feat(lklsdk): 新增订单分账结果查询功能

- 在SDK中增加OrderSplitLedgerResultQuery方法 - 重命名SplitLedgerResultQuery为OrderSplitLedgerResultQuery - 更新相关请求和响应结构体名称以匹配新功能 - 调整模型文件名以反映新的功能用途 - 确保接口版本和请求时间字段正确设置 - 维持原有的分账状态和明细数据处理逻辑
feat(split): 新增分账结果查询接口
2025-12-05 10:22:30 +08:00 · 2025-12-05 10:03:16 +08:00 · 2025-11-14 09:12:04 +08:00 · 2025-11-13 09:23:20 +08:00 · 2025-11-13 09:10:07 +08:00 · 2025-11-12 16:57:47 +08:00
12 changed files with 387 additions and 45 deletions
@@ -23,7 +23,8 @@ const (
 	// LKL_ACCOUNT_BALANCE_QUERY_URL 拉卡拉账户余额查询
 	LKL_ACCOUNT_BALANCE_QUERY_URL = "/v2/laep/industry/ewalletBalanceQuery"
 	// LKL_ACCOUNT_WITHDRAW_URL 拉卡拉账户提现
-	LKL_ACCOUNT_WITHDRAW_URL = "/v2/laep/industry/ewalletWithdrawD1"
+	LKL_ACCOUNT_WITHDRAW_URL          = "/v2/laep/industry/ewalletWithdrawD1"
+	LKL_SPLIT_LEDGER_RESULT_QUERY_URL = "/v3/sacs/query_plus"
 )

 const (
@@ -39,6 +39,25 @@ 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) {
 	// 构建请求参数
@@ -58,3 +77,22 @@ 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
+}
@@ -1,29 +1,26 @@
 package common

 import (
-	"encoding/json"
 	"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) {
-	var data interface{}
-
-	// 解析JSON字符串
-	if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
-		return nil, err
-	}
-
+	// 解析为JSON
+	json := gjson.NewWithOptions(jsonStr, gjson.Options{StrNumber: true})
+	glog.Infof(gctx.New(), "Cleaning JSON: %+v", json)
 	// 递归清理数据
-	cleaned := cleanData(data)
-
-	// 转换回JSON字符串
-	result, err := json.Marshal(cleaned)
+	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 result, nil
+	return jsons.ToJson()
 }

 // cleanData 递归清理map或slice中的空值和0值
@@ -160,6 +160,29 @@ func (t *MerService[T]) MerValidateTest(req *model.MerValidateRequestData) (*T,
 	return respBody, nil
 }

+func (t *MerService[T]) ReconsiderSubmit(req *model.ReConfSubmitRequestData) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_URL + consts.LKL_RECONF_SUBMIT
+	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
+	if err != nil {
+		return nil, fmt.Errorf("创建ReqId失败")
+	}
+	// 构建BaseModel请求
+	baseReq := model.ReConfSubmitRequest{
+		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]) ReconsiderSubmitTest(req *model.ReConfSubmitRequestData) (*T, error) {
 	// 构建请求参数
 	url := consts.BASE_TEST_URL + consts.LKL_RECONF_SUBMIT
@@ -7,8 +7,8 @@ package querystatus
 // 生产环境：https://s2.lakala.com/api/v3/mms/open_api/ec/q_status
 type ECQueryStatusRequestData struct {
 	OrderNo   string `json:"order_no" dc:"四方机构自定义订单编号 必选，建议：平台编号+14位年月日时（24小时制）分秒+8位的随机数（同一接入机构不重复）"` // 必选，建议：平台编号+14位年月日时（24小时制）分秒+8位的随机数（同一接入机构不重复）
-	OrgID     int    `json:"org_id" dc:"机构号 必选，签约方所属拉卡拉机构"`                                     // 必选，签约方所属拉卡拉机构
-	EcApplyID int64  `json:"ec_apply_id" dc:"电子合同申请受理号 必选，申请接口反馈编号"`                               // 必选，申请接口反馈编号
+	OrgCode   int    `json:"org_code" dc:"机构号 必选，签约方所属拉卡拉机构"`                                         // 必选，签约方所属拉卡拉机构
+	EcApplyID int64  `json:"ec_apply_id" dc:"电子合同申请受理号 必选，申请接口反馈编号"`                                  // 必选，申请接口反馈编号
 }

 // ECQueryStatusRequest 电子合同查询状态请求
@@ -16,4 +16,4 @@ type ECQueryStatusRequest struct {
 	ReqTime string                    `json:"req_time" dc:"请求时间"` // 必选，格式：yyyyMMddHHmmss
 	ReqData *ECQueryStatusRequestData `json:"req_data" dc:"请求数据"` // 请求数据
 	Version string                    `json:"version" dc:"版本号"`   // 必选，固定值：1.0
-}
+}
@@ -54,21 +54,41 @@ func (s *SDK[T]) ReconsiderSubmit(req *model.ReConfSubmitRequestData) (*T, error
 	return s.Merchant.ReconsiderSubmit(req)
 }

