wxxyx-sdk/core/payment/index.ts

import { createOrderApi, orderNotifyApi, paymentApi } from "../../api/order.api";
import { getDeviceInfo } from "../../utils/wechat";
import DnSdk from "../../lib/DnSdk";
import { setStorage } from "../../store";
import { throttle, unixTimestamp } from "../../utils/helper";
import UserInfoModel from "../../store/models/user.model";
import { silentLogin } from "../auth/wechat/wechat-auth";
import { serverLogin } from "../auth/server/server-auth";

/**
 * 创建订单
 * @param orderData 订单信息
 */
export const createOrder = async (orderData) => {
    try {
        let { cp_order_id, money, product_id, product_name, server_id, server_name, role_id, role_name, role_level, ext } = orderData;

        // 创建订单

        const createOrderResult = await createOrderApi({
            cp_order_id,
            money,
            product_id,
            product_name,
            server_id,
            server_name,
            role_id,
            role_name,
            role_level,
            ext,
        })
        const { inapp, wechat_jsapi } = createOrderResult.pay_channel;


        console.log("createOrderResult", createOrderResult)


        let midasPayParams = {}
        let gzhPayParams = {}

        const payUrlRes = await getPayUrl(createOrderResult)

        const curOrderInfo = {
            ...payUrlRes,
            pay_type: inapp ? "midas" : wechat_jsapi ? "kf" : "",
            ext,
            money,
            order_id: createOrderResult.order_id,
            inapp,
            product_name
        }


        if (inapp) {
            midasPayParams = typeof payUrlRes !== 'undefined' ? { ...payUrlRes, pay_type: "midas" } : {}
        }


        if (wechat_jsapi) {
            let from = { "order_id": createOrderResult.order_id, pay_channel_id: wechat_jsapi }
            gzhPayParams = {
                sessionFrom: JSON.stringify(from),
                showMessageCard: true,
                sendMessagePath: "",
                sendMessageTitle: "",
                sendMessageImage: `${import.meta.env.SDK_API_BASE}/img/pay.png`,
                pay_type: "w_gzh"
            }
        }

        return Promise.resolve({
            midasPayParams,
            gzhPayParams,
            curOrderInfo
        })
    } catch (error) {
        return Promise.reject(error)
    }

}


/**
 * 获取支付链接
 */
const getPayUrl = async (createOrderResult) => {
    const platform = getDeviceInfo('platform')
    if (platform === 'ios') {
        return Promise.resolve({})
    }
    try {
        let params = {
            order_id: createOrderResult.order_id,
            pay_channel_id: createOrderResult.pay_channel.inapp ? createOrderResult.pay_channel.inapp : createOrderResult.pay_channel.wechat_jsapi
        }

        const payUrlRes = await paymentApi(params)
        return Promise.resolve(payUrlRes)
    } catch (error) {
        return Promise.reject(error)
    }
}

/**
 * 拉起支付
 * @param curOrderInfo 订单信息
 * @param gzhPayParams 公众号支付参数
 */
