@jolibox/implement 1.1.56 → 1.2.1

package/src/common/rewards/registers/utils/coins/commands/currency-handlers.ts

@@ -0,0 +1,50 @@
+import { IHttpClient } from '@/common/http';
+import { IJoliCoin, IGem } from '@/common/rewards/type';
+import { IUnlockOptionsEvent } from '@/common/rewards/reward-emitter';
+import { fetchBalance as fetchJoliCoinBalance } from '../jolicoin/fetch-balance';
+import { fetchGemBalance } from '../joligem/fetch-gem-balance';
+
+export type CurrencyType = 'JOLI_COIN' | 'JOLI_GEM';
+
+export interface CurrencyHandler {
+  fetchBalance: (httpClient: IHttpClient) => Promise<{ balance: number } | undefined>;
+  getQuantity: (unlockOptions: IUnlockOptionsEvent | null) => number;
+  getCurrentUser: (unlockOptions: IUnlockOptionsEvent | null) => IJoliCoin | IGem;
+  createUpdatedUser: (balance: number, enableAutoDeduct: boolean) => IJoliCoin | IGem;
+  getUpdateKey: () => keyof Pick<IUnlockOptionsEvent, 'userJoliCoin' | 'userGem'>;
+  isEnough: (unlockOptions: IUnlockOptionsEvent | null, user: IJoliCoin | IGem) => boolean;
+}
+
+export const CURRENCY_HANDLERS: Record<CurrencyType, CurrencyHandler> = {
+  JOLI_COIN: {
+    fetchBalance: fetchJoliCoinBalance,
+    getQuantity: (unlockOptions) =>
+      unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
+        .joliCoinQuantity ?? 0,
+    getCurrentUser: (unlockOptions) => unlockOptions?.userJoliCoin ?? { balance: 0, enableAutoDeduct: false },
+    createUpdatedUser: (balance, enableAutoDeduct) => ({ balance, enableAutoDeduct }),
+    getUpdateKey: () => 'userJoliCoin',
+    isEnough: (unlockOptions, user) =>
+      unlockOptions?.options?.some(
+        (option) =>
+          option.type === 'JOLI_COIN' &&
+          option.joliCoinChoices.some((choice) => choice.joliCoinQuantity <= (user?.balance ?? 0))
+      ) ?? false
+  },
+  JOLI_GEM: {
+    fetchBalance: fetchGemBalance,
+    getQuantity: (unlockOptions) =>
+      unlockOptions?.options?.find((option) => option.type === 'JOLI_GEM')?.joliGemChoice?.joliGemQuantity ??
+      0,
+    getCurrentUser: (unlockOptions) => unlockOptions?.userGem ?? { balance: 0, enableAutoDeduct: false },
+    createUpdatedUser: (balance, enableAutoDeduct) => ({ balance, enableAutoDeduct }),
+    getUpdateKey: () => 'userGem',
+    isEnough: (unlockOptions, user) => {
+      const joliGemConfig = unlockOptions?.options.find((option) => option.type === 'JOLI_GEM');
+      if (joliGemConfig) {
+        return (joliGemConfig.joliGemChoice?.joliGemQuantity ?? 0) <= (user?.balance ?? 0);
+      }
+      return false;
+    }
+  }
+};

package/src/common/rewards/registers/utils/coins/commands/index.ts

@@ -1,3 +1,3 @@
-export { registerUseJolicoinCommand, createShowUnlockWithJolicoinModal } from './use-jolicoin';
+export { registerUseJolicoinCommand, createShowUnlockWithCurrencyModal } from './use-jolicoin';
 export { registerUsePaymentCommand, createInitiateAndAwaitPayment } from './use-payment';
 export { registerUseUnloginCommand, createShowUnloginModal } from './use-unlogin';

package/src/common/rewards/registers/utils/coins/commands/use-jolicoin.ts