+// ReconsiderSubmitTest 商户进件复议提交
+func (s *SDK[T]) ReconsiderSubmitTest(req *model.ReConfSubmitRequestData) (*T, error) {
+	return s.Merchant.ReconsiderSubmitTest(req)
+}
+
 // QueryMerchant 商户进件信息查询
 func (s *SDK[T]) QueryMerchant(req *model.QueryMerRequestData) (*T, error) {
 	return s.Merchant.QueryMer(req)
 }

+// QueryMerchantTest 商户进件信息查询
+func (s *SDK[T]) QueryMerchantTest(req *model.QueryMerRequestData) (*T, error) {
+	return s.Merchant.QueryMerTest(req)
+}
+
 // MerValidate 商户进件信息校验
 func (s *SDK[T]) MerValidate(req *model.MerValidateRequestData) (*T, error) {
 	return s.Merchant.MerValidate(req)
 }

+// MerValidateTest 商户进件信息校验
+func (s *SDK[T]) MerValidateTest(req *model.MerValidateRequestData) (*T, error) {
+	return s.Merchant.MerValidateTest(req)
+}
+
 // AddMer 商户进件
 func (s *SDK[T]) AddMer(req *model.MerchantApplyReqData) (*T, error) {
 	return s.Merchant.AddMer(req)
 }

