@jolibox/implement 1.1.53-beta.0 → 1.1.54

package/src/common/rewards/registers/use-gem-only.ts

@@ -1,58 +0,0 @@
-import { IHttpClient } from '@/common/http';
-import { IAdBreakParams } from '@/common/ads';
-import { createCommonGemRewardHandler } from './utils/coins/joligem/gem-handler';
-import { unlockOptionsHandler } from './utils/common';
-import {
-  createShowUnlockWithCurrencyModal,
-  createInitiateAndAwaitPayment,
-  createShowUnloginModal
-} from './utils/coins/commands';
-
-export type GemOnlyRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
-export const createGemOnlyRewardHandler = (
-  httpClient: IHttpClient,
-  {
-    onUnlockSuccess,
-    onUnlockFailed
-  }: {
-    onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
-    onUnlockFailed?: () => void;
-  }
-): GemOnlyRewardsHandler => {
-  const handleUnlockFailed = (() => (params: IAdBreakParams) => {
-    onUnlockFailed?.();
-    params.adBreakDone?.({
-      breakType: params.type,
-      breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
-      breakStatus: 'noAdPreloaded'
-    });
-  })();
-
-  const showUnlockWithGemModal = createShowUnlockWithCurrencyModal('JOLI_GEM', {
-    confirmButtonText: 'gem.useGem',
-    cancelButtonText: 'gem.noThanks'
-  });
-
-  const initiateAndAwaitPayment = createInitiateAndAwaitPayment('JOLI_GEM', {
-    confirmButtonText: 'gem.payAndUnlock',
-    cancelButtonText: 'gem.noThanks'
-  });
-
-  const showUnloginModal = createShowUnloginModal('JOLI_GEM', {
-    confirmButtonText: 'loginGuide.login',
-    cancelButtonText: 'loginGuide.noThanks'
-  });
-
-  const gemOnlyRewardHandler = createCommonGemRewardHandler('JOLI_GEM', httpClient, {
-    handlers: {
-      handleUnlockSuccess: onUnlockSuccess,
-      handleUnlockFailed,
-      unlockOptionsHandler,
-      initiateAndAwaitPayment,
-      showUnlockWithCurrencyModal: showUnlockWithGemModal,
-      showUnloginModal
-    }
-  });
-
-  return gemOnlyRewardHandler;
-};

package/src/common/rewards/registers/use-gem.ts

@@ -1,53 +0,0 @@
-import { IHttpClient } from '@/common/http';
-import { IAdBreakParams } from '@/common/ads';
-import { unlockOptionsHandler } from './utils/common';
-import { createCommonGemRewardHandler } from './utils/coins/joligem/gem-handler';
-import {
-  createShowUnlockWithCurrencyModal,
-  createInitiateAndAwaitPayment,
-  createShowUnloginModal
-} from './utils/coins/commands';
-
-export type GemRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
-export const createGemRewardHandler = (
-  httpClient: IHttpClient,
-  {
-    onUnlockSuccess,
-    onUnlockFailed
-  }: {
-    onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
-    onUnlockFailed?: () => void;
-  }
-): GemRewardsHandler => {
-  const handleUnlockFailed = () => {
-    onUnlockFailed?.();
-  };
-
-  const showUnlockWithGemModal = createShowUnlockWithCurrencyModal('ADS-JOLI_GEM', {
-    confirmButtonText: 'gem.useGem',
-    cancelButtonText: 'gem.noWatchAds'
-  });
-
-  const initiateAndAwaitPayment = createInitiateAndAwaitPayment('ADS-JOLI_GEM', {
-    confirmButtonText: 'gem.payAndUnlock',
-    cancelButtonText: 'gem.noWatchAds'
-  });
-
-  const showUnloginModal = createShowUnloginModal('ADS-JOLI_GEM', {
-    confirmButtonText: 'loginGuide.login',
-    cancelButtonText: 'loginGuide.noWatchAds'
-  });
-
-  const gemRewardHandler = createCommonGemRewardHandler('ADS-JOLI_GEM', httpClient, {
-    handlers: {
-      handleUnlockSuccess: onUnlockSuccess,
-      handleUnlockFailed,
-      unlockOptionsHandler,
-      initiateAndAwaitPayment,
-      showUnlockWithCurrencyModal: showUnlockWithGemModal,
-      showUnloginModal
-    }
-  });
-
-  return gemRewardHandler;
-};

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

