@jolibox/implement 1.2.3 → 1.2.5-beta.3

package/src/native/payment/payment-service.ts

@@ -0,0 +1,293 @@
+import { IPaymentChoice } from '@/common/rewards/reward-emitter';
+import { paymentHelper } from './index';
+import { isUndefinedOrNull } from '@jolibox/common';
+import { StandardResponse } from '@jolibox/types';
+import { applyNative } from '@jolibox/native-bridge';
+import { innerFetch as fetch } from '@/native/network';
+import type { PaymentResult } from './payment-helper';
+import { RequestCacheService, RequestAdapter } from '@jolibox/common';
+
+type PaymentPurchaseType = 'JOLI_COIN' | 'JOLI_GEM';
+
+// Request/Response interfaces for RequestCacheService
+
+type PaymentRequest = Record<string, never>;
+
+interface PaymentResponse {
+  balance: number;
+  enableAutoDeduct: boolean;
+  paymentChoices: IPaymentChoice[];
+}
+
+interface PaymentCacheData {
+  paymentChoices: IPaymentChoice[];
+}
+
+interface PaymentRealTimeData {
+  balance: number;
+  enableAutoDeduct: boolean;
+}
+
+// Utility function for merging response data
+function 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[];
+}
+
+// Payment Request Adapter for RequestCacheService
+class PaymentRequestAdapter
+  implements RequestAdapter<PaymentRequest, PaymentResponse, PaymentCacheData, PaymentRealTimeData>
+{
+  // applyNative 的缓存
+  private static nativePriceCache = new Map<string, { [appStoreProductId: string]: { price: string } }>();
+  private static readonly NATIVE_PRICE_CACHE_DURATION = 30 * 60 * 1000; // 30分钟缓存
+  private static nativePriceCacheTimestamp = new Map<string, number>();
+
+  async execute(endpoint: string, _options?: PaymentRequest): Promise<PaymentResponse> {
+    // 获取服务端数据（余额等实时数据）
+    const { response } = await fetch<StandardResponse<PaymentResponse>>(endpoint, {
+      method: 'GET',
+      appendHostCookie: true,
+      responseType: 'json'
+    });
+
+    console.log('[PaymentService] get products info from server', endpoint, response.data);
+
+    if (!response.data?.data) {
+      throw new Error('get products info failed');
+    }
+
+    const serverData = response.data.data;
+
+    const appStoreProductIds =
+      serverData.paymentChoices
+        ?.filter((choice) => typeof choice.appStoreProductId === 'string')
+        .map((choice) => choice.appStoreProductId as string) ?? [];
+
+    if (appStoreProductIds.length > 0) {
+      const nativeData = await this.getNativePriceData(appStoreProductIds);
+      if (nativeData) {
+        mergeResponseData(serverData, nativeData);
+      }
+    }
+
+    if (serverData.paymentChoices.length === 0) {
+      throw new Error('paymentChoices is empty');
+    }
+
+    return serverData;
+  }
+
+  private async getNativePriceData(
+    appStoreProductIds: string[]
+  ): Promise<{ [appStoreProductId: string]: { price: string } } | null> {
+    // 检查缓存
+    const cacheKey = appStoreProductIds.sort().join(',');
+    const cached = PaymentRequestAdapter.nativePriceCache.get(cacheKey);
+    const cacheTime = PaymentRequestAdapter.nativePriceCacheTimestamp.get(cacheKey) || 0;
+
+    if (cached && Date.now() - cacheTime < PaymentRequestAdapter.NATIVE_PRICE_CACHE_DURATION) {
+      console.log('[PaymentService] Using cached native price data');
+      return cached;
+    }
+
+    console.log('[PaymentService] Fetching fresh native price data');
+
+    try {
+      const { data } = await applyNative('requestProductDetailsAsync', {
+        appStoreProductIds
+      });
+
+      if (data) {
+        // cache
+        PaymentRequestAdapter.nativePriceCache.set(cacheKey, data);
+        PaymentRequestAdapter.nativePriceCacheTimestamp.set(cacheKey, Date.now());
+      }
+
+      return data;
+    } catch (error) {
+      console.warn('[PaymentService] Failed to fetch native product details:', error);
+      throw error; // rethrow error, let upper layer handle it
+    }
+  }
+
+  extractCacheableData(response: PaymentResponse): PaymentCacheData {
+    return {
+      paymentChoices: response.paymentChoices
+    };
+  }
+
+  extractRealTimeData?: undefined;
+  mergeData(cached: PaymentCacheData, realTime: PaymentRealTimeData): PaymentResponse {
+    return {
+      balance: realTime.balance,
+      enableAutoDeduct: realTime.enableAutoDeduct,
+      paymentChoices: cached.paymentChoices
+    };
+  }
+
+  processCachedData(cached: PaymentCacheData): PaymentResponse {
+    // when only cached data is available, use default real-time data values
+    return {
+      balance: 0, // default balance
+      enableAutoDeduct: false, // default not enable auto deduct
+      paymentChoices: cached.paymentChoices
+    };
+  }
+
+  // clear native price cache static method
+  static clearNativePriceCache(): void {
+    this.nativePriceCache.clear();
+    this.nativePriceCacheTimestamp.clear();
+    console.log('[PaymentService] Cleared native price cache');
+  }
+}
+
+// Base Payment Service class
+class BasePaymentService extends RequestCacheService<
+  PaymentRequest,
+  PaymentResponse,
+  PaymentCacheData,
+  PaymentRealTimeData
+> {
+  // 失败计数器，按 endpoint 统计
+  private static failureCounters = new Map<string, number>();
+  private static readonly MAX_FAILURE_COUNT = 2;
+
+  constructor(private apiEndpoint: string, private paymentType: PaymentPurchaseType) {
+    super(new PaymentRequestAdapter(), {
+      duration: 10 * 60 * 1000, // 10分钟缓存 paymentChoices
+      timeout: 1000 // 1秒超时
+    });
+  }
+
+  async getProductsInfo(): Promise<PaymentResponse | undefined> {
+    // 检查失败计数，如果达到最大失败次数则直接抛出错误
+    const currentFailureCount = BasePaymentService.failureCounters.get(this.apiEndpoint) || 0;
+    if (currentFailureCount >= BasePaymentService.MAX_FAILURE_COUNT) {
+      throw new Error(
+        `getProductsInfo has failed more than ${BasePaymentService.MAX_FAILURE_COUNT} times for ${this.apiEndpoint}`
+      );
+    }
+
+    try {
+      const result = await this.request(this.apiEndpoint);
+      // 成功时重置失败计数器
+      BasePaymentService.failureCounters.delete(this.apiEndpoint);
+      return result;
+    } catch (error) {
+      // 失败时增加计数器
+      const newCount = currentFailureCount + 1;
+      BasePaymentService.failureCounters.set(this.apiEndpoint, newCount);
+      console.warn(
+        `[PaymentService] getProductsInfo failed (${newCount}/${
+          BasePaymentService.MAX_FAILURE_COUNT + 1
+        }) for ${this.apiEndpoint}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  async purchase(productId: string): Promise<PaymentResult<{ totalAmount: string }>> {
+    const productsInfo = await this.getProductsInfo();
+    const appStoreProductId = productsInfo?.paymentChoices.find(
+      (choice) => choice.productId === productId
+    )?.appStoreProductId;
+    if (!appStoreProductId) {
+      throw new Error('appStoreProductId not found');
+    }
+
+    const result = (await paymentHelper.invokePayment(
+      this.paymentType === 'JOLI_COIN' ? 'JOLI_COIN_IAP' : 'JOLI_GEM_IAP',
+      {
+        productId,
+        appStoreProductId
+      }
+    )) as PaymentResult<{ totalAmount: string }>;
+
+    return result;
+  }
+
+  // 获取产品信息（使用 RequestCacheService）
+  async getProductsInfoWithBalance(): Promise<PaymentResponse | undefined> {
+    return this.request(this.apiEndpoint);
+  }
+
+  // 强制刷新产品信息
+  async refreshProductsInfo(): Promise<PaymentResponse | undefined> {
+    return this.forceRequest(this.apiEndpoint);
+  }
+
+  // 重置失败计数器（供测试使用）
+  static resetFailureCounters(): void {
+    this.failureCounters.clear();
+  }
+
+  // 获取失败计数器状态（供测试使用）
+  static getFailureCount(endpoint: string): number {
+    return this.failureCounters.get(endpoint) || 0;
+  }
+}
+
+// JOLI_COIN payment service
+export class JoliCoinPaymentService extends BasePaymentService {
+  constructor() {
+    super('/api/joli-coin/balance-detail', 'JOLI_COIN');
+  }
+}
+
+// JOLI_GEM payment service
+export class JoliGemPaymentService extends BasePaymentService {
+  constructor() {
+    super('/api/joli-gem/balance-detail', 'JOLI_GEM');
+  }
+}
+
+// service instance management
+let joliCoinServiceInstance: JoliCoinPaymentService | null = null;
+let joliGemServiceInstance: JoliGemPaymentService | null = null;
+
+// create JOLI_COIN payment service instance
+export const createJoliCoinPaymentService = (): JoliCoinPaymentService => {
+  if (joliCoinServiceInstance) {
+    return joliCoinServiceInstance;
+  }
+  joliCoinServiceInstance = new JoliCoinPaymentService();
+  return joliCoinServiceInstance;
+};
+
+// create JOLI_GEM payment service instance
+export const createJoliGemPaymentService = (): JoliGemPaymentService => {
+  if (joliGemServiceInstance) {
+    return joliGemServiceInstance;
+  }
+  joliGemServiceInstance = new JoliGemPaymentService();
+  return joliGemServiceInstance;
+};
+
+// 导出原生价格缓存清理方法供测试使用
+export const clearNativePriceCache = (): void => {
+  PaymentRequestAdapter.clearNativePriceCache();
+};
+
+// 导出失败计数器重置方法供测试使用
+export const resetFailureCounters = (): void => {
+  BasePaymentService.resetFailureCounters();
+};
+
+// 导出获取失败计数方法供测试使用
+export const getFailureCount = (endpoint: string): number => {
+  return BasePaymentService.getFailureCount(endpoint);
+};

package/src/native/payment/registers/jolicoin-iap.ts

@@ -75,7 +75,7 @@ onNative('onPaymentStateChange', (data) => {
   pendingPayments.delete(orderUUID);
 });
 
-const payInApp = async (params: { appStoreProductId: string; appAccountToken?: string }) => {
+const purchaseGem = async (params: { appStoreProductId: string; appAccountToken?: string }) => {
   const deferred = new Deferred<StandardResponse<{ totalAmount: string }>>();
   let targetOrderUUID: string | undefined;
 
@@ -88,7 +88,7 @@ const payInApp = async (params: { appStoreProductId: string; appAccountToken?: s
     });
     targetOrderUUID = response.data?.orderUUID;
 
-    console.info('---payInApp---', response);
+    console.info('---purchaseGem---', response);
     if (!targetOrderUUID) {
       throw createPaymentInternalError(
         'orderUUID is null',
@@ -134,7 +134,7 @@ class JolicoinIAPAndroidPaymentResiter extends BasePaymentRegister<
   };
 
   pay = async (): Promise<StandardResponse<{ totalAmount: string }>> => {
-    return await payInApp({ appStoreProductId: this.appStoreProductId });
+    return await purchaseGem({ appStoreProductId: this.appStoreProductId });
   };
 }
 
@@ -180,7 +180,7 @@ class JolicoinIAPIOSPaymentResiter extends BasePaymentRegister<
   };
 
   pay = async (): Promise<StandardResponse<{ totalAmount: string }>> => {
-    return await payInApp({
+    return await purchaseGem({
       appStoreProductId: this.appStoreProductId,
       appAccountToken: this.appAccountToken
     });

package/src/native/report/index.ts

@@ -13,12 +13,15 @@ const reportNative: ReportHandler = (event, data, webviewId) => {
     : isString(_data.extra)
     ? JSON.parse(_data.extra)
     : {};
+  const { mpName, mpVersion } = context.mpInfo ?? {}; //
   const extra = {
     ...originExtra,
     mp_id: (_data.mp_id as string) ?? '',
     mp_version: (_data.mp_version as string) ?? '',
     session_id: context.sessionId,
-    user_id: context.hostUserInfo?.uid ?? ''
+    user_id: context.hostUserInfo?.uid ?? '',
+    ...(mpName ? { mp_name: mpName } : {}),
+    ...(mpVersion ? { mp_info_version: mpVersion } : {})
   };
   const eventType = (_data.eventType ?? EventType.Other) as number;
 

package/src/native/rewards/ui/payment-modal.ts

@@ -23,12 +23,12 @@ import {
 import { paymentHelper } from '@/native/payment';
 import { createLoading } from '@jolibox/ui';
 import { canIUseNative } from '@/native/api/base';
-import { applyNative } from '@jolibox/native-bridge';
-import { isUndefinedOrNull } from '@jolibox/common';
+
 import { track } from '@/native/report';
 import { updateAutoDeductConfig } from './utils';
 import { createEventPromiseHandler } from '@/common/rewards/registers/utils/event-listener';
 import { TrackEvent } from '@jolibox/types';
+import { createJoliCoinPaymentService, createJoliGemPaymentService } from '@/native/payment/payment-service';
 
 // 货币配置映射
 interface CurrencyPaymentConfig {
@@ -85,6 +85,9 @@ const CURRENCY_PAYMENT_CONFIG: Record<'JOLI_COIN' | 'JOLI_GEM', CurrencyPaymentC
 
 const loading = createLoading();
 
+const JoliCoinPaymentService = createJoliCoinPaymentService();
+const JoliGemPaymentService = createJoliGemPaymentService();
+
 const modalUseFrequencyConfig = createEventPromiseHandler<
   IUseModalFrequencyConfig,
   typeof UseModalFrequencyEventName
@@ -114,6 +117,7 @@ rewardsEmitter.on(
         await loading.show({
           duration: 3000
         });
+
         const config = await modalUseFrequencyConfig.getData();
         const { canShow: canShowPaymentModal } = await paymentConfig.frequencyChecker(
           config.joliCoinUseAndCharge[paymentConfig.frequencyConfigKey]
@@ -134,7 +138,9 @@ rewardsEmitter.on(
       await loading.show({
         duration: 3000
       });
-      const balenceDetails = await getBalenceDetails(paymentConfig.apiEndpoint);
+      const paymentService = currencyType === 'JOLI_COIN' ? JoliCoinPaymentService : JoliGemPaymentService;
+      // get product info from cache, if not found, get from server and cache it
+      const balenceDetails = await paymentService.getProductsInfo();
       loading.hide();
 
       if (!balenceDetails) {
@@ -158,7 +164,7 @@ rewardsEmitter.on(
               ...choice,
               totalAmountStr: choice.totalAmountStr ?? ''
             })) ?? [],
-          enableAutoDeduct: balenceDetails.enableAutoDeduct
+          enableAutoDeduct: params.enableAutoDeduct
         },
         buttons: {
           confirm: {
@@ -183,8 +189,8 @@ rewardsEmitter.on(
                   return;
                 }
 
-                const balenceDetails = await getBalenceDetails(paymentConfig.apiEndpoint);
-                if ((balenceDetails?.balance ?? 0) >= params.quantity) {
+                const newBalence = await paymentService.refreshProductsInfo();
+                if ((newBalence?.balance ?? 0) >= params.quantity) {
                   rewardsEmitter.emit(PaymentResultEventName, {
                     paymentResult: 'SUCCESS',
                     currency: currencyType
@@ -193,6 +199,7 @@ rewardsEmitter.on(
                   return;
                 }
               }
+              // invoke native payment
               console.log('invokeNativePayment', productId);
               const appStoreProductId = balenceDetails?.paymentChoices?.find(
                 (choice) => choice.productId === productId
@@ -278,58 +285,11 @@ rewardsEmitter.on(
   }
 );
 
-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[];
-};
-
-const getBalenceDetails = async (
-  apiEndpoint: string
-): Promise<
-  | {
-      balance: number;
-      enableAutoDeduct: boolean;
-      paymentChoices: IPaymentChoice[];
-    }
-  | undefined
-> => {
-  const { response } = await fetch<
-    StandardResponse<{
-      balance: number;
-      enableAutoDeduct: boolean;
-      paymentChoices: IPaymentChoice[];
-    }>
-  >(apiEndpoint, {
-    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) ?? []
-  });
+/** preload payment details */
 
-  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;
-};
+JoliCoinPaymentService.getProductsInfo().catch((e) => {
+  console.error('preload joli coin payment details failed', e);
+});
+JoliGemPaymentService.getProductsInfo().catch((e) => {
+  console.error('preload joli gem payment details failed', e);
+});