@jolibox/implement 1.1.24 → 1.1.26

package/src/native/api/task.ts

@@ -1,5 +1,4 @@
 import { createCommands } from '@jolibox/common';
-
 import { createAPI, registerCanIUse, t } from './base';
 import { taskTracker } from '../report';
 
@@ -7,20 +6,22 @@ const commands = createCommands();
 
 const onLevelFinished = createAPI('levelFinished', {
   paramsSchema: t.tuple(
-    t.string(),
     t.object({
-      result: t.boolean(),
-      duration: t.number()
+      levelId: t.or(t.string(), t.number()),
+      duration: t.number().optional(),
+      rating: t.number().optional(),
+      score: t.number().optional()
     })
   ),
-  implement: async (levelId, parmas) => {
-    const { result, duration } = parmas;
+  implement: async (parmas) => {
+    const { levelId, duration, rating, score } = parmas;
     const tasks = [];
     tasks.push(
       taskTracker.tracker('LevelFinished', {
         levelId,
-        result,
-        duration
+        duration,
+        rating,
+        score
       })
     );
 
@@ -33,195 +34,76 @@ const onLevelFinished = createAPI('levelFinished', {
   }
 });
 
-const onTaskFinished = createAPI('taskFinished', {
+const onGamePlayEnded = createAPI('gamePlayEnded', {
   paramsSchema: t.tuple(
-    t.string(),
     t.object({
-      duration: t.number()
+      duration: t.number().optional(),
+      rating: t.number().optional(),
+      score: t.number()
     })
   ),
-  implement: async (taskId, params) => {
-    const { duration } = params;
-    return await taskTracker.reportToNative({
-      event: 'TaskFinished',
-      params: {
-        duration,
-        taskId
-      }
+  implement: async (params) => {
+    const { duration, rating, score } = params;
+    return taskTracker.tracker('GamePlayEnded', {
+      duration,
+      rating,
+      score
     });
   }
 });
 
 const onLevelUpgrade = createAPI('levelUpgrade', {
-  paramsSchema: t.tuple(t.string(), t.string()),
-  implement: async (levelId, name) => {
-    const tasks = [];
-    tasks.push(
-      taskTracker.reportToNative({
-        event: 'LevelUpgrade',
-        params: {
-          name,
-          levelId
-        }
-      })
-    );
-    await Promise.all(tasks);
-  }
-});
-
-const onHistoryUserLevel = createAPI('onHistoryUserLevel', {
-  paramsSchema: t.tuple(t.number()),
-  implement: async (level) => {
-    return await taskTracker.reportToNative({
-      event: 'HistoryUserLevel',
-      params: {
-        level
-      }
-    });
-  }
-});
-
-const onHistoryUserScore = createAPI('onHistoryUserScore', {
-  paramsSchema: t.tuple(t.number()),
-  implement: async (score) => {
-    return await taskTracker.reportToNative({
-      event: 'HistoryUserScore',
-      params: {
-        score
-      }
-    });
-  }
-});
-
-const onTaskEvent = createAPI('taskEvent', {
   paramsSchema: t.tuple(
-    t.string(),
     t.object({
-      tools: t
-        .array(
-          t.object({
-            id: t.string(),
-            name: t.string(),
-            count: t.number(),
-            description: t.string().optional(),
-            price: t
-              .object({
-                amount: t.number(),
-                unit: t.string()
-              })
-              .optional()
-          })
-        )
-        .optional(),
-      awards: t
-        .array(
-          t.object({
-            id: t.string(),
-            name: t.string()
-          })
-        )
-        .optional()
+      levelId: t.or(t.string(), t.number()),
+      name: t.string().optional()
     })
   ),
-  implement: async (taskId, params) => {
+  implement: async ({ levelId, name }) => {
     const tasks = [];
     tasks.push(
-      taskTracker.reportToNative({
-        event: 'TaskEvent',
-        params: {
-          taskId,
-          ...params
-        }
+      taskTracker.tracker('LevelUpgrade', {
+        name,
+        levelId
       })
     );
-    // 使用了道具，上报任务
-    if (params.tools?.length ?? 0 > 0) {
-      tasks.push(
-        taskTracker.reporter({
-          event: 'USE_GAME_ITEM'
-        })
-      );
-      tasks.push(
-        taskTracker.reportToNative({
-          event: 'UseGameItem',
-          params: {
-            taskId,
-            ...params
-          }
-        })
-      );
-    }
     await Promise.all(tasks);
   }
 });
 
 commands.registerCommand('TaskTrackerSDK.levelFinished', onLevelFinished);
-commands.registerCommand('TaskTrackerSDK.taskFinished', onTaskFinished);
+commands.registerCommand('TaskTrackerSDK.gamePlayEnded', onGamePlayEnded);
 commands.registerCommand('TaskTrackerSDK.levelUpgrade', onLevelUpgrade);
-commands.registerCommand('TaskTrackerSDK.historyUserLevel', onHistoryUserLevel);
-commands.registerCommand('TaskTrackerSDK.historyUserScore', onHistoryUserScore);
-commands.registerCommand('TaskTrackerSDK.taskEvent', onTaskEvent);
 
 registerCanIUse('TaskTrackerSDK.onLevelFinished', {
-  version: '1.0.0',
+  version: '1.1.25',
   properties: {
-    levelId: '1.0.0',
     params: {
-      result: '1.0.0',
-      duration: '1.0.0'
+      levelId: '1.1.25',
+      duration: '1.1.25',
+      rating: '1.1.25',
+      score: '1.1.25'
     }
   }
 });
 
-registerCanIUse('TaskTrackerSDK.onTaskFinished', {
-  version: '1.0.0',
+registerCanIUse('TaskTrackerSDK.onGamePlayEnded', {
+  version: '1.1.25',
   properties: {
-    taskId: '1.0.0',
-    duration: '1.0.0'
+    params: {
+      duration: '1.1.25',
+      rating: '1.1.25',
+      score: '1.1.25'
+    }
   }
 });
 
 registerCanIUse('TaskTrackerSDK.onLevelUpgrade', {
-  version: '1.0.0',
-  properties: {
-    levelId: '1.0.0',
-    name: '1.0.0'
-  }
-});
-
-registerCanIUse('TaskTrackerSDK.onHistoryUserLevel', {
-  version: '1.0.0',
-  properties: {
-    level: '1.0.0'
-  }
-});
-
-registerCanIUse('TaskTrackerSDK.onHistoryUserScore', {
-  version: '1.0.0',
-  properties: {
-    score: '1.0.0'
-  }
-});
-
-registerCanIUse('TaskTrackerSDK.onTaskEvent', {
-  version: '1.0.0',
+  version: '1.1.25',
   properties: {
-    taskId: '1.0.0',
     params: {
-      tools: {
-        id: '1.0.0',
-        name: '1.0.0',
-        count: '1.0.0',
-        description: '1.0.0',
-        price: {
-          amount: '1.0.0',
-          unit: '1.0.0'
-        }
-      },
-      awards: {
-        id: '1.0.0',
-        name: '1.0.0'
-      }
+      levelId: '1.1.25',
+      name: '1.1.25'
     }
   }
 });

package/src/native/bootstrap/index.ts

@@ -7,6 +7,7 @@ import { adEventEmitter } from '@/common/ads';
 import { openRetentionSchema } from '../ui/retention';
 import { innerFetch } from '../network';
 import { Env } from '@jolibox/types';
+import { registerLanguageHandler } from '@jolibox/ui';
 import { createIframeModal, registerIframeModalToGlobal } from '../ui/modal-iframe';
 interface IBasicMetaConfig {
   canShowRecommended: boolean;
@@ -135,6 +136,7 @@ function addGameServiceReadyListener() {
 
     // 任务上报
     handleTaskTracker(loadDuration);
+    registerLanguageHandler(() => context.language);
   });
 
   onNative('onBeforeExit', ({ uuid }) => {

package/src/native/payment/index.ts

@@ -0,0 +1,5 @@
+import { createPaymentHelper } from './payment-helper';
+import { createJolicoinPaymentHandler } from './registers/joli-coin';
+
+export const paymentHelper = createPaymentHelper();
+paymentHelper.registerPaymentHandler('JOLI_COIN', createJolicoinPaymentHandler());

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

@@ -0,0 +1,44 @@
+export type PaymentType = 'JOLI_COIN'; // current only jolicoin
+
+import { StandardResponse } from '@jolibox/types';
+import { reportError } from '@/common/report/errors/report';
+import { BaseError } from '@jolibox/common';
+
+type PaymentResult = StandardResponse<void>;
+
+export interface PaymentHandlerMap {
+  JOLI_COIN: (productId: string) => Promise<PaymentResult>; // jolicoin
+}
+
+export type PaymentHandler<T extends PaymentType> = PaymentHandlerMap[T];
+
+export function createPaymentHelper() {
+  const paymentHandlers = new Map<PaymentType, PaymentHandler<any>>();
+
+  return {
+    registerPaymentHandler<T extends PaymentType>(type: T, handler: PaymentHandler<T>) {
+      paymentHandlers.set(type, handler);
+    },
+    async invokePayment<T extends PaymentType>(type: T, ...args: Parameters<PaymentHandler<T>>) {
+      const paymentHandler = paymentHandlers.get(type);
+      if (!paymentHandler) {
+        return {
+          code: 'FAILED',
+          message: `[joliboxSDK]: ${type} payment not supported in this platform`
+        };
+      }
+      try {
+        const result = await paymentHandler(...args);
+        return result;
+      } catch (e) {
+        reportError(e as BaseError);
+        return {
+          code: 'FAILED',
+          message: `[joliboxSDK]: paymenterror ${e}`
+        };
+      }
+    }
+  };
+}
+
+export type PaymentHelper = ReturnType<typeof createPaymentHelper>;

package/src/native/payment/registers/base.ts

@@ -0,0 +1,97 @@
+import { StandardResponse } from '@jolibox/types';
+import type { IPlaceOrderJoliCoinParamas, IJoliCoinProductInfo, IJolicoinPaymentContext } from './joli-coin';
+import type { IPlaceOrderResponse } from './type';
+import { PaymentErrorCodeMap } from './type';
+type PaymentStatus = 'INIT' | 'PENDING' | 'SUCCESS' | 'FAILED';
+import { UserPaymentError, InternalPaymentError } from '@jolibox/common';
+import { context } from '@/common/context';
+import { innerFetch as fetch } from '@/native/network';
+
+type IPlaceOrderParams = IPlaceOrderJoliCoinParamas;
+type IOrderProductInfo = IJoliCoinProductInfo;
+type IOrderPaymentContext = IJolicoinPaymentContext;
+
+const createPaymentErrorFactory = () => {
+  const [createPaymentError, createPaymentInternalError] = [UserPaymentError, InternalPaymentError].map(
+    (ctor) => {
+      return (errMsg: string, errNo: number, extra?: Record<string, unknown>) => {
+        return new ctor(errMsg, errNo, extra);
+      };
+    }
+  );
+  return {
+    createPaymentError,
+    createPaymentInternalError
+  };
+};
+
+const { createPaymentError, createPaymentInternalError } = createPaymentErrorFactory();
+export { createPaymentError, createPaymentInternalError };
+
+const CALLBACK_HOST = context.testMode ? 'https://stg-game.jolibox.com' : 'https://game.jolibox.com';
+
+export abstract class BasePaymentRegister<T extends IPlaceOrderParams, E extends IOrderProductInfo> {
+  private _orderId: string | null = null;
+  private _orderStatus: PaymentStatus = 'INIT';
+
+  startPayment = async (params: T) => {
+    if (this._orderId) {
+      await this.cancelOrder(this.orderId as string);
+    }
+
+    const { data, code, message } = await this.placeOrder(params);
+    if (code !== 'SUCCESS' || !data || !data.orderId) {
+      throw createPaymentError(message, PaymentErrorCodeMap.PlaceOrderFailed);
+    }
+    if (data?.status !== 'PENDING') {
+      throw createPaymentInternalError(
+        `Place order failed, status: ${data?.status}`,
+        PaymentErrorCodeMap.PlaceOrderFailed
+      );
+    }
+
+    const { orderId } = data;
+    this._orderId = orderId;
+    // invoke native payment;
+
+    const callbackUrl = this.generateCallbackUrl();
+    // 回调页
+  };
+
+  cancelOrder = async (orderId: string) => {
+    const { response } = await fetch(`/api/orders/${orderId}/cancel`, {
+      method: 'POST',
+      data: {}
+    });
+    if (response.code !== 'SUCCCESS') {
+      throw createPaymentError(
+        response.message ?? response.errMsg ?? '',
+        PaymentErrorCodeMap.CancelOrderFailed
+      );
+    }
+  };
+
+  private generateCallbackUrl = () => {
+    // Set or replace gameId and joliSource parameters
+    const originalSearch = new URLSearchParams('');
+    originalSearch.set('utm_source', context.deviceInfo.platform);
+    originalSearch.set(
+      'joliSource',
+      context.encodeJoliSourceQuery({
+        ...this.generatePaymentContext()
+      })
+    );
+    return `${CALLBACK_HOST}//payment/callback?${originalSearch.toString()}`;
+  };
+
+  abstract placeOrder(params: T): Promise<StandardResponse<IPlaceOrderResponse<E>>>;
+  abstract generatePaymentContext(): IOrderPaymentContext;
+
+  get orderId(): string | null {
+    return this._orderId;
+  }
+
+  get status(): PaymentStatus {
+    return this._orderStatus;
+  }
+}

package/src/native/payment/registers/joli-coin.ts

@@ -0,0 +1,83 @@
+import { innerFetch as fetch } from '@/native/network';
+import { BasePaymentRegister, createPaymentError, createPaymentInternalError } from './base';
+import { PaymentErrorCodeMap, IPlaceOrderResponse } from './type';
+import { ResponseType, StandardResponse } from '@jolibox/types';
+
+export interface IPlaceOrderJoliCoinParamas {
+  productId: string;
+}
+
+export interface IJoliCoinProductInfo {
+  quantity: number;
+}
+
+export interface IJolicoinPaymentContext {
+  type: 'JOLI_COIN_ORDER_CONTEXT';
+  state: 'TO_CHECKOUT' | 'TO_VALIDATE';
+  productId: string;
+  orderId: string;
+}
+
+class JolicoinPaymentResiter extends BasePaymentRegister<IPlaceOrderJoliCoinParamas, IJoliCoinProductInfo> {
+  constructor(readonly productId: string) {
+    super();
+  }
+  async placeOrder(
+    params: IPlaceOrderJoliCoinParamas
+  ): Promise<StandardResponse<IPlaceOrderResponse<IJoliCoinProductInfo>, unknown>> {
+    try {
+      const { response } = await fetch<IPlaceOrderResponse<IJoliCoinProductInfo>>(
+        '/api/orders/checkout/joli-coin',
+        {
+          method: 'POST',
+          data: { productId: params.productId }
+        }
+      );
+
+      if (response.code !== 'SUCCESS') {
+        throw createPaymentError(
+          response.errMsg ?? response.message ?? '',
+          PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+        );
+      }
+
+      return {
+        code: 'SUCCESS' as ResponseType,
+        message: response.message ?? 'placeorder jolicoin success',
+        data: response.data
+      };
+    } catch (e) {
+      console.info(`[JoliboxSDK] placeorder failed`, e);
+      throw createPaymentInternalError(
+        JSON.stringify(e) ?? 'jolicoin placeorder failed',
+        PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+      );
+    }
+  }
+
+  generatePaymentContext = (): IJolicoinPaymentContext => {
+    return {
+      type: 'JOLI_COIN_ORDER_CONTEXT',
+      state: 'TO_VALIDATE',
+      productId: this.productId,
+      orderId: this.orderId!
+    };
+  };
+}
+
+export const createJolicoinPaymentHandler = () => {
+  const productPaymentMap = new Map<string, JolicoinPaymentResiter>();
+  return async (productId: string) => {
+    let instance = productPaymentMap.get(productId);
+    if (!instance) {
+      instance = new JolicoinPaymentResiter(productId);
+      productPaymentMap.set(productId, instance);
+    }
+
+    await instance.startPayment({ productId });
+    return {
+      code: 'SUCCESS' as ResponseType,
+      message: 'jolicoin payment success'
+    };
+  };
+};

package/src/native/payment/registers/type.ts

@@ -0,0 +1,15 @@
+type OrderStatus = 'PENDING' | 'PAYING' | 'PAYMENT_FAILED' | 'PAYMENT_SUCCESS' | 'PAYMENT_CLOSED';
+
+export interface IPlaceOrderResponse<T> {
+  orderId: string;
+  status: OrderStatus;
+  totalAmountStr: string;
+  joliBizType: 'DRAMA' | 'JOLI_COIN';
+  productInfo: T;
+}
+
+export enum PaymentErrorCodeMap {
+  PlaceOrderFailed = 1001,
+  JolicoinPlaceOrderRequestFailed = 1002,
+  CancelOrderFailed = 1003
+}

package/src/native/report/task-tracker.ts

@@ -19,7 +19,7 @@ type NativeTaskPointEvent =
   | 'HistoryUserLevel'
   | 'HistoryUserScore'
   | 'UseGameItem'
-  | 'TaskEvent';
+  | 'GameTaskEvent';
 
 export type NativeTaskPoint = {
   event: NativeTaskPointEvent;

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

@@ -2,6 +2,16 @@ import { StandardResponse } from '@jolibox/types';
 import { getGlobalStorage, setGlobalStorage } from '../api/storage';
 import { filterTodayTimestamps } from './utils';
 
+const parseFrequency = (data: string) => {
+  let fequeycies;
+  try {
+    fequeycies = JSON.parse(data);
+  } catch (e) {
+    fequeycies = [];
+  }
+  return fequeycies;
+};
+
 /**
  * check can show useModal
  * @param config
@@ -9,11 +19,12 @@ import { filterTodayTimestamps } from './utils';
  */
 export const checkUseModalFrequency = async (config: { dailyMaxPopUps: number; minInterval: number }) => {
   const { dailyMaxPopUps, minInterval } = config;
-  const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<number[]>;
+  const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<string>;
   if (!res.data) {
     return true;
   }
-  const fequeycies = res.data;
+
+  const fequeycies = parseFrequency(res.data);
   const todayFequencies = filterTodayTimestamps(fequeycies);
   if (todayFequencies.length >= dailyMaxPopUps) {
     return false;
@@ -27,12 +38,13 @@ export const checkUseModalFrequency = async (config: { dailyMaxPopUps: number; m
 
 export const updateUseModalFrequency = async () => {
   const now = Date.now();
-  const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<number[]>;
+  const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<string>;
 
-  const fequeycies = res.data ?? [];
-  fequeycies.push(now);
-  fequeycies.sort((a, b) => b - a).splice(8);
-  await setGlobalStorage('joli_coin_use_modal_frequency', fequeycies);
+  const frequencies = parseFrequency(res.data ?? '[]') as number[];
+  frequencies.push(now);
+  frequencies.sort((a, b) => b - a).splice(8);
+
+  await setGlobalStorage('joli_coin_use_modal_frequency', JSON.stringify(frequencies));
 };
 
 /**
@@ -40,13 +52,13 @@ export const updateUseModalFrequency = async () => {
  */
 export const checkPaymentFrequency = async (config: { dailyMaxPopUps: number; minInterval: number }) => {
   const { dailyMaxPopUps, minInterval } = config;
-  const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<number[]>;
+  const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<string>;
 
   if (!res.data) {
     return true;
   }
-  const fequeycies = res.data;
-  const todayFequencies = filterTodayTimestamps(fequeycies);
+  const frequencies = parseFrequency(res.data);
+  const todayFequencies = filterTodayTimestamps(frequencies);
   if (todayFequencies.length >= dailyMaxPopUps) {
     return false;
   }
@@ -62,9 +74,10 @@ export const checkPaymentFrequency = async (config: { dailyMaxPopUps: number; mi
  */
 export const updatePaymentFrequency = async () => {
   const now = Date.now();
-  const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<number[]>;
-  const frequencies = res.data ?? [];
-  frequencies.push(now);
-  frequencies.sort((a, b) => b - a).splice(8);
-  await setGlobalStorage('joli_coin_payment_frequency', frequencies);
+  const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<string>;
+  const fequeycies: number[] = parseFrequency(res.data ?? '[]');
+
+  fequeycies.push(now);
+  fequeycies.sort((a, b) => b - a).splice(8);
+  await setGlobalStorage('joli_coin_payment_frequency', JSON.stringify(fequeycies));
 };

package/src/native/rewards/index.ts

@@ -27,6 +27,7 @@ import {
   checkPaymentFrequency,
   updatePaymentFrequency
 } from './check-frequency';
+import { paymentHelper } from '../payment';
 
 const modalUseFrequencyConfig = createEventPromiseHandler<
   IUseModalFrequencyConfig,
@@ -153,14 +154,19 @@ rewardsEmitter.on(
                 }
 
                 const balenceDetails = await getBalenceDetails();
-                if ((balenceDetails?.balance ?? 0) >= params.joliCoinQuantity && params.enableAutoDeduct) {
+                if ((balenceDetails?.balance ?? 0) >= params.joliCoinQuantity) {
                   rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
                   modal.destroy();
                   return;
                 }
               }
               console.log('invokeNativePayment', productId);
-
+              const { code } = await paymentHelper.invokePayment('JOLI_COIN', productId);
+              if (code !== 'SUCCESS') {
+                rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
+                modal.destroy();
+                return;
+              }
               rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
               modal.destroy();
             }