consts/url.go

@@ -24,7 +24,6 @@ const (
 	LKL_ACCOUNT_BALANCE_QUERY_URL = "/v2/laep/industry/ewalletBalanceQuery"
 	// LKL_ACCOUNT_WITHDRAW_URL 拉卡拉账户提现
 	LKL_ACCOUNT_WITHDRAW_URL = "/v2/laep/industry/ewalletWithdrawD1"
-	LKL_SPLIT_LEDGER_FALLBACK_URL = "/v3/sacs/fallback"
 )
 
 const (
@@ -57,8 +56,6 @@ const (
 	LKL_EC_APPLY_MANUAL = "/v3/mms/open_api/ec/apply_manual"
 	// LKL_EC_QMA_STATUS 拉卡拉商户电子合同人工复核结果查询
 	LKL_EC_QMA_STATUS = "/v3/mms/open_api/ec/qma_status"
-	LKL_QUERY_SUB_MER_INFO_URL    = "/v2/mms/openApi/querySubMerInfo"
-	LKL_MRCH_AUTH_STATE_QUERY_URL = "/v2/mms/sme/mrchAuthStateQuery"
 )
 
 // unifiedReturn  统一退货API地址

lklsdk/account.go

@@ -39,25 +39,6 @@ func (a *AccountService[T]) BalanceQuery(req *model.BalanceQueryReqData) (*T, er
 	return respBody, nil
 }
 
-func (a *AccountService[T]) BalanceQueryTest(req *model.BalanceQueryReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_ACCOUNT_BALANCE_QUERY_URL
-
-	// 构建BaseModel请求
-	baseReq := model.BalanceQueryRequest{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "3.0",
-		ReqData: req,
-	}
-	// 发送请求
-	respBody, err := a.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBody, nil
-}
-
 // Withdraw 账户提现
 func (a *AccountService[T]) Withdraw(req *model.WithdrawReqData) (*T, error) {
 	// 构建请求参数
@@ -77,22 +58,3 @@ func (a *AccountService[T]) Withdraw(req *model.WithdrawReqData) (*T, error) {
 	}
 	return respBody, nil
 }
-
-func (a *AccountService[T]) WithdrawTest(req *model.WithdrawReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_ACCOUNT_WITHDRAW_URL
-
-	// 构建BaseModel请求
-	baseReq := model.WithdrawRequest{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := a.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}

lklsdk/common/json_cleaner.go

@@ -4,23 +4,27 @@ import (
 	"reflect"
 
 	"github.com/gogf/gf/v2/encoding/gjson"
-	"github.com/gogf/gf/v2/os/gctx"
-	"github.com/gogf/gf/v2/os/glog"
 )
 
 // CleanJSON 清理JSON字符串中的空值和0值字段
 func CleanJSON(jsonStr string) ([]byte, error) {
-	// 解析为JSON
+	var data interface{}
-	json := gjson.NewWithOptions(jsonStr, gjson.Options{StrNumber: true})
+
-	glog.Infof(gctx.New(), "Cleaning JSON: %+v", json)
+	// 解析JSON字符串
-	// 递归清理数据
+	if err := gjson.Unmarshal([]byte(jsonStr), &data); err != nil {
-	cleaned := cleanData(json.Interface())
-	jsons, err := gjson.DecodeToJson(cleaned, gjson.Options{StrNumber: true})
-	if err != nil {
-		glog.Errorf(gctx.New(), "Error decoding JSON: %v", err)
 		return nil, err
 	}
-	return jsons.ToJson()
+
+	// 递归清理数据
+	cleaned := cleanData(data)
+
+	// 转换回JSON字符串
+	result, err := gjson.Marshal(cleaned)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
 }
 
 // cleanData 递归清理map或slice中的空值和0值

lklsdk/merchant.go

@@ -205,48 +205,3 @@ func (t *MerService[T]) ReconsiderSubmitTest(req *model.ReConfSubmitRequestData)
 	}
 	return respBody, nil
 }
-
-func (t *MerService[T]) QuerySubMerInfo(req *model.QuerySubMerInfoReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_QUERY_SUB_MER_INFO_URL
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.QuerySubMerInfoRequest{
-		ReqData:   req,
-		ReqId:     md5,
-		Timestamp: time.Now().Unix(),
-		Ver:       "1.0",
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-func (t *MerService[T]) MrchAuthStateQuery(req *model.MrchAuthStateQueryReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_MRCH_AUTH_STATE_QUERY_URL
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.MrchAuthStateQueryRequest{
-		ReqData:   req,
-		ReqId:     md5,
-		Timestamp: time.Now().Unix(),
-		Ver:       "1.0",
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}

lklsdk/sdk.go

@@ -104,60 +104,31 @@ func (s *SDK[T]) ApplyLedgerMer(req *model.ApplyLedgerMerReqData) (*T, error) {
 	return s.SplitLedger.ApplyLedgerMer(req)
 }
 
-func (s *SDK[T]) ApplyLedgerMerTest(req *model.ApplyLedgerMerReqData) (*T, error) {
-	return s.SplitLedger.ApplyLedgerMerTest(req)
-}
-
 // QueryLedgerMer 商户分账信息查询
 func (s *SDK[T]) QueryLedgerMer(req *model.QueryLedgerMerReqData) (*T, error) {
 	return s.SplitLedger.QueryLedgerMer(req)
 }
 
-func (s *SDK[T]) QueryLedgerMerTest(req *model.QueryLedgerMerReqData) (*T, error) {
-	return s.SplitLedger.QueryLedgerMerTest(req)
-}
-
 // ApplyLedgerReceiver 分账接收方创建申请
 func (s *SDK[T]) ApplyLedgerReceiver(req *model.ApplyLedgerReceiverReqData) (*T, error) {
 	return s.SplitLedger.ApplyLedgerReceiver(req)
 }
 
-func (s *SDK[T]) ApplyLedgerReceiverTest(req *model.ApplyLedgerReceiverReqData) (*T, error) {
-	return s.SplitLedger.ApplyLedgerReceiverTest(req)
-}
-
 // ApplyBind 分账关系绑定申请
 func (s *SDK[T]) ApplyBind(req *model.ApplyBindReqData) (*T, error) {
 	return s.SplitLedger.ApplyBind(req)
 }
 
-func (s *SDK[T]) ApplyBindTest(req *model.ApplyBindReqData) (*T, error) {
-	return s.SplitLedger.ApplyBindTest(req)
-}
-
 // QuerySplitBalance 可分账金额查询
 func (s *SDK[T]) QuerySplitBalance(req *model.SplitBalanceReqData) (*T, error) {
 	return s.SplitLedger.QuerySplitBalance(req)
 }
 
-func (s *SDK[T]) QuerySplitBalanceTest(req *model.SplitBalanceReqData) (*T, error) {
-	return s.SplitLedger.QuerySplitBalanceTest(req)
-}
-
 // OrderSplitLedger 订单分账
 func (s *SDK[T]) OrderSplitLedger(req *model.OrderSplitLedgerReqData) (*T, error) {
 	return s.SplitLedger.OrderSplitLedger(req)
 }
 
-func (s *SDK[T]) OrderSplitLedgerTest(req *model.OrderSplitLedgerReqData) (*T, error) {
-	return s.SplitLedger.OrderSplitLedgerTest(req)
-}
-
-// OrderSplitLedgerFallback 订单分账回退
-func (s *SDK[T]) OrderSplitLedgerFallback(req *model.OrderSplitLedgerFallbackReqData) (*T, error) {
-	return s.SplitLedger.OrderSplitLedgerFallback(req)
-}
-
 // TradeQuery 交易查询
 func (s *SDK[T]) TradeQuery(req *model.TradeQueryReqData) (*T, error) {
 	return s.Trade.TradeQuery(req)
@@ -173,26 +144,15 @@ func (s *SDK[T]) BalanceQuery(req *model.BalanceQueryReqData) (*T, error) {
 	return s.Account.BalanceQuery(req)
 }
 
-func (s *SDK[T]) BalanceQueryTest(req *model.BalanceQueryReqData) (*T, error) {
-	return s.Account.BalanceQueryTest(req)
-}
-
 func (s *SDK[T]) UploadFileQuery(req *model.UploadFileReqData) (*T, error) {
 	return s.UploadFile.UploadFileQuery(req)
 }
-func (s *SDK[T]) UploadFileQueryTest(req *model.UploadFileReqData) (*T, error) {
-	return s.UploadFile.UploadFileQueryTest(req)
-}
 
 // Withdraw 账户提现
 func (s *SDK[T]) Withdraw(req *model.WithdrawReqData) (*T, error) {
 	return s.Account.Withdraw(req)
 }
 
-func (s *SDK[T]) WithdrawTest(req *model.WithdrawReqData) (*T, error) {
-	return s.Account.WithdrawTest(req)
-}
-
 // ECApply 电子合同申请
 func (s *SDK[T]) ECApply(req *ecApply.ECApplyRequestData) (*ecApply.ECApplyResponse, error) {
 	return s.EC.ECApply(req)
@@ -242,11 +202,3 @@ func (s *SDK[T]) ECQmaStatus(req *ecQmaStatus.ECQmaStatusRequestData) (*ecQmaSta
 func (s *SDK[T]) ECQmaStatusTest(req *ecQmaStatus.ECQmaStatusRequestData) (*ecQmaStatus.ECQmaStatusResponse, error) {
 	return s.ECPeQmaStatus.ECQmaStatusTest(req)
 }
-
-func (s *SDK[T]) QuerySubMerInfo(req *model.QuerySubMerInfoReqData) (*T, error) {
-	return s.Merchant.QuerySubMerInfo(req)
-}
-
-func (s *SDK[T]) MrchAuthStateQuery(req *model.MrchAuthStateQueryReqData) (*T, error) {
-	return s.Merchant.MrchAuthStateQuery(req)
-}

lklsdk/split_ledger.go

@@ -50,31 +50,6 @@ func (s *SplitLedgerService[T]) ApplyLedgerMer(req *model.ApplyLedgerMerReqData)
 	return respBody, nil
 }
 
-func (s *SplitLedgerService[T]) ApplyLedgerMerTest(req *model.ApplyLedgerMerReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_SPLIT_LEDGER_URL
-
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.ApplyLedgerMerRequest{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "2.0",
-		ReqData: req,
-		ReqId:   md5,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBody, nil
-}
-
 // ApplyLedgerReceiver 分账接收方创建申请
 func (s *SplitLedgerService[T]) ApplyLedgerReceiver(req *model.ApplyLedgerReceiverReqData) (*T, error) {
 	// 构建请求参数
@@ -101,31 +76,6 @@ func (s *SplitLedgerService[T]) ApplyLedgerReceiver(req *model.ApplyLedgerReceiv
 	return respBody, nil
 }
 
-func (s *SplitLedgerService[T]) ApplyLedgerReceiverTest(req *model.ApplyLedgerReceiverReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_SPLIT_LEDGER_RECEIVE_URL
-
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.ApplyLedgerReceiverRequest{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "2.0",
-		ReqId:   md5,
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBody, nil
-}
-
 // QueryLedgerMer 商户分账信息查询
 func (s *SplitLedgerService[T]) QueryLedgerMer(req *model.QueryLedgerMerReqData) (*T, error) {
 	// 构建请求参数
@@ -146,23 +96,3 @@ func (s *SplitLedgerService[T]) QueryLedgerMer(req *model.QueryLedgerMerReqData)
 
 	return respBody, nil
 }
-
-func (s *SplitLedgerService[T]) QueryLedgerMerTest(req *model.QueryLedgerMerReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_SPLIT_LEDGER_QUERY_URL
-
-	// 构建BaseModel请求
-	baseReq := model.QueryLedgerMerRequest{
-		ReqTime: time.Now().Format("20060102150405"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBody, nil
-}

lklsdk/split_ledger_more.go

@@ -36,30 +36,6 @@ func (s *SplitLedgerService[T]) ApplyBind(req *model.ApplyBindReqData) (*T, erro
 	return respBody, nil
 }
 
-func (s *SplitLedgerService[T]) ApplyBindTest(req *model.ApplyBindReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_SPLIT_LEDGER_RECEIVE_BIND_URL
-
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.ApplyBindRequest{
-		ReqTime: time.Now().Format("20060102150405"),
-		Version: "2.0",
-		ReqData: req,
-		ReqId:   md5,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-
 // QuerySplitBalance 可分账金额查询
 func (s *SplitLedgerService[T]) QuerySplitBalance(req *model.SplitBalanceReqData) (*T, error) {
 	// 构建请求参数
@@ -80,25 +56,6 @@ func (s *SplitLedgerService[T]) QuerySplitBalance(req *model.SplitBalanceReqData
 	return respBody, nil
 }
 
-func (s *SplitLedgerService[T]) QuerySplitBalanceTest(req *model.SplitBalanceReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_SPLIT_LEDGER_BALANCE_URL
-
-	// 构建BaseModel请求
-	baseReq := model.SplitBalanceRequest{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-
 // OrderSplitLedger 订单分账
 func (s *SplitLedgerService[T]) OrderSplitLedger(req *model.OrderSplitLedgerReqData) (*T, error) {
 	// 构建请求参数
@@ -118,41 +75,3 @@ func (s *SplitLedgerService[T]) OrderSplitLedger(req *model.OrderSplitLedgerReqD
 	}
 	return respBody, nil
 }
-
-func (s *SplitLedgerService[T]) OrderSplitLedgerTest(req *model.OrderSplitLedgerReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_ORDER_SPLIT_LEDGER_URL
-
-	// 构建BaseModel请求
-	baseReq := model.OrderSplitLedgerRequest{
-		ReqTime: time.Now().Format("20060102150405"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-
-func (s *SplitLedgerService[T]) OrderSplitLedgerFallback(req *model.OrderSplitLedgerFallbackReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_SPLIT_LEDGER_FALLBACK_URL
-
-	// 构建BaseModel请求
-	baseReq := model.OrderSplitLedgerFallbackRequest{
-		ReqTime: time.Now().Format("20060102150405"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}

lklsdk/uploadFile.go

@@ -46,26 +46,3 @@ func (t *UploadFileService[T]) UploadFileQuery(req *model.UploadFileReqData) (*T
 	}
 	return respBody, nil
 }
-
-func (t *UploadFileService[T]) UploadFileQueryTest(req *model.UploadFileReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_UPLOAD_FILE_URL
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.UploadFileRequest{
-		Timestamp: gconv.String(time.Now().Unix()),
-		Ver:       "1.0",
-		ReqId:     md5,
-		ReqData:   req,
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}

model/applyLedgerMer.go

@@ -23,7 +23,7 @@ type ApplyLedgerMerReqData struct {
 	SplitEntrustFilePath string                 `json:"splitEntrustFilePath"`  // 分账授权委托书文件路径，必传，长度64，调用附件上传接口获取
 	SplitRange           consts.SplitRange      `json:"splitRange"`            // 分账范围，必传，长度32，取值说明：ALL-全部交易分账(所有交易默认都分账)，MARK-标记交易分账(只有带标记交易才分账，其余交易正常结算)
 	SepFundSource        consts.SepFundSource   `json:"sepFundSource"`         // 分账依据，非必传，长度32，取值说明：TRA-交易分账，BAR-金额分账
-	EleContractNo        string                 `json:"eleContractNo"`         // 电子合同编号，非必传，长度32，收单已签约交易电子合同编号，供审核人员复核使用
+	ElecContractId       string                 `json:"elecContractId"`        // 电子合同编号，非必传，长度32，收单已签约交易电子合同编号，供审核人员复核使用
 	SplitLaunchMode      consts.SplitLaunchMode `json:"splitLaunchMode"`       // 分账发起方式，非必传，长度32，取值说明：AUTO-自动触发分账，POINTTRUE-指定规则分账，MANUAL-手动分账
 	SettleType           consts.SplitSettleType `json:"settleType"`            // 结算类型，非必传，长度32，取值说明：01-主扫现结，02-复扫现结，03-交易自动结算
 	SplitRuleSource      consts.SplitRuleSource `json:"splitRuleSource"`       // 分账规则来源，条件必传，长度32，取值说明：MER-商户自定规则，PLATFORM-平台分润规则(分润规则必传)

model/balanceQuery.go

@@ -35,30 +35,30 @@ type BalanceQueryReqData struct {
 // 包含响应状态码、消息和业务数据
 type BalanceQueryResponse struct {
 	// 响应状态码，000000
-	Code string `json:"retCode"`
+	Code string `json:"code"`
 	// 响应消息
-	Msg string `json:"retMsg"`
+	Msg string `json:"msg"`
 	// 响应业务数据，当code为SACS0000时返回
-	RespData *BalanceQueryRespData `json:"respData"`
+	RespData *BalanceQueryRespData `json:"resp_data"`
 }
 
 // BalanceQueryRespData 余额查询响应业务数据结构体
 // 包含余额查询返回的具体账户信息
 type BalanceQueryRespData struct {
 	// 账号，必传
-	PayNo string `json:"payNo"`
+	PayNo string `json:"pay_no"`
 	// 账户类型，必传
-	PayType string `json:"payType"`
+	PayType string `json:"pay_type"`
 	// 账户状态，必传，取值说明：CLOSE销户，NORMAL正常，FREEZE冻结，STOPAY止付
-	AcctSt string `json:"acctSt"`
+	AcctSt string `json:"acct_st"`
 	// 预付余额（单位元），必传
-	ForceBalance string `json:"forceBalance"`
+	ForceBalance string `json:"force_balance"`
 	// 上日余额（单位元）-该字段已废弃使用，必传
-	HisBalance string `json:"hisBalance"`
+	HisBalance string `json:"his_balance"`
 	// 实时余额（单位元），必传
-	ReBalance string `json:"reBalance"`
+	ReBalance string `json:"re_balance"`
 	// 当前可用余额（单位元），必传
-	CuBalance string `json:"cuBalance"`
+	CuBalance string `json:"cu_balance"`
 }
 
 // SuccessOrFail 判断余额查询请求是否成功

model/mrchAuthStateQuery.go

@@ -1,29 +0,0 @@
-package model
-
-type MrchAuthStateQueryRequest struct {
-	ReqData   *MrchAuthStateQueryReqData `json:"reqData"`
-	Ver       string                     `json:"ver"`
-	Timestamp int64                      `json:"timestamp"`
-	ReqId     string                     `json:"reqId"`
-}
-
-type MrchAuthStateQueryReqData struct {
-	TradeMode     string `json:"tradeMode" dc:"交易模式"`
-	SubMerchantId string `json:"subMerchantId" dc:"子商户号"`
-	MerchantNo    string `json:"merchantNo" dc:"商户号"`
-}
-
-type MrchAuthStateQueryResponse struct {
-	RetCode  string                      `json:"retCode"`
-	RetMsg   string                      `json:"retMsg"`
-	RespData *MrchAuthStateQueryRespData `json:"respData"`
-}
-
-type MrchAuthStateQueryRespData struct {
-	SubMerchantId string `json:"subMerchantId"`
-	CheckResult   string `json:"checkResult"`
-}
-
-func (t *MrchAuthStateQueryResponse) SuccessOrFail() bool {
-	return t.RetCode == "000000"
-}

model/orderSplitLedgerFallback.go

@@ -1,40 +0,0 @@
-package model
-
-type OrderSplitLedgerFallbackRequest struct {
-	ReqData *OrderSplitLedgerFallbackReqData `json:"req_data"` // 请求业务数据
-	Version string                           `json:"version"`  // 接口版本号
-	ReqTime string                           `json:"req_time"` // 请求时间，格式为yyyyMMddHHmmss
-}
-
-type OrderSplitLedgerFallbackReqData struct {
-	MerchantNo          string                             `json:"merchant_no"`            // 商户号，必传，长度32
-	OriginSeparateNo    string                             `json:"origin_separate_no"`     // 原分账单号，必传，长度32
-	OutSeparateNo       string                             `json:"out_separate_no"`        // 外部分账单号，必传，长度32
-	OriginOutSeparateNo string                             `json:"origin_out_separate_no"` // 原外部分账单号，必传，长度32
-	FallbackReason      string                             `json:"fallback_reason"`        // 回退原因，必传，长度255
-	TotalAmt            string                             `json:"total_amt"`              // 总金额，必传，长度15
-	OriginRecvDatas     []*OrderSplitLedgerOriginRecvDatas `json:"origin_recv_datas"`      // 原分账接收数据，必传，数组长度1-100
-}
-
-type OrderSplitLedgerOriginRecvDatas struct {
-	RecvNo string `json:"recv_no"` // 原分账接收号，必传，长度32
-	Amt    string `json:"amt"`     // 原分账接收金额，必传，长度15
-}
-
-type OrderSplitLedgerFallbackResponse struct {
-	Msg      string `json:"msg"`       // 消息
-	RespTime string `json:"resp_time"` // 响应时间
-	Code     string `json:"code"`      // 响应码 SACS0000表示成功
-	RespData struct {
-		OutSeparateNo       string `json:"out_separate_no"`        // 外部分账单号，必传，长度32
-		TotalAmt            string `json:"total_amt"`              // 总金额，必传，长度15
-		OriginOutSeparateNo string `json:"origin_out_separate_no"` // 原外部分账单号，必传，长度32
-		OriginSeparateNo    string `json:"origin_separate_no"`     // 原分账单号，必传，长度32
-		Status              string `json:"status"`                 // 状态，必传，长度1
-		SeparateNo          string `json:"separate_no"`            // 分账单号，必传，长度32
-	}
-}
-
-func (s *OrderSplitLedgerFallbackResponse) SuccessOrFail() bool {
-	return s.Code == "SACS0000"
-}

model/preorder.go

@@ -27,7 +27,6 @@ type PreorderReqData struct {
 		Location  string `json:"location"`   // 纬度,经度，商户终端的地理位置，银联二维码交易必填，整体格式：纬度,经度，+表示北纬、东经，-表示南纬、西经。经度格式：1位正负号+3位整数+1位小数点+5位小数；纬度格式：1位正负号+2位整数+1位小数点+6位小数；举例：+31.221345,+121.12345，String(32)
 	} `json:"location_info"` // 地址位置信息，Object
 	Subject string `json:"subject"` // 订单标题，用于简单描述订单或商品主题，传输给账户端（账户端控制，实际最多42个字节），微信支付必送，String(42)
-	AccBusiFields *AccBusiFields `json:"acc_busi_fields"` // 账户业务字段，Object
 }
 
 func NewPreorder(param *PreorderReqData) *Preorder {

model/queryLedgerMer.go

@@ -5,11 +5,11 @@ package model
 // 包含请求头信息和业务数据
 type QueryLedgerMerRequest struct {
 	// 请求业务数据
-	ReqData *QueryLedgerMerReqData `json:"reqData"`
+	ReqData *QueryLedgerMerReqData `json:"req_data"`
 	// 接口版本号
 	Version string `json:"version"`
 	// 请求时间，格式为yyyyMMddHHmmss
-	ReqTime string `json:"reqTime"`
+	ReqTime string `json:"req_time"`
 }
 
 // QueryLedgerMerReqData 分账商户查询请求业务数据结构体
@@ -19,13 +19,13 @@ type QueryLedgerMerReqData struct {
 	// 接口版本号，必传，长度8，取值说明：1.0
 	Version string `json:"version"`
 	// 订单编号（便于后续跟踪排查问题及核对报文），必传，长度32，取值说明：14位年月日（24小时制）分秒+8位的随机数（不重复）
-	OrderNo string `json:"orderNo"`
+	OrderNo string `json:"order_no"`
 	// 机构代码，必传，长度32
-	OrgCode string `json:"orgCode"`
+	OrgCode string `json:"org_code"`
 	// 拉卡拉内部商户号，可选，长度32，取值说明：拉卡拉内部商户号和银联商户号必须传一个，都送以内部商户号为准
-	MerInnerNo string `json:"merInnerNo"`
+	MerInnerNo string `json:"mer_inner_no"`
 	// 银联商户号，可选，长度32，取值说明：拉卡拉内部商户号和银联商户号必须传一个，都送以内部商户号为准
-	MerCupNo string `json:"merCupNo"`
+	MerCupNo string `json:"mer_cup_no"`
 }
 
 // QueryLedgerMerResponse 分账商户查询响应结构体
@@ -33,58 +33,58 @@ type QueryLedgerMerReqData struct {
 // 包含响应状态码、消息和业务数据
 type QueryLedgerMerResponse struct {
 	// 响应状态码，000000表示成功
-	RetCode string `json:"retCode"`
+	Code string `json:"code"`
 	// 响应消息
-	RetMsg string `json:"retMsg"`
+	Msg string `json:"msg"`
 	// 响应业务数据，当code为000000时返回
-	RespData *QueryLedgerMerRespData `json:"respData"`
+	RespData *QueryLedgerMerRespData `json:"resp_data"`
 }
 
 // QueryLedgerMerRespData 分账商户查询响应业务数据结构体
 // 包含分账商户查询返回的具体业务信息
 type QueryLedgerMerRespData struct {
 	// 分账商户机构号
-	OrgId string `json:"orgId"`
+	OrgId string `json:"org_id"`
 	// 分账商户机构名称
-	OrgName string `json:"orgName"`
+	OrgName string `json:"org_name"`
 	// 拉卡拉内部商户号
-	MerInnerNo string `json:"merInnerNo"`
+	MerInnerNo string `json:"mer_inner_no"`
 	// 银联商户号
-	MerCupNo string `json:"merCupNo"`
+	MerCupNo string `json:"mer_cup_no"`
 	// 最低分账比例（百分比，支持2位精度），取值说明：70或70.50
-	SplitLowestRatio float64 `json:"splitLowestRatio"`
+	SplitLowestRatio string `json:"split_lowest_ratio"`
 	// 商户分账状态，取值说明：VALID启用，INVALID禁用
-	SplitStatus string `json:"splitStatus"`
+	SplitStatus string `json:"split_status"`
 	// 分账范围，取值说明：ALL：全部交易分账(商户所有交易默认待分账)，MARK：标记交易分账(只有带分账标识交易待分账，其余交易正常结算)，默认：MARK
-	SplitRange string `json:"splitRange"`
+	SplitRange string `json:"split_range"`
 	// 分账依据，取值说明：TR或空：交易分账，BA：余额分账，默认：TR交易分账
-	SepFundSource string `json:"sepFundSource"`
+	SepFundSource string `json:"sep_fund_source"`
 	// 平台ID，取值说明：如果商户和绑定平台分账，返回平台ID
-	PlatformId string `json:"platformId"`
+	PlatformId string `json:"platform_id"`
 	// 分账发起方式，取值说明：AUTO：自动规则分账，POINTRULE：指定规则分账，MANUAL：手动规则分账
-	SplitLaunchMode string `json:"splitLaunchMode"`
+	SplitLaunchMode string `json:"split_launch_mode"`
 	// 分账规则来源，取值说明：MER：商户分账规则，PLATFORM：平台分账规则
-	SplitRuleSource string `json:"splitRuleSource"`
+	SplitRuleSource string `json:"split_rule_source"`
 	// 已绑定接收方列表
-	BindRelations []*BindRelation `json:"bindRelations"`
+	BindRelations []*BindRelation `json:"bind_relations"`
 }
 
 // BindRelation 已绑定接收方信息结构体
 // 用于表示分账商户已绑定的接收方信息
 type BindRelation struct {
 	// 拉卡拉内部商户号
-	MerInnerNo string `json:"merInnerNo"`
+	MerInnerNo string `json:"mer_inner_no"`
 	// 银联商户号
-	MerCupNo string `json:"merCupNo"`
+	MerCupNo string `json:"mer_cup_no"`
 	// 接收方编号
-	ReceiverNo string `json:"receiverNo"`
+	ReceiverNo string `json:"receiver_no"`
 	// 接收方编号名称
-	ReceiverName string `json:"receiverName"`
+	ReceiverName string `json:"receiver_name"`
 }
 
 // SuccessOrFail 判断分账商户查询请求是否成功
 // 成功条件：响应码为000000
 // 返回值：true表示成功，false表示失败
 func (resp *QueryLedgerMerResponse) SuccessOrFail() bool {
-	return resp.RetCode == "000000"
+	return resp.Code == "000000"
 }

model/querySubMerInfo.go

@@ -1,50 +0,0 @@
-package model
-
-type QuerySubMerInfoRequest struct {
-	ReqData   *QuerySubMerInfoReqData `json:"reqData"`
-	Ver       string                  `json:"ver"`
-	Timestamp int64                   `json:"timestamp"`
-	ReqId     string                  `json:"reqId"`
-}
-
-type QuerySubMerInfoReqData struct {
-	Version         string `json:"version" dc:"接口版本号"`
-	OrderNo         string `json:"orderNo" dc:"订单编号,保证唯一"`
-	OrgCode         string `json:"orgCode" dc:"机构代码"`
-	MerInnerNo      string `json:"merInnerNo" dc:"拉卡拉内部商户号和银联商户号必须传一个，都送以内部商户号为准。"`
-	MerCupNo        string `json:"merCupNo" dc:"拉卡拉内部商户号和银联商户号必须传一个，都送以内部商户号为准。"`
-	RegisterChannel string `json:"registerChannel" dc:"报备渠道"`
-	RegisterType    string `json:"registerType" dc:"报备类型"`
-	RegisterStatus  string `json:"registerStatus" dc:"报备状态 SUCCESS：成功；FAIL：失败"`
-	SubMchId        string `json:"subMchId" dc:"子商户号"`
-}
-
-type QuerySubMerInfoResponse struct {
-	RetCode  string                   `json:"retCode"`
-	RetMsg   string                   `json:"retMsg"`
-	RespData *QuerySubMerInfoRespData `json:"respData"`
-}
-
-type QuerySubMerInfoRespData struct {
-	OrgCode string          `json:"orgCode"`
-	OrderNo string          `json:"orderNo"`
-	List    []*RegisterList `json:"list"`
-}
-type RegisterList struct {
-	MerInnerNo      string `json:"merInnerNo" dc:"内部商户号"`
-	SubMchId        string `json:"subMchId" dc:"子商户号"`
-	SubMchIdBank    string `json:"subMchIdBank" dc:"交易子商户号"`
-	DcWalletId      string `json:"dcWalletId" dc:"数币钱包ID"`
-	ChannelId       string `json:"channelId" dc:"渠道号"`
-	ReceOrgNo       string `json:"receOrgNo" dc:"从业机构号"`
-	RegisterChannel string `json:"registerChannel" dc:"报备渠道"`
-	RegisterType    string `json:"registerType" dc:"报备类型"`
-	RegisterTm      string `json:"registerTm" dc:"报备时间"`
-	RegisterStatus  string `json:"registerStatus" dc:"报备状态"`
-	ResultCode      string `json:"resultCode" dc:"结果返回码"`
-	ResultMessage   string `json:"resultMessage" dc:"结果描述"`
-}
-
-func (t *QuerySubMerInfoResponse) SuccessOrFail() bool {
-	return t.RetCode == "000000"
-}

model/tradeQuery.go

@@ -69,5 +69,5 @@ type TradeQueryResponse struct {
 }
 
 func (t *TradeQueryResponse) SuccessOrFail() bool {
-	return t.Code == "BBS00000"
+	return t.Code == "000000"
 }