@@ -1,48 +0,0 @@
-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')?.joliGemChoices?.joliGemQuantity ??
-      0,
-    getCurrentUser: (unlockOptions) => unlockOptions?.userGem ?? { balance: 0, enableAutoDeduct: false },
-    createUpdatedUser: (balance, enableAutoDeduct) => ({ balance, enableAutoDeduct }),
-    getUpdateKey: () => 'userGem',
-    isEnough: (unlockOptions, user) =>
-      unlockOptions?.options?.some(
-        (option) =>
-          option.type === 'JOLI_GEM' && (option.joliGemChoices?.joliGemQuantity ?? 0) <= (user?.balance ?? 0)
-      ) ?? false
-  }
-};

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

@@ -1,23 +0,0 @@
-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/jolicoin/jolicoin-handler.ts

@@ -1,149 +0,0 @@
-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: {
-          // TODO: support drama
-          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);
-};

package/src/common/rewards/registers/utils/coins/joligem/fetch-gem-balance.ts

@@ -1,15 +0,0 @@
-import { IHttpClient } from '@/common/http';
-import { StandardResponse } from '@jolibox/types';
-
-export const fetchGemBalance = async (httpClient: IHttpClient) => {
-  const res = await httpClient.get<
-    StandardResponse<{
-      balance: number;
-    }>
-  >('/api/joli-gem/balance', {
-    query: {
-      type: 'GEM'
-    }
-  });
-  return res.data;
-};

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

@@ -1,131 +0,0 @@
-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 } from '../currency-config';
-
-import {
-  createInitiateAndAwaitPayment,
-  registerUsePaymentCommand,
-  registerUseUnloginCommand,
-  createShowUnloginModal
-} from '../commands';
-import { registerUseJolicoinCommand, createShowUnlockWithCurrencyModal } from '../commands/use-jolicoin';
-import { rewardsCommands } from '../rewards-command';
-import { RewardsCommandType } from '@jolibox/types';
-
-interface IGemUnlockRes {
-  code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
-  message: string;
-  data: {
-    transactionId: string;
-    quantity: number;
-    balance: number;
-  };
-}
-
-export const createCommonGemRewardHandler = (
-  type: 'JOLI_GEM' | 'ADS-JOLI_GEM',
-  httpClient: IHttpClient,
-  {
-    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>;
-    };
-  }
-) => {
-  // register commands
-  registerUseUnloginCommand(type, 'JOLI_GEM', {
-    httpClient: httpClient,
-    showUnloginModal: showUnloginModal
-  });
-  registerUsePaymentCommand(type, 'JOLI_GEM', {
-    httpClient: httpClient,
-    initiateAndAwaitPayment: initiateAndAwaitPayment
-  });
-  registerUseJolicoinCommand(type, 'JOLI_GEM', {
-    showUnlockWithCurrencyModal: 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['GEM'];
-      const unlockWithGem = await httpClient.post<IGemUnlockRes>(config.unlockEndpoint, {
-        data: {
-          // TODO: support drama
-          type: 'GAME_REWARD',
-          reqId: `${uuidv4()}-${context.mpType}-${Date.now()}`,
-          gameInfo: {
-            gameId: context.mpId
-          }
-        }
-      });
-
-      console.log('-----unlockWithGem request result-----', unlockWithGem);
-      if (unlockWithGem.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('-----unlockWithGem adBreakDone error-----', e);
-        }
-
-        handleUnlockSuccess?.({
-          quantity: unlockWithGem.data.quantity,
-          balance: unlockWithGem.data.balance
-        });
-        return true;
-      }
-      handleUnlockFailed?.(params);
-      return false;
-    } catch (e) {
-      console.info(`GemRewardHandler 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();
-    }
-  };
-};