wxappb2b/GuangZuan/miniprogram/services/socket/trade/index.ts

import { v4 } from '../../../utils/uuid/index'
import { Package50 } from '../../../utils/websocket/package'
import { FunCode } from '../../../constants/enum/funcode'
import { IMessageHead } from './protobuf/proto'
import { TradeRequest, TradeResponse } from './interface'
import Protobuf from './protobuf/index'
import socket from '../index'

/**
 * 构建消息头部
 */
function getProtoHeader(funCode: keyof typeof FunCode, header?: IMessageHead, marketId?: number) {
    // 组合请求头
    const protoHeader: IMessageHead = {
        FunCode: FunCode[funCode],
        UUID: v4(),
        AccessID: 0,
        UserID: 0,
        ...(header ?? {})
    }
    if (marketId) {
        protoHeader.MarketID = marketId;
    }
    return protoHeader;
}

/**
 * 向交易服务器发送请求
 * @param params 请求参数
 * @param reqCode 请求代码
 * @param rspCode 回调代码
 * @param marketId 市场ID
 */
function tradeServerMiddleware<Req, Rsp>(reqCode: keyof typeof FunCode, rspCode: keyof typeof FunCode, params: TradeRequest<Req, Rsp>, marketId?: number): Promise<Rsp> {
    params.data.Header = getProtoHeader(reqCode, params.data.Header, marketId);
    return new Promise((resolve, reject) => {
        Protobuf.requestEncode(reqCode, params.data).then((res) => {
            // 发送消息
            socket.sendTradeServer({
                data: {
                    payload: new Package50(FunCode[reqCode], res)
                },
                success: (raw) => {
                    if (raw.funCode === FunCode[rspCode]) {
                        Protobuf.responseDecode<Rsp>(rspCode, raw.content).then((res) => {
                            resolve(res);
                        }).catch((msg) => {
                            console.warn(rspCode, msg);
                            reject('报文解析失败');
                        })
                    } else {
                        console.warn('解析包错误', rspCode, rspCode);
                        reject('解析包错误');
                    }
                },
                fail: (err: any) => {
                    console.error(reqCode, err);
                    reject(err);
                }
            })
        }).catch((msg) => {
            console.error(reqCode, msg);
            reject('报文构建失败');
        })
    })
}

/**
 * 向交易服务器发送请求
 * @param params 
 * @param reqCode 
 * @param rspCode 
 * @param marketId 
 */
export async function tradeServerRequest<Req, Rsp>(reqCode: keyof typeof FunCode, rspCode: keyof typeof FunCode, params: TradeRequest<Req, Rsp & TradeResponse>, marketId?: number) {
  const { success, fail, complete } = params;

  await tradeServerMiddleware(reqCode, rspCode, params, marketId).then((res) => {
      const { RetCode, RetDesc } = res;

      switch (RetCode) {
          case 0: {
              success && success(res);
              return Promise.resolve();
          }
          case -1: {
              // 管理端错误消息
              return Promise.reject(RetDesc);
          }
          case 12018: {
              if (RetDesc) {
                  // 解析base64
                  res.RetDesc = Buffer.from(RetDesc, 'base64').toString();
              }
              return Promise.reject(res.RetDesc);
          }
          default: {
              const msg = (RetDesc || RetCode).toString();
              return Promise.reject(msg);
          }
      }
  }).catch((err) => {
      fail && fail(err);
      return Promise.reject(err);
  }).finally(() => {
      complete && complete();
  })
}