+// AddMerTest 商户进件
+func (s *SDK[T]) AddMerTest(req *model.MerchantApplyReqData) (*T, error) {
+	return s.Merchant.AddMerTest(req)
+}
+
 // MergePreOrder 主扫合单交易
 func (s *SDK[T]) MergePreOrder(req *model.MergePreorderReqData) (*T, error) {
 	return s.MergePre.PreOrder(req)
@@ -84,31 +104,60 @@ 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)
+}
+
+// OrderSplitLedgerResultQuery 订单分账结果查询
+func (s *SDK[T]) OrderSplitLedgerResultQuery(req *model.OrderSplitLedgerResultQueryReqData) (*T, error) {
+	return s.SplitLedger.OrderSplitLedgerResultQuery(req)
+}
+
 // TradeQuery 交易查询
 func (s *SDK[T]) TradeQuery(req *model.TradeQueryReqData) (*T, error) {
 	return s.Trade.TradeQuery(req)
@@ -124,15 +173,26 @@ 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)
@@ -50,6 +50,31 @@ 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) {
 	// 构建请求参数
@@ -76,6 +101,31 @@ 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) {
 	// 构建请求参数
@@ -96,3 +146,23 @@ 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
+}
@@ -36,6 +36,30 @@ 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) {
 	// 构建请求参数
@@ -56,6 +80,25 @@ 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) {
 	// 构建请求参数
@@ -75,3 +118,41 @@ 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]) OrderSplitLedgerResultQuery(req *model.OrderSplitLedgerResultQueryReqData) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_URL + consts.LKL_SPLIT_LEDGER_RESULT_QUERY_URL
+
+	// 构建BaseModel请求
+	baseReq := model.OrderSplitLedgerResultQueryRequest{
+		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
+}
@@ -46,3 +46,26 @@ 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
+}
@@ -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-金额分账
-	ElecContractId       string                 `json:"elecContractId"`        // 电子合同编号，非必传，长度32，收单已签约交易电子合同编号，供审核人员复核使用
+	EleContractNo        string                 `json:"eleContractNo"`         // 电子合同编号，非必传，长度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-平台分润规则(分润规则必传)
@@ -0,0 +1,49 @@
+package model
+
+type OrderSplitLedgerResultQueryRequest struct {
+	ReqData *OrderSplitLedgerResultQueryReqData `json:"req_data"` // 请求业务数据
+	Version string                              `json:"version"`  // 接口版本号
+	ReqTime string                              `json:"req_time"` // 请求时间，格式为yyyyMMddHHmmss
+}
+
+type OrderSplitLedgerResultQueryReqData struct {
+	MerchantNo    string `json:"merchant_no"`     // 商户号，必传，长度32
+	SeparateNo    string `json:"separate_no"`     // 分账核心系统返回的分账流水号，入参中的separate_no,out_separate_no至少二选一，优先级: separate_no> out_separate_no
+	OutSeparateNo string `json:"out_separate_no"` // 商户分账指令流水号，入入参中的separate_no,out_separate_no至少二选一，优先级: separate_no> out_separate_no
+}
+
+type OrderSplitLedgerResultQueryResponse struct {
+	Msg      string `json:"msg"`       // 消息
+	RespTime string `json:"resp_time"` // 响应时间
+	Code     string `json:"code"`      // 响应码 SACS0000表示成功
+	RespData struct {
+		SeparateNo        string                                        `json:"separate_no"`         // 分账指令流水号
+		OutSeparateNo     string                                        `json:"out_separate_no"`     // 商户分账指令流水号
+		CmdType           string                                        `json:"cmd_type"`            // 指令类型 SEPARATE：分账 CANCEL：分账撤销 FALLBACK：分账回退
+		LogNo             string                                        `json:"log_no"`              // 拉卡拉对账单流水号
+		LogDate           string                                        `json:"log_date"`            // 交易日期  posp日期，yyyyMMdd，查清结算用
+		CalType           string                                        `json:"cal_type"`            // 分账计算类型 0 按照指定金额。1 按照指定比例，默认 0 （cmd_type为SEPARATE分账指令类型才有值）
+		SeparateDate      string                                        `json:"separate_date"`       // 分账日期
+		FinishDate        string                                        `json:"finish_date"`         // 完成日期
+		TotalAmt          string                                        `json:"total_amt"`           // 发生总金额，单位为分
+		Status            string                                        `json:"status"`              // 分账状态，ACCEPTED:已受理, PROCESSING:处理中, FAIL:失败, SUCCESS:成功, （如果分账指令后有反向操作指令，则原分账指令会变更成以下的状态之一：） CANCELING:撤销中, CANCELED:撤销成功, CANCEL_FAIL:撤销失败, FALLBACKING:回退中, FALLBACK_END:回退结束
+		FinalStatus       string                                        `json:"final_status"`        // 处理状态 ACCEPTED:已受理, PROCESSING:处理中, FAIL:失败, SUCCESS:成功
+		FrontRuleId       string                                        `json:"front_rule_id"`       // 分账前置规则ID
+		ActualSeparateAmt string                                        `json:"actual_separate_amt"` // 实分金额
+		TotalFeeAmt       string                                        `json:"total_fee_amt"`       // 手续费金额
+		AccResultDesc     string                                        `json:"acc_result_desc"`     // 账户处理错误描述
+		DetailDatas       []*OrderSplitLedgerResultQueryRespDetailDatas `json:"detail_datas"`        // 明细数据
+	}
+}
+
+type OrderSplitLedgerResultQueryRespDetailDatas struct {
+	RecvMerchantNo string `json:"recv_merchant_no"` // 接收方商户号
+	RecvNo         string `json:"recv_no"`          // 接收方编号
+	Amt            string `json:"amt"`              // 分账金额
+	ActualAmt      string `json:"actual_amt"`       // 实分金额
+	FeeAmt         string `json:"fee_amt"`          // 手续费金额
+}
+
+func (s *OrderSplitLedgerResultQueryResponse) SuccessOrFail() bool {
+	return s.Code == "SACS0000"
+}
@@ -5,11 +5,11 @@ package model
 // 包含请求头信息和业务数据
 type QueryLedgerMerRequest struct {
 	// 请求业务数据
-	ReqData *QueryLedgerMerReqData `json:"req_data"`
+	ReqData *QueryLedgerMerReqData `json:"reqData"`
 	// 接口版本号
 	Version string `json:"version"`
 	// 请求时间，格式为yyyyMMddHHmmss
-	ReqTime string `json:"req_time"`
+	ReqTime string `json:"reqTime"`
 }

 // QueryLedgerMerReqData 分账商户查询请求业务数据结构体