const makePay = async ({ curOrderInfo, gzhPayParams }) => {
    const platform = getDeviceInfo('platform')
    if (curOrderInfo.pay_type === "midas") {
        if ("ios" === platform) {
            return Promise.resolve("MIDAS_IOS");
        } else {
            // return Promise.resolve();
            wx.checkSession({
                success() {
                    return Promise.resolve();
                },
                fail() {
                    UserInfoModel.getInstance().clear();
                    // 获取用户信息
                    silentLogin()
                        .then(function (silentLoginRes) {
                            serverLogin(silentLoginRes)
                                .then(function () {
                                    return Promise.resolve();
                                })
                                .catch((error) => {
                                    return Promise.reject(error);
                                });
                        })
                        .catch((error) => {
                            return Promise.reject(error);
                        });
                },
            });
        }
    } else if (curOrderInfo.pay_type === "kf") {
       
        // 拉起客服消息
        wx.openCustomerServiceConversation({
            sessionFrom: gzhPayParams.sessionFrom,
            showMessageCard: gzhPayParams.showMessageCard,
            sendMessagePath: gzhPayParams.sendMessagePath,
            sendMessageTitle: gzhPayParams.sendMessageTitle,
            sendMessageImg: gzhPayParams.sendMessageImage,
        });
        console.log("kfkkk===>",{
            sessionFrom: gzhPayParams.sessionFrom,
            showMessageCard: gzhPayParams.showMessageCard,
            sendMessagePath: gzhPayParams.sendMessagePath,
            sendMessageTitle: gzhPayParams.sendMessageTitle,
            sendMessageImg: gzhPayParams.sendMessageImage,
        })
        return Promise.resolve("CUSTOMER");
    }
}
const midasPay = async ({ curOrderInfo, midasPayParams }) => {

    let platform = getDeviceInfo('platform')
    try {
        wx.requestMidasPayment({
            mode: "game",
            env: midasPayParams.env,
            offerId: midasPayParams.offerId,
            currencyType: "CNY",
            platform: platform,
            buyQuantity: midasPayParams.buyQuantity,
            amt: curOrderInfo.money,
            zoneId: midasPayParams.zoneId,
            outTradeNo: curOrderInfo.order_id,
            success: (res) => {
                // 腾讯广告小游戏SDK上报支付
                DnSdk.getInstance().onPurchase(curOrderInfo.money * 100);
                // 支付成功后回调
                const payChannelId = curOrderInfo.inapp;
                orderNotifyApi(payChannelId, {
                    money: curOrderInfo.money,
                    order_id: curOrderInfo.order_id,
                    callback_type: "client",
                });
                return Promise.resolve();
            },
            fail: (error) => {
                return Promise.reject(error);
            },
        });


    } catch (error) {
        return Promise.reject(error);
    }
};

/**
 * @description: 内部支付函数
 * @param {*} payParams
 * @return {*}
 */
const _payment = async (payParams) => {

    try {
        const orderInfo = {
            cp_order_id: payParams.cp_order_id,
            money: payParams.money,
            role_id: payParams.role_id,
            role_name: payParams.role_name,
            server_id: payParams.server_id,
            server_name: payParams.server_name,
            ext: payParams.ext ? payParams.ext : "",
            role_level: payParams.role_level,
            product_id: payParams.product_id,
            product_name: payParams.product_name,
        };
        // 下单
        const { curOrderInfo, midasPayParams, gzhPayParams } = await createOrder(
            orderInfo
        );

        // 非米大师支付使用本地定时器检查上报

        if (curOrderInfo.pay_type != "midas") {
            setStorage("extOrderAndReport_" + curOrderInfo.order_id, {
                ext: curOrderInfo.ext,
                money: curOrderInfo.money,
                order_id: curOrderInfo.order_id,
                product_name: curOrderInfo.product_name || "Purchase Item",
                timestamp: unixTimestamp(),
                reportCount: 0,
            });
        }

        const res = await makePay({ curOrderInfo, gzhPayParams });
        wx.hideLoading();

        // 二维码+url 二合一
        if (typeof res === "object") {
            return Promise.resolve({
                code: 0,
                data: res,
                msg: "订单创建成功",
            });
        }
        if (res === "CUSTOMER") {
            //客服已经拉起成功
            return Promise.resolve({
                code: 0,
                data: null,
                msg: "订单创建成功",
            });
        }

        // 小游戏米大师
        await midasPay({ curOrderInfo, midasPayParams });

        return Promise.resolve({
            code: 0,
            data: null,
            msg: "订单创建成功",
        });
    } catch (error) {
        return Promise.reject(error);
    }
};

/**
 * @description:拉起支付（节流版本，避免短时间内重复点击）
 * @param {*} payParams
 * @return {*}
 */
export const payment = throttle(_payment, 2000);