package request

import (
	"encoding/base64"
	"errors"
	"mtp20access/global"
	"mtp20access/packet"
	"mtp20access/res/pb"
	"regexp"
	"strings"
	"time"

	"github.com/golang/protobuf/jsonpb"
	"github.com/golang/protobuf/proto"
	"go.uber.org/zap"
)

type MQBodyReq struct {
	FunCodeReq  uint32 `json:"funCodeReq" binding:"required"`  // 请求功能码
	FunCodeRsp  uint32 `json:"funCodeRsp"`                     // 回复功能码
	IsEncrypted *bool  `json:"isEncrypted" binding:"required"` // 是否加密
	Data        string `json:"data" binding:"required"`        // 请求数据
}

// GetProtoBytes 将客户端请求的数据转换成总线使用的Protobuf
//
// serialNumber 流水号
func (r *MQBodyReq) GetProtoBytes(serialNumber *uint32) (bytes *[]byte, err error) {
	// 判断是否需要解密数据内容
	data := r.Data
	if *r.IsEncrypted {
		d, e := base64.StdEncoding.DecodeString(r.Data)
		if e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("解密失败")
			return
		}
		d1 := d[4 : len(d)-8] // 解密时要去头尾
		p, e := packet.Decrypt(d1, packet.AESKey, true)
		if e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("解密失败")
			return
		}
		data = string(p)
	}

	// JSON -> Protobuf
	switch int(r.FunCodeReq) {
	case global.ModifyPwdReq:
		m := pb.ModifyPwdReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.UserReceiveInfoReq:
		m := pb.UserReceiveInfoReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.DelUserReceiveInfoReq:
		m := pb.DelUserReceiveInfoReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.UserReceiveIsDefaultReq:
		m := pb.UserReceiveIsDefaultReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.UserReceiptInfoReq:
		m := pb.UserReceiptInfoReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.DelUserReceiptInfoReq:
		m := pb.DelUserReceiptInfoReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.T2bBankSignReq:
		m := pb.T2BBankSignReq{}
		if err = r.reflectNoLong(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.T2bBankCancelSignReq:
		m := pb.T2BBankCancelSignReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.T2bBankWithdrawReq:
		m := pb.T2BBankWithdrawReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.T2bBankDepositReq:
		m := pb.T2BBankDepositReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.WarehouseApplyReq:
		m := pb.WarehouseApplyReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.PerformanceContractedApplyReq:
		m := pb.PerformanceContractedApplyReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.PerformanceDelayApplyReq:
		m := pb.PerformanceDelayApplyReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.PerformanceManualConfirmReq:
		m := pb.PerformanceManualConfirmReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.PerformanceModifyContactReq:
		m := pb.PerformanceModifyContactReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.GoodsFavoriteOperateReq:
		m := pb.GoodsFavoriteOperateReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.ZSBuyOrderListingReq:
		m := pb.ZSBuyOrderListingReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.ZSSellOrderListingReq:
		m := pb.ZSSellOrderListingReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.ZSBuyOrderDestingReq:
		m := pb.ZSBuyOrderDestingReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.ZSSellOrderDestingApplyReq:
		m := pb.ZSSellOrderDestingApplyReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.ZSSellOrderDestingApplyOperateReq:
		m := pb.ZSSellOrderDestingApplyOperateReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.ZSBuyOrderDestingNegPriceReq:
		m := pb.ZSBuyOrderDestingNegPriceReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.ZSBuyOrderDestingNegPriceOperateReq:
		m := pb.ZSBuyOrderDestingNegPriceOperateReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.WRListingCancelOrderReq:
		m := pb.WRListingCancelOrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.HdWROrderReq:
		m := pb.HdWROrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.WROutApplyReq:
		m := pb.WROutApplyReq{}
		if err = r.reflectNoLong(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.ReceiptZSOutApplyReq:
		m := pb.ReceiptZSOutApplyReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.SpotPresaleListingOrderReq:
		m := pb.SpotPresaleListingOrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.CJJCMemberOperateReq:
		m := pb.CJJCMemberOperateReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.BSFWMemberOperateReq:
		m := pb.BSFWMemberOperateReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.AccountFundInfoReq:
		m := pb.AccountFundInfoReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.GZPresaleApplyReq:
		m := pb.GZPresaleApplyReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.GZPresaleOrderReq:
		m := pb.GZPresaleOrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.GZCenterPurchaseApplyReq:
		m := pb.GZCenterPurchaseApplyReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.GZCenterPurchaseOrderReq:
		m := pb.GZCenterPurchaseOrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.BSWMSReckonPayReq:
		m := pb.BSWMSReckonPayReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.OrderReq:
		m := pb.OrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		// 按交易服务要求增加服务器时间
		m.ServiceTime = new(string)
		*m.ServiceTime = time.Now().Format("2006-01-02 15:04:05")
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.CancelOrderReq:
		m := pb.CancelOrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.HolderCloseReq:
		m := pb.HolderCloseReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.DeliveryOrderReq:
		m := pb.DeliveryOrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.MakeUpDepositReq:
		m := pb.MakeUpDepositReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.HoldAppendDepositReq:
		m := pb.HoldAppendDepositReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.OfflineDeliveryReq:
		m := pb.OfflineDeliveryReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.HdWRDealOrderReq:
		m := pb.HdWRDealOrderReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.SupplementDepositReq:
		m := pb.SupplementDepositReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.RefundedDepositReq:
		m := pb.RefundedDepositReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.MarketOrderDeliveryApplyReq:
		m := pb.MarketOrderDeliveryApplyReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	case global.DeliveryClientOperatorReq:
		m := pb.DeliveryClientOperatorReq{}
		if err = r.reflect(data, &m); err != nil {
			return
		}
		if m.Header != nil {
			m.Header.RequestID = serialNumber
		} else {
			err = errors.New("请求信息序列化失败")
			return
		}
		if b, e := proto.Marshal(&m); e != nil {
			global.M2A_LOG.Error(e.Error(), zap.Error(e))
			err = errors.New("请求信息序列化失败")
			return
		} else {
			bytes = &b
		}
	}

	return
}

func (r *MQBodyReq) reflect(data string, m proto.Message) (err error) {
	// 由于JS对Long类型支持不佳，故让小程序端在使用单号时以字符串发过来，服务这边会自动把19位数字的字符串转化为数字
	reg, _ := regexp.Compile(`"[0-9]{19}"`)
	all := reg.FindAll([]byte(data), -1)
	for _, i := range all {
		r := strings.Replace(string(i), "\"", "", -1)
		data = strings.Replace(data, string(i), r, -1)
	}

	if e := jsonpb.UnmarshalString(data, m); e != nil {
		global.M2A_LOG.Error(e.Error(), zap.Error(e))
		err = errors.New("业务数据装箱失败")
		return
	}

	return
}

func (r *MQBodyReq) reflectNoLong(data string, m proto.Message) (err error) {
	if e := jsonpb.UnmarshalString(data, m); e != nil {
		global.M2A_LOG.Error(e.Error(), zap.Error(e))
		err = errors.New("业务数据装箱失败")
		return
	}

	return
}