@@ -19,13 +19,13 @@ type QueryLedgerMerReqData struct {
 	// 接口版本号，必传，长度8，取值说明：1.0
 	Version string `json:"version"`
 	// 订单编号（便于后续跟踪排查问题及核对报文），必传，长度32，取值说明：14位年月日（24小时制）分秒+8位的随机数（不重复）
-	OrderNo string `json:"order_no"`
+	OrderNo string `json:"orderNo"`
 	// 机构代码，必传，长度32
-	OrgCode string `json:"org_code"`
+	OrgCode string `json:"orgCode"`
 	// 拉卡拉内部商户号，可选，长度32，取值说明：拉卡拉内部商户号和银联商户号必须传一个，都送以内部商户号为准
-	MerInnerNo string `json:"mer_inner_no"`
+	MerInnerNo string `json:"merInnerNo"`
 	// 银联商户号，可选，长度32，取值说明：拉卡拉内部商户号和银联商户号必须传一个，都送以内部商户号为准
-	MerCupNo string `json:"mer_cup_no"`
+	MerCupNo string `json:"merCupNo"`
 }

 // QueryLedgerMerResponse 分账商户查询响应结构体
@@ -33,58 +33,58 @@ type QueryLedgerMerReqData struct {
 // 包含响应状态码、消息和业务数据
 type QueryLedgerMerResponse struct {
 	// 响应状态码，000000表示成功
-	Code string `json:"code"`
+	RetCode string `json:"retCode"`
 	// 响应消息
-	Msg string `json:"msg"`
+	RetMsg string `json:"retMsg"`
 	// 响应业务数据，当code为000000时返回
-	RespData *QueryLedgerMerRespData `json:"resp_data"`
+	RespData *QueryLedgerMerRespData `json:"respData"`
 }

 // QueryLedgerMerRespData 分账商户查询响应业务数据结构体
 // 包含分账商户查询返回的具体业务信息
 type QueryLedgerMerRespData struct {
 	// 分账商户机构号
-	OrgId string `json:"org_id"`
+	OrgId string `json:"orgId"`
 	// 分账商户机构名称
-	OrgName string `json:"org_name"`
+	OrgName string `json:"orgName"`
 	// 拉卡拉内部商户号
-	MerInnerNo string `json:"mer_inner_no"`
+	MerInnerNo string `json:"merInnerNo"`
 	// 银联商户号
-	MerCupNo string `json:"mer_cup_no"`
+	MerCupNo string `json:"merCupNo"`
 	// 最低分账比例（百分比，支持2位精度），取值说明：70或70.50
-	SplitLowestRatio string `json:"split_lowest_ratio"`
+	SplitLowestRatio float64 `json:"splitLowestRatio"`
 	// 商户分账状态，取值说明：VALID启用，INVALID禁用
-	SplitStatus string `json:"split_status"`
+	SplitStatus string `json:"splitStatus"`
 	// 分账范围，取值说明：ALL：全部交易分账(商户所有交易默认待分账)，MARK：标记交易分账(只有带分账标识交易待分账，其余交易正常结算)，默认：MARK
-	SplitRange string `json:"split_range"`
+	SplitRange string `json:"splitRange"`
 	// 分账依据，取值说明：TR或空：交易分账，BA：余额分账，默认：TR交易分账
-	SepFundSource string `json:"sep_fund_source"`
+	SepFundSource string `json:"sepFundSource"`
 	// 平台ID，取值说明：如果商户和绑定平台分账，返回平台ID
-	PlatformId string `json:"platform_id"`
+	PlatformId string `json:"platformId"`
 	// 分账发起方式，取值说明：AUTO：自动规则分账，POINTRULE：指定规则分账，MANUAL：手动规则分账
-	SplitLaunchMode string `json:"split_launch_mode"`
+	SplitLaunchMode string `json:"splitLaunchMode"`
 	// 分账规则来源，取值说明：MER：商户分账规则，PLATFORM：平台分账规则
-	SplitRuleSource string `json:"split_rule_source"`
+	SplitRuleSource string `json:"splitRuleSource"`
 	// 已绑定接收方列表
-	BindRelations []*BindRelation `json:"bind_relations"`
+	BindRelations []*BindRelation `json:"bindRelations"`
 }

 // BindRelation 已绑定接收方信息结构体
 // 用于表示分账商户已绑定的接收方信息
 type BindRelation struct {
 	// 拉卡拉内部商户号
-	MerInnerNo string `json:"mer_inner_no"`
+	MerInnerNo string `json:"merInnerNo"`
 	// 银联商户号
-	MerCupNo string `json:"mer_cup_no"`
+	MerCupNo string `json:"merCupNo"`
 	// 接收方编号
-	ReceiverNo string `json:"receiver_no"`
+	ReceiverNo string `json:"receiverNo"`
 	// 接收方编号名称
-	ReceiverName string `json:"receiver_name"`
+	ReceiverName string `json:"receiverName"`
 }

 // SuccessOrFail 判断分账商户查询请求是否成功
 // 成功条件：响应码为000000
 // 返回值：true表示成功，false表示失败
 func (resp *QueryLedgerMerResponse) SuccessOrFail() bool {
-	return resp.Code == "000000"
+	return resp.RetCode == "000000"
 }
Author	SHA1	Message	Date
gaoda	4a46686a68	feat(lklsdk): 新增订单分账结果查询功能 - 在SDK中增加OrderSplitLedgerResultQuery方法 - 重命名SplitLedgerResultQuery为OrderSplitLedgerResultQuery - 更新相关请求和响应结构体名称以匹配新功能 - 调整模型文件名以反映新的功能用途 - 确保接口版本和请求时间字段正确设置 - 维持原有的分账状态和明细数据处理逻辑	2025-12-05 10:22:30 +08:00
gaoda	a7dca57d23	feat(split): 新增分账结果查询接口 - 在 consts/url.go 中新增分账结果查询 URL 常量 - 实现 SplitLedgerService 的 SplitLedgerResultQuery 方法 - 新增 model/splitLedgerResult.go 文件定义相关请求和响应结构体 - 支持通过 separate_no 或 out_separate_no 查询分账结果 - 返回详细的分账状态、金额及明细信息	2025-12-05 10:03:16 +08:00
gaoda	5d502d371a	feat(model): 修改分账最低比例字段类型 - 将 SplitLowestRatio 字段从 string 类型改为 float64 类型 - 提高数值处理的准确性和效率- 支持更精确的分账比例计算- 保持与其他数值字段类型的统一性 - 更新相关数据序列化逻辑以适应新类型- 确保前后端数据传输兼容性	2025-11-14 09:12:04 +08:00
gaoda	6edab2db55	refactor(model): 修改QueryLedgerMerResponse字段名以提高一致性 - 将Code字段重命名为RetCode - 将Msg字段重命名为RetMsg - 更新SuccessOrFail方法中对RetCode的引用 - 保持与其它响应模型结构的一致性- 确保JSON序列化标签同步更新 - 维持原有的业务逻辑判断规则	2025-11-13 09:23:20 +08:00
gaoda	468950e555	feat(model): 更新分账商户查询接口字段命名 - 将 req_data 字段重命名为 reqData - 将 req_time 字段重命名为 reqTime - 将 order_no 字段重命名为 orderNo - 将 org_code 字段重命名为 orgCode - 将 mer_inner_no 字段重命名为 merInnerNo - 将 mer_cup_no 字段重命名为 merCupNo - 将 resp_data 字段重命名为 respData- 将 org_id 字段重命名为 orgId- 将 org_name 字段重命名为 orgName - 将 split_lowest_ratio 字段重命名为 splitLowestRatio- 将 split_status 字段重命名为 splitStatus- 将 split_range 字段重命名为 splitRange- 将 sep_fund_source 字段重命名为 sepFundSource- 将 platform_id 字段重命名为 platformId- 将 split_launch_mode 字段重命名为 splitLaunchMode - 将 split_rule_source 字段重命名为 splitRuleSource - 将 bind_relations 字段重命名为 bindRelations - 将 receiver_no 字段重命名为 receiverNo- 将 receiver_name 字段重命名为 receiverName	2025-11-13 09:10:07 +08:00
gaoda	2f9a46a6d9	fix(model): 修改电子合同编号字段名 - 将 ElecContractId 字段重命名为 EleContractNo - 保持字段注释和长度限制不变 - 确保与其他相关模块的兼容性	2025-11-12 16:57:47 +08:00
gaoda	14ef8bf585	feat(lklsdk): 添加测试环境接口支持 - 为账户服务增加余额查询和提现的测试接口 - 为分账服务增加商户申请、接收方申请、绑定关系等测试接口 -为上传文件服务增加测试环境查询接口 - 统一测试接口的URL使用BASE_TEST_URL常量 - 完善SDK层对所有新增测试接口的封装支持	2025-11-12 15:52:24 +08:00
maguodong	b10df1f064	refactor(common):优化JSON清理逻辑 - 使用gjson.NewWithOptions替代gjson.DecodeToJson解析JSON字符串- 添加日志记录清理过程中的JSON数据 - 修改cleanData函数参数类型为interface{} - 更新错误处理逻辑并添加错误日志 - 调整JSON编码方式，使用ToJson()方法返回结果 - 移除不必要的类型转换和中间变量声明	2025-11-12 15:05:04 +08:00
gaoda	aab78082ce	refactor(common):优化JSON清理逻辑 - 使用gjson.DecodeToJson替代gjson.Unmarshal提高解析效率 - 添加StrNumber选项支持字符串数字处理 - 简化数据清理流程 - 移除不必要的中间变量声明 - 提升JSON解析的准确性和性能	2025-11-12 10:58:30 +08:00
gaoda	59158d7309	Merge remote-tracking branch 'origin/main' # Conflicts: # lklsdk/common/json_cleaner.go	2025-11-12 10:51:41 +08:00
maguodong	6f685ea087	Merge remote-tracking branch 'github.com/black1552/main'	2025-11-12 10:08:55 +08:00
maguodong	b038c64873	refactor(common): 替换JSON处理库为gjson - 使用gjson替代标准库encoding/json- 更新Unmarshal调用为gjson.Unmarshal - 更新Marshal调用为gjson.Marshal- 移除未使用的json导入声明	2025-11-12 10:08:36 +08:00
gaoda	03aec086bf	refactor(common): 替换JSON处理库为gjson -encoding 将标准库/json替换为github.com/gogf/gf/v2/encoding/gjson - 更新Unmarshal方法调用为gjson.Unmarshal- 更新Marshal方法调用为gjson.Marshal- 保持原有数据清理逻辑不变	2025-11-12 09:55:46 +08:00
gaoda	8eeee5cbe1	fix(merchant): 更新电子合同查询状态请求字段 - 将 OrgID 字段重命名为 OrgCode以匹配拉卡拉机构号定义- 保持 EcApplyID 字段定义不变 - 调整结构体字段注释格式以提高可读性	2025-11-10 09:52:15 +08:00
maguodong	aa5b400ee8	feat(lklsdk): 新增商户进件复议提交功能 - 在MerService中实现ReconsiderSubmit方法，支持构建并发送复议提交请求 - 在SDK中暴露ReconsiderSubmitTest方法，用于测试环境的复议提交 - 同步新增QueryMerchantTest、MerValidateTest和AddMerTest等测试方法 - 所有新接口均遵循现有请求封装逻辑，确保一致性和可维护性	2025-11-08 09:00:05 +08:00