@@ -1,33 +1,39 @@
-import { IJoliCoin } from '@/common/rewards/type';
+import { IGem, IJoliCoin } from '@/common/rewards/type';
 import { rewardsCommands } from '../rewards-command';
 import { unlockOptionsHandler } from '@/common/rewards/registers/utils/common';
 import { createEventPromiseHandler } from '../../event-listener';
 import { IUseModalResultEvent, UseModalResultEventName } from '@/common/rewards/reward-emitter';
 import { rewardsEmitter, UseModalEventName } from '@/common/rewards/reward-emitter';
+import { CURRENCY_HANDLERS } from './currency-handlers';
 
-export const registerUseJolicoinCommand = (
-  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+export const registerUseJolicoinCommand = <T extends IJoliCoin | IGem>(
+  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
+  currency: 'JOLI_COIN' | 'JOLI_GEM',
   params: {
-    showUnlockWithJolicoinModal: (params: {
+    showUnlockWithCurrencyModal: (params: {
       enableAutoDeduct: boolean;
-      userJoliCoin: IJoliCoin;
-      joliCoinQuantity: number;
+      userCurrency: T;
+      quantity: number;
+      currency: T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM';
     }) => Promise<'CONFIRM' | 'CANCEL' | 'FAILED'>;
   }
 ) => {
-  const { showUnlockWithJolicoinModal } = params;
+  const { showUnlockWithCurrencyModal } = params;
   rewardsCommands.registerCommand(`Rewards.${prefix}.useJolicoin`, async () => {
     const unlockOptions = await unlockOptionsHandler.getData();
-    const enableAutoDeduct = !!unlockOptions?.userJoliCoin?.enableAutoDeduct;
-    const joliCoinQuantity =
-      unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
-        .joliCoinQuantity ?? 0;
+
+    // Use currency handler for unified logic
+    const handler = CURRENCY_HANDLERS[currency];
+    const currentUser = handler.getCurrentUser(unlockOptions);
+    const joliCoinQuantity = handler.getQuantity(unlockOptions);
+    const enableAutoDeduct = !!currentUser?.enableAutoDeduct;
 
     console.log('-----unlockOptions usemodal-----', unlockOptions, enableAutoDeduct, joliCoinQuantity);
-    const shouldUnlock = await showUnlockWithJolicoinModal({
+    const shouldUnlock = await showUnlockWithCurrencyModal({
       enableAutoDeduct,
-      userJoliCoin: unlockOptions?.userJoliCoin,
-      joliCoinQuantity
+      userCurrency: currentUser as T,
+      quantity: joliCoinQuantity,
+      currency: currency as T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM'
     });
 
     if (shouldUnlock !== 'CONFIRM') {
@@ -42,22 +48,28 @@ export const registerUseJolicoinCommand = (
 };
 
 // EVENTS
-export const createShowUnlockWithJolicoinModal = (
-  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+export const createShowUnlockWithCurrencyModal = <T extends IJoliCoin | IGem>(
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
   buttons: {
     confirmButtonText: string;
     cancelButtonText: string;
   }
 ) => {
-  return async (params: { enableAutoDeduct: boolean; userJoliCoin: IJoliCoin; joliCoinQuantity: number }) => {
+  return async (params: {
+    enableAutoDeduct: boolean;
+    userCurrency: T;
+    quantity: number;
+    currency: T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM';
+  }) => {
     const modalHandler = createEventPromiseHandler<IUseModalResultEvent, typeof UseModalResultEventName>(
       rewardsEmitter,
       UseModalResultEventName
     );
     rewardsEmitter.emit(UseModalEventName, type, {
       enableAutoDeduct: params.enableAutoDeduct,
-      userJoliCoin: params.userJoliCoin,
-      joliCoinQuantity: params.joliCoinQuantity,
+      userCurrency: params.userCurrency as T,
+      quantity: params.quantity,
+      currency: params.currency,
       confirmButtonText: buttons.confirmButtonText,
       cancelButtonText: buttons.cancelButtonText
     });

package/src/common/rewards/registers/utils/coins/commands/use-payment.ts

@@ -1,9 +1,7 @@
-import { IJoliCoin } from '@/common/rewards/type';
-import { fetchBalance } from '../fetch-balance';
+import { IJoliCoin, IGem } from '@/common/rewards/type';
 import { rewardsCommands } from '../rewards-command';
 import { IHttpClient } from '@/common/http';
 import { unlockOptionsHandler } from '../../common';
-import { joliCoinIsEnough } from '../../index';
 import { rewardsEmitter } from '@/common/rewards/reward-emitter';
 import { createEventPromiseHandler } from '../../event-listener';
 import {
@@ -11,39 +9,43 @@ import {
   PaymentResultEventName,
   InvokePaymentEventName
 } from '@/common/rewards/reward-emitter';
+import { CURRENCY_HANDLERS, CurrencyType } from './currency-handlers';
 
-export const registerUsePaymentCommand = (
-  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+export const registerUsePaymentCommand = <T extends IJoliCoin | IGem>(
+  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
+  currency: 'JOLI_COIN' | 'JOLI_GEM',
   params: {
     httpClient: IHttpClient;
     initiateAndAwaitPayment: (params: {
-      userJoliCoin: IJoliCoin;
-      joliCoinQuantity: number;
+      userCurrency: T;
+      currencyQuantity: number;
+      currency: T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM';
     }) => Promise<'SUCCESS' | 'FAILED' | 'CANCEL'>;
   }
 ) => {
   const { httpClient, initiateAndAwaitPayment } = params;
   rewardsCommands.registerCommand(`Rewards.${prefix}.usePayment`, async () => {
     const unlockOptions = await unlockOptionsHandler.getData();
-    const newBalance = await fetchBalance(httpClient);
-    const joliCoinQuantity =
-      unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
-        .joliCoinQuantity ?? 0;
 
-    const newJoliCoin = {
-      balance: newBalance?.balance ?? 0,
-      enableAutoDeduct: unlockOptions?.userJoliCoin?.enableAutoDeduct ?? false
-    };
+    // Use currency handler for balance and quantity calculation
+    const handler = CURRENCY_HANDLERS[currency as CurrencyType];
+    const newBalance = await handler.fetchBalance(httpClient);
+    const currencyQuantity = handler.getQuantity(unlockOptions);
+    const currentUser = handler.getCurrentUser(unlockOptions);
+
+    const newUser = handler.createUpdatedUser(newBalance?.balance ?? 0, currentUser.enableAutoDeduct);
 
+    const updateKey = handler.getUpdateKey();
     unlockOptionsHandler.updateData({
-      userJoliCoin: newJoliCoin
+      [updateKey]: newUser
     });
 
-    console.log('-----unlockOptions payment-----', unlockOptions, newJoliCoin, joliCoinQuantity);
-    if (!joliCoinIsEnough(unlockOptions?.options || [], newJoliCoin)) {
+    console.log('-----unlockOptions payment-----', unlockOptions, newUser, currencyQuantity, currency);
+    if (!handler.isEnough(unlockOptions, newUser)) {
       const paymentResult = await initiateAndAwaitPayment({
-        userJoliCoin: newJoliCoin,
-        joliCoinQuantity
+        userCurrency: newUser as T,
+        currencyQuantity,
+        currency: currency as T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM'
       });
 
       return {
@@ -58,22 +60,27 @@ export const registerUsePaymentCommand = (
 
 // events
 export const createInitiateAndAwaitPayment = (
-  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
   buttons: {
     confirmButtonText: string;
     cancelButtonText: string;
   }
 ) => {
-  return async (params: { userJoliCoin: IJoliCoin; joliCoinQuantity: number }) => {
+  return async <T extends IJoliCoin | IGem>(params: {
+    userCurrency: T;
+    currencyQuantity: number;
+    currency: T extends IJoliCoin ? 'JOLI_COIN' : 'JOLI_GEM';
+  }) => {
     const paymentHandler = createEventPromiseHandler<IPaymentEvent, typeof PaymentResultEventName>(
       rewardsEmitter,
       PaymentResultEventName
     );
 
     rewardsEmitter.emit(InvokePaymentEventName, type, {
-      userJoliCoin: params.userJoliCoin,
-      joliCoinQuantity: params.joliCoinQuantity,
-      enableAutoDeduct: params.userJoliCoin.enableAutoDeduct,
+      userCurrency: params.userCurrency as T,
+      quantity: params.currencyQuantity,
+      currency: params.currency,
+      enableAutoDeduct: params.userCurrency.enableAutoDeduct,
       confirmButtonText: buttons.confirmButtonText,
       cancelButtonText: buttons.cancelButtonText
     });

package/src/common/rewards/registers/utils/coins/commands/use-unlogin.ts

@@ -3,23 +3,21 @@ import { rewardsCommands } from '../rewards-command';
 import { createEventPromiseHandler } from '../../event-listener';
 import { IUseUnloginModalResultEvent, UseUnloginModalResultEventName } from '@/common/rewards/reward-emitter';
 import { rewardsEmitter, InvokeUnloginModalEventName } from '@/common/rewards/reward-emitter';
-import { createToast } from '@jolibox/ui';
 import { sleep } from '@jolibox/common';
-import { fetchBalance } from '../fetch-balance';
 import { IHttpClient } from '@/common/http';
 import { unlockOptionsHandler } from '../../common';
+import { CURRENCY_HANDLERS, CurrencyType } from './currency-handlers';
 
 export const registerUseUnloginCommand = (
-  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  prefix: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
+  currency: 'JOLI_COIN' | 'JOLI_GEM',
   params: {
     httpClient: IHttpClient;
-    showUnloginModal: () => Promise<{
+    showUnloginModal: (currency: 'JOLI_COIN' | 'JOLI_GEM') => Promise<{
       result: 'CANCEL' | 'FAILED' | 'SUCCESS' | 'ADS' | 'NOT_SUPPORT';
       rewards?: {
-        jolicoin?: {
-          isFirstLogin: boolean;
-          claimedRewardValue: number;
-        };
+        isFirstLogin: boolean;
+        claimedRewardValue: number;
       };
     }>;
   }
@@ -30,7 +28,7 @@ export const registerUseUnloginCommand = (
     const unlockOptions = await unlockOptionsHandler.getData();
     console.log('-----isLogin-----', !!isLogin);
     if (!isLogin) {
-      const unloginModalResult = await showUnloginModal();
+      const unloginModalResult = await showUnloginModal(currency);
 
       console.log('-----unloginModalResult-----', unloginModalResult);
       if (unloginModalResult.result == 'FAILED' || unloginModalResult.result == 'CANCEL') {
@@ -39,27 +37,26 @@ export const registerUseUnloginCommand = (
         };
       }
 
-      const { isFirstLogin, claimedRewardValue } = unloginModalResult.rewards?.jolicoin ?? {};
+      const { isFirstLogin, claimedRewardValue } = unloginModalResult.rewards ?? {};
       if (unloginModalResult.result == 'SUCCESS') {
         if (isFirstLogin && claimedRewardValue) {
           await sleep(3000); // wait for center toast to show
         }
 
-        //check balance
-        const newBalance = await fetchBalance(httpClient);
-        const joliCoinQuantity =
-          unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
-            .joliCoinQuantity ?? 0;
+        //check balance using currency handler
+        const handler = CURRENCY_HANDLERS[currency as CurrencyType];
+        const newBalance = await handler.fetchBalance(httpClient);
+        const currencyQuantity = handler.getQuantity(unlockOptions);
+        const currentUser = handler.getCurrentUser(unlockOptions);
 
-        const newJoliCoin = {
-          balance: newBalance?.balance ?? 0,
-          enableAutoDeduct: unlockOptions?.userJoliCoin?.enableAutoDeduct ?? false
-        };
+        const newUser = handler.createUpdatedUser(newBalance?.balance ?? 0, currentUser.enableAutoDeduct);
 
+        const updateKey = handler.getUpdateKey();
         unlockOptionsHandler.updateData({
-          userJoliCoin: newJoliCoin
+          [updateKey]: newUser
         });
-        if (newJoliCoin.balance >= joliCoinQuantity) {
+
+        if (newUser.balance >= currencyQuantity) {
           return {
             result: 'SUCCESS'
           };
@@ -75,20 +72,21 @@ export const registerUseUnloginCommand = (
 //EVENTS
 
 export const createShowUnloginModal = (
-  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM',
   buttons: {
     confirmButtonText: string;
     cancelButtonText: string;
   }
 ) => {
-  return async () => {
+  return async (currency: 'JOLI_COIN' | 'JOLI_GEM') => {
     const modalHandler = createEventPromiseHandler<
       IUseUnloginModalResultEvent,
       typeof UseUnloginModalResultEventName
     >(rewardsEmitter, UseUnloginModalResultEventName);
     rewardsEmitter.emit(InvokeUnloginModalEventName, type, {
       confirmButtonText: buttons.confirmButtonText,
-      cancelButtonText: buttons.cancelButtonText
+      cancelButtonText: buttons.cancelButtonText,
+      currency
     });
     const modalResult = await modalHandler.getFreshData();
     return modalResult;

package/src/common/rewards/registers/utils/coins/currency-config.ts

@@ -0,0 +1,23 @@
+export type CurrencyType = 'JOLI_COIN' | 'GEM';
+
+export interface CurrencyConfig {
+  balanceEndpoint: string;
+  unlockEndpoint: string;
+  balanceDetailEndpoint: string;
+  unlockType: string;
+}
+
+export const CURRENCY_CONFIG: Record<CurrencyType, CurrencyConfig> = {
+  JOLI_COIN: {
+    balanceEndpoint: '/api/joli-coin/balance',
+    balanceDetailEndpoint: '/api/joli-coin/balance-detail',
+    unlockEndpoint: '/api/joli-coin/unlock',
+    unlockType: 'JOLI_COIN'
+  },
+  GEM: {
+    balanceEndpoint: '/api/joli-gem/balance',
+    balanceDetailEndpoint: '/api/joli-gem/balance-detail',
+    unlockEndpoint: '/api/joli-gem/unlock',
+    unlockType: 'GEM'
+  }
+};

package/src/common/rewards/registers/utils/coins/index.ts

@@ -1,139 +1,2 @@
-import { IHttpClient } from '@/common/http';
-import { context } from '@/common/context';
-import { uuidv4 } from '@jolibox/common';
-import { UnlockOptionsEventName, IUnlockOptionsEvent } from '@/common/rewards/reward-emitter';
-import { IAdBreakParams } from '@/common/ads';
-import { EventPromiseHandler } from '../event-listener';
-
-import {
-  createInitiateAndAwaitPayment,
-  registerUseJolicoinCommand,
-  registerUsePaymentCommand,
-  registerUseUnloginCommand,
-  createShowUnlockWithJolicoinModal,
-  createShowUnloginModal
-} from './commands';
-import { rewardsCommands } from './rewards-command';
-import { RewardsCommandType } from '@jolibox/types';
-
-interface IJolicoinUnlockRes {
-  code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
-  message: string;
-  data: {
-    transactionId: string;
-    quantity: number;
-    balance: number;
-  };
-}
-
-export const createCommonJolicoinRewardHandler = (
-  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
-  httpClient: IHttpClient,
-  {
-    handlers: {
-      handleUnlockSuccess,
-      handleUnlockFailed,
-      unlockOptionsHandler,
-      initiateAndAwaitPayment,
-      showUnlockWithJolicoinModal,
-      showUnloginModal
-    }
-  }: {
-    handlers: {
-      handleUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
-      handleUnlockFailed?: (params: IAdBreakParams) => void;
-      unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
-      initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
-      showUnlockWithJolicoinModal: ReturnType<typeof createShowUnlockWithJolicoinModal>;
-      showUnloginModal: ReturnType<typeof createShowUnloginModal>;
-    };
-  }
-) => {
-  // register commands
-  registerUseUnloginCommand(type, {
-    httpClient: httpClient,
-    showUnloginModal: showUnloginModal
-  });
-  registerUsePaymentCommand(type, {
-    httpClient: httpClient,
-    initiateAndAwaitPayment: initiateAndAwaitPayment
-  });
-  registerUseJolicoinCommand(type, {
-    showUnlockWithJolicoinModal: showUnlockWithJolicoinModal
-  });
-
-  const targetABTest = context.abTests.find((abTest) => abTest.startsWith('coinOpt_v1'));
-  let commands = [];
-  if (targetABTest) {
-    commands = [`Rewards.${type}.usePayment`, `Rewards.${type}.useJolicoin`];
-  } else {
-    commands = [
-      `Rewards.${type}.useUnloginModal`,
-      `Rewards.${type}.usePayment`,
-      `Rewards.${type}.useJolicoin`
-    ];
-  }
-  return async (params: IAdBreakParams) => {
-    try {
-      let result = true;
-      for (const command of commands) {
-        const commandResult = await rewardsCommands.executeCommand(command as RewardsCommandType);
-        result = result && commandResult.result !== 'FAILED';
-        if (commandResult.result !== 'CONTINUE') {
-          break;
-        }
-      }
-
-      if (!result) {
-        handleUnlockFailed?.(params);
-        return false;
-      }
-
-      const unlockWithJolicoin = await httpClient.post<IJolicoinUnlockRes>('/api/joli-coin/unlock', {
-        data: {
-          // TODO: support drama
-          type: 'GAME_REWARD',
-          reqId: `${uuidv4()}-${context.mpType}-${Date.now()}`,
-          gameInfo: {
-            gameId: context.mpId
-          }
-        }
-      });
-
-      console.log('-----unlockWithJolicoin request result-----', unlockWithJolicoin);
-      if (unlockWithJolicoin.code == 'SUCCESS') {
-        try {
-          params.adBreakDone?.({
-            breakType: params.type,
-            breakName: 'name' in params ? params.name ?? '' : '',
-            breakFormat: 'reward',
-            breakStatus: 'viewed'
-          });
-          if ('adViewed' in params) {
-            params.adViewed?.();
-          }
-        } catch (e) {
-          console.error('-----unlockWithJolicoin adBreakDone error-----', e);
-        }
-
-        handleUnlockSuccess?.({
-          quantity: unlockWithJolicoin.data.quantity,
-          balance: unlockWithJolicoin.data.balance
-        });
-        return true;
-      }
-      handleUnlockFailed?.(params);
-      return false;
-    } catch (e) {
-      console.info(`JolicoinRewardHandler error:`, e);
-      if (e instanceof Error && e.message == 'CANCEL') {
-        // Cancel should terminate the reward handler, invoke unlock failed
-        throw e;
-      }
-      handleUnlockFailed?.(params);
-      return false;
-    } finally {
-      unlockOptionsHandler.clearCache();
-    }
-  };
-};
+export { createCommonJolicoinRewardHandler } from './jolicoin/jolicoin-handler';
+export { createCommonGemRewardHandler } from './joligem/gem-handler';

package/src/common/rewards/registers/utils/coins/jolicoin/jolicoin-handler.ts

@@ -0,0 +1,148 @@
+import { IHttpClient } from '@/common/http';
+import { context } from '@/common/context';
+import { uuidv4 } from '@jolibox/common';
+import { UnlockOptionsEventName, IUnlockOptionsEvent } from '@/common/rewards/reward-emitter';
+import { IAdBreakParams } from '@/common/ads';
+import { EventPromiseHandler } from '../../event-listener';
+import { CURRENCY_CONFIG, CurrencyType } from '../currency-config';
+
+import {
+  createInitiateAndAwaitPayment,
+  registerUseJolicoinCommand,
+  registerUsePaymentCommand,
+  registerUseUnloginCommand,
+  createShowUnlockWithCurrencyModal,
+  createShowUnloginModal
+} from '../commands';
+import { rewardsCommands } from '../rewards-command';
+import { RewardsCommandType } from '@jolibox/types';
+
+interface ICurrencyUnlockRes {
+  code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
+  message: string;
+  data: {
+    transactionId: string;
+    quantity: number;
+    balance: number;
+  };
+}
+
+const createCommonCurrencyRewardHandler = (
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  httpClient: IHttpClient,
+  currencyType: CurrencyType,
+  {
+    handlers: {
+      handleUnlockSuccess,
+      handleUnlockFailed,
+      unlockOptionsHandler,
+      initiateAndAwaitPayment,
+      showUnlockWithCurrencyModal,
+      showUnloginModal
+    }
+  }: {
+    handlers: {
+      handleUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+      handleUnlockFailed?: (params: IAdBreakParams) => void;
+      unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
+      initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
+      showUnlockWithCurrencyModal: ReturnType<typeof createShowUnlockWithCurrencyModal>;
+      showUnloginModal: ReturnType<typeof createShowUnloginModal>;
+    };
+  }
+) => {
+  // registerUseUnloginCommand(type, 'JOLI_COIN', {
+  //   httpClient: httpClient,
+  //   showUnloginModal: showUnloginModal
+  // });
+  registerUsePaymentCommand(type, 'JOLI_COIN', {
+    httpClient: httpClient,
+    initiateAndAwaitPayment: initiateAndAwaitPayment
+  });
+  registerUseJolicoinCommand(type, 'JOLI_COIN', {
+    showUnlockWithCurrencyModal
+  });
+
+  const commands = [`Rewards.${type}.usePayment`, `Rewards.${type}.useJolicoin`];
+  return async (params: IAdBreakParams) => {
+    try {
+      let result = true;
+      for (const command of commands) {
+        const commandResult = await rewardsCommands.executeCommand(command as RewardsCommandType);
+        result = result && commandResult.result !== 'FAILED';
+        if (commandResult.result !== 'CONTINUE') {
+          break;
+        }
+      }
+
+      if (!result) {
+        handleUnlockFailed?.(params);
+        return false;
+      }
+
+      const config = CURRENCY_CONFIG[currencyType];
+      const unlockWithCurrency = await httpClient.post<ICurrencyUnlockRes>(config.unlockEndpoint, {
+        data: {
+          type: 'GAME_REWARD',
+          reqId: `${uuidv4()}-${context.mpType}-${Date.now()}`,
+          gameInfo: {
+            gameId: context.mpId
+          }
+        }
+      });
+
+      console.log('-----unlockWithCurrency request result-----', unlockWithCurrency);
+      if (unlockWithCurrency.code == 'SUCCESS') {
+        try {
+          params.adBreakDone?.({
+            breakType: params.type,
+            breakName: 'name' in params ? params.name ?? '' : '',
+            breakFormat: 'reward',
+            breakStatus: 'viewed'
+          });
+          if ('adViewed' in params) {
+            params.adViewed?.();
+          }
+        } catch (e) {
+          console.error('-----unlockWithJolicoin adBreakDone error-----', e);
+        }
+
+        handleUnlockSuccess?.({
+          quantity: unlockWithCurrency.data.quantity,
+          balance: unlockWithCurrency.data.balance
+        });
+        return true;
+      }
+      handleUnlockFailed?.(params);
+      return false;
+    } catch (e) {
+      console.info(`JolicoinRewardHandler error:`, e);
+      if (e instanceof Error && e.message == 'CANCEL') {
+        // Cancel should terminate the reward handler, invoke unlock failed
+        throw e;
+      }
+      handleUnlockFailed?.(params);
+      return false;
+    } finally {
+      unlockOptionsHandler.clearCache();
+    }
+  };
+};
+
+// 向后兼容的 jolicoin 处理器
+export const createCommonJolicoinRewardHandler = (
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
+  httpClient: IHttpClient,
+  config: {
+    handlers: {
+      handleUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+      handleUnlockFailed?: (params: IAdBreakParams) => void;
+      unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
+      initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
+      showUnlockWithCurrencyModal: ReturnType<typeof createShowUnlockWithCurrencyModal>;
+      showUnloginModal: ReturnType<typeof createShowUnloginModal>;
+    };
+  }
+) => {
+  return createCommonCurrencyRewardHandler(type, httpClient, 'JOLI_COIN', config);
+};