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

README.md

@@ -6,14 +6,45 @@
 
 ```
 lklsdk/
-├── client.go           # 核心客户端
+├── account.go          # 账户相关功能
+├── common/             # 通用工具和客户端
+│   ├── client.go       # 核心客户端
+│   ├── json_cleaner.go # JSON清理工具
+│   └── structs.go      # 通用结构体定义
+├── merchant.go         # 商户相关功能
+├── merchant/           # 商户相关模块
+│   └── in_net/         # 网络接口
+│       └── ec/         # 电子合同功能
+│           ├── apply/             # 电子合同申请
+│           │   ├── api.go         # API实现
+│           │   ├── request.go     # 请求结构体
+│           │   └── response.go    # 响应结构体
+│           ├── applymanual/       # 电子合同人工复核申请
+│           │   ├── api.go         # API实现
+│           │   ├── request.go     # 请求结构体
+│           │   └── response.go    # 响应结构体
+│           ├── download/          # 电子合同下载
+│           │   ├── api.go         # API实现
+│           │   ├── request.go     # 请求结构体
+│           │   └── response.go    # 响应结构体
+│           ├── qmastatus/         # 电子合同人工复核结果查询
+│           │   ├── api.go         # API实现
+│           │   ├── request.go     # 请求结构体
+│           │   └── response.go    # 响应结构体
+│           └── querystatus/       # 电子合同签署状态查询
+│               ├── api.go         # API实现
+│               ├── request.go     # 请求结构体
+│               └── response.go    # 响应结构体
+├── mergePre.go         # 主扫合单交易功能
+├── sdk.go              # SDK主入口
 ├── split_ledger.go     # 分账基本功能
 ├── split_ledger_more.go # 分账扩展功能
 ├── trade.go            # 交易相关功能
-├── account.go          # 账户相关功能
+├── unifiedreturn/      # 统一退款功能
-├── merge_pre.go        # 主扫合单交易功能
+│   ├── mergerefund/    # 合并退款
-├── sdk.go              # SDK主入口
+│   ├── refund/         # 退款
-├── merchant.go         # 商户相关功能
+│   ├── refundfee/      # 退款手续费
+│   └── refundquery/    # 退款查询
 └── uploadFile.go       # 文件上传相关功能
 ```
 

consts/ec.go

@@ -0,0 +1,42 @@
+package consts
+
+type ECType string
+
+const (
+	ECType001 ECType = "EC001" // EC001 : 特约商户支付服务合作协议V3.1(商户入网)
+	ECType002 ECType = "EC002" // EC002 : 特约商户支付服务合作协议V3.2（商户入网+分账）
+	ECType003 ECType = "EC003" // EC003 : 分账结算授权委托书
+	ECType004 ECType = "EC004" // EC004 : 特约商户支付服务合作协议V3.3（商户入网）
+	ECType005 ECType = "EC005" // EC005 : 特约商户支付服务合作协议V3.3（商户入网+分账）
+	ECType007 ECType = "EC007" // EC007 : 特约商户支付服务合作协议V4.1 + 结算授权委托书 (商户入网 + 分账 )
+	ECType008 ECType = "EC008" // EC008 : 特约商户支付服务合作协议V4.1 (商户入网)
+	ECType009 ECType = "EC009" // EC009 : 结算授权委托书
+)
+
+func (e ECType) Ptr() string {
+	return string(e)
+}
+
+type CertType string
+
+const (
+	CertType_RESIDENT_ID   CertType = "RESIDENT_ID"   // RESIDENT_ID（身份证)
+	CertType_PASSPORT      CertType = "PASSPORT"      // PASSPORT（护照）
+	CertType_HK_MACAO_PASS CertType = "HK_MACAO_PASS" // HK_MACAO_PASS（港澳居民往来内地通行证）
+	CertType_TAIWAN_PASS   CertType = "TAIWAN_PASS"   // TAIWAN_PASS（台湾居民来往大陆通行证）
+)
+
+func (c CertType) Ptr() string {
+	return string(c)
+}
+
+type AgentTag int
+
+const (
+	AgentTag0 AgentTag = iota // 0：不启用  缺省
+	AgentTag1  // 1: 启用
+)
+
+func (a AgentTag) Ptr() int {
+	return int(a)
+}

consts/url.go

@@ -2,6 +2,7 @@ package consts
 
 const (
 	BASE_URL      = "https://s2.lakala.com/api"
+	BASE_TEST_URL = "https://test.wsmsd.cn/sit/api"
 )
 
 const (
@@ -45,6 +46,16 @@ const (
 	LKL_MER_VALIDATE = "/v2/mms/openApi/verifyContractInfo"
 	// LKL_RECONF_SUBMIT 拉卡拉商户进件复议提交
 	LKL_RECONF_SUBMIT = "/v2/mms/openApi/reconsiderSubmit"
+	// LKL_EC_APPLY 拉卡拉商户电子合同
+	LKL_EC_APPLY = "/v3/mms/open_api/ec/apply"
+	// LKL_EC_QUERY_STATUS 拉卡拉商户电子合同查询状态
+	LKL_EC_QUERY_STATUS = "/v3/mms/open_api/ec/q_status"
+	// LKL_EC_DOWNLOAD 拉卡拉商户电子合同下载
+	LKL_EC_DOWNLOAD = "/v3/mms/open_api/ec/download"
+	// LKL_EC_APPLY_MANUAL 拉卡拉商户电子合同人工复核申请
+	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"
 )
 
 // unifiedReturn  统一退货API地址

lklsdk/account.go

@@ -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
+}

lklsdk/common/client.go

@@ -8,7 +8,6 @@ import (
 	"crypto/sha256"
 	"crypto/x509"
 	"encoding/base64"
-	"encoding/json"
 	"encoding/pem"
 	"fmt"
 	ran "math/rand"
@@ -101,14 +100,9 @@ func (c *Client[T]) DoRequest(url string, reqData interface{}) (*T, error) {
 	if err != nil {
 		return nil, fmt.Errorf("清理JSON空值失败: %v", err)
 	}
-	g.Log().Infof(c.ctx, "清理后的json: %s", reqJson)
+	g.Log().Infof(c.ctx, "清理后的json: %v", string(reqJson))
-	// 序列化为JSON
-	jsonData, err := json.Marshal(reqJson)
-	if err != nil {
-		return nil, fmt.Errorf("序列化请求数据失败: %v", err)
-	}
 
-	auth, err := c.generateSign(jsonData)
+	auth, err := c.generateSign(reqJson)
 	if err != nil {
 		return nil, fmt.Errorf("生成签名失败: %v", err)
 	}
@@ -119,5 +113,5 @@ func (c *Client[T]) DoRequest(url string, reqData interface{}) (*T, error) {
 	}
 	// 设置其他必要的请求头
 
-	return utils.NewClient[T](jsonData, url, header).Post(c.ctx)
+	return utils.NewClient[T](reqJson, url, header).Post(c.ctx)
 }

lklsdk/common/json_cleaner.go

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

lklsdk/merchant.go

@@ -47,6 +47,30 @@ func (t *MerService[T]) AddMer(req *model.MerchantApplyReqData) (*T, error) {
 	return respBody, nil
 }
 
+// AddMerTest 商户进件(测试)
+func (t *MerService[T]) AddMerTest(req *model.MerchantApplyReqData) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_TEST_URL + consts.LKL_ADD_MER
+	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
+	if err != nil {
+		return nil, fmt.Errorf("创建ReqId失败")
+	}
+	// 构建BaseModel请求
+	baseReq := model.MerchantApplyRequest{
+		ReqData:   req,
+		ReqId:     md5,
+		Timestamp: time.Now().Unix(),
+		Ver:       "1.0.0",
+	}
+
+	// 发送请求
+	respBody, err := t.client.DoRequest(url, baseReq)
+	if err != nil {
+		return nil, err
+	}
+	return respBody, nil
+}
+
 func (t *MerService[T]) QueryMer(req *model.QueryMerRequestData) (*T, error) {
 	// 构建请求参数
 	url := consts.BASE_URL + consts.LKL_QUERY_MER
@@ -69,6 +93,28 @@ func (t *MerService[T]) QueryMer(req *model.QueryMerRequestData) (*T, error) {
 	}
 	return respBody, nil
 }
+func (t *MerService[T]) QueryMerTest(req *model.QueryMerRequestData) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_TEST_URL + consts.LKL_QUERY_MER
+	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
+	if err != nil {
+		return nil, fmt.Errorf("创建ReqId失败")
+	}
+	// 构建BaseModel请求
+	baseReq := model.QueryMerRequest{
+		ReqData:   req,
+		ReqId:     md5,
+		Timestamp: time.Now().Unix(),
+		Ver:       "1.0.0",
+	}
+
+	// 发送请求
+	respBody, err := t.client.DoRequest(url, baseReq)
+	if err != nil {
+		return nil, err
+	}
+	return respBody, nil
+}
 func (t *MerService[T]) MerValidate(req *model.MerValidateRequestData) (*T, error) {
 	// 构建请求参数
 	url := consts.BASE_URL + consts.LKL_MER_VALIDATE
@@ -91,6 +137,28 @@ func (t *MerService[T]) MerValidate(req *model.MerValidateRequestData) (*T, erro
 	}
 	return respBody, nil
 }
+func (t *MerService[T]) MerValidateTest(req *model.MerValidateRequestData) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_TEST_URL + consts.LKL_MER_VALIDATE
+	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
+	if err != nil {
+		return nil, fmt.Errorf("创建ReqId失败")
+	}
+	// 构建BaseModel请求
+	baseReq := model.MerValidateRequest{
+		ReqData:   req,
+		ReqId:     md5,
+		Timestamp: time.Now().Unix(),
+		Ver:       "1.0.0",
+	}
+
+	// 发送请求
+	respBody, err := t.client.DoRequest(url, baseReq)
+	if err != nil {
+		return nil, err
+	}
+	return respBody, nil
+}
 
 func (t *MerService[T]) ReconsiderSubmit(req *model.ReConfSubmitRequestData) (*T, error) {
 	// 构建请求参数
@@ -114,3 +182,26 @@ func (t *MerService[T]) ReconsiderSubmit(req *model.ReConfSubmitRequestData) (*T
 	}
 	return respBody, nil
 }
+
+func (t *MerService[T]) ReconsiderSubmitTest(req *model.ReConfSubmitRequestData) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_TEST_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
+}

lklsdk/merchant/in_net/ec/apply/api.go

@@ -0,0 +1,49 @@
+package apply
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type Apply struct {
+	Client *common.Client[ECApplyResponse]
+}
+
+func NewEcApply(client *common.Client[ECApplyResponse]) *Apply {
+	return &Apply{
+		Client: client,
+	}
+}
+
+// ECApply 电子合同申请
+// 提供与拉卡拉进行电子签约的第四方进行电子合同申请
+// 电子合同签约成功后不需要将其下载出来作为附件上传，只需将电子合同编号（ecNo）
+// 在“新增商户入网”接口中在（contractNo）字段中传入即可
+// https://o.lakala.com/#/home/document/detail?id=289
+func (a *Apply) ECApply(req *ECApplyRequestData) (*ECApplyResponse, error) {
+	// 构建请求
+	baseReq := ECApplyRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_EC_APPLY, baseReq)
+}
+
+// ECApplyTest 电子合同申请（测试环境）
+// 提供与拉卡拉进行电子签约的第四方进行电子合同申请
+// 电子合同签约成功后不需要将其下载出来作为附件上传，只需将电子合同编号（ecNo）
+// 在“新增商户入网”接口中在（contractNo）字段中传入即可
+// https://o.lakala.com/#/home/document/detail?id=289
+func (a *Apply) ECApplyTest(req *ECApplyRequestData) (*ECApplyResponse, error) {
+	// 构建请求
+	baseReq := ECApplyRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+
+	return a.Client.DoRequest(consts.BASE_TEST_URL+consts.LKL_EC_APPLY, baseReq)
+}

lklsdk/merchant/in_net/ec/apply/request.go

@@ -0,0 +1,54 @@
+package apply
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+)
+
+// ECApplyRequestData 电子合同申请请求数据
+// 提供与拉卡拉进行电子签约的第四方进行电子合同申请
+// 电子合同签约成功后不需要将其下载出来作为附件上传，只需将电子合同编号（ecNo）
+// 在“新增商户入网”接口中在（contractNo）字段中传入即可
+// 合同类别适用业务场景说明：
+// EC001: 特约商户支付服务合作协议V3.1(商户入网) - 历史存量，推荐使用EC008
+// EC002: 特约商户支付服务合作协议V3.2+分账结算授权委托书 - 历史存量，推荐使用EC007
+// EC003: 分账结算授权委托书 - 历史存量，推荐使用EC009
+// EC004: 特约商户支付服务合作协议V3.3(商户入网) - 历史存量，推荐使用EC008
+// EC005: 特约商户支付服务合作协议V3.3+分账结算授权委托书 - 历史存量，推荐使用EC007
+// EC007: 特约商户支付服务合作协议V4.1+分账结算授权委托书(商户入网+分账业务) - 当前最新版本
+// EC008: 特约商户支付服务合作协议V4.1(商户入网) - 当前最新版本
+// EC009: 清分结算授权委托书(分账业务) - 当前最新版本
+type ECApplyRequestData struct {
+	OrderNo             string              `json:"order_no" dc:"四方机构自定义订单编号 必选，建议：平台编号+14位年月日时分秒+8位的随机数"`                                                          // 必选，建议：平台编号+14位年月日时分秒+8位的随机数
+	OrgID               int                 `json:"org_id" dc:"机构号 必选，签约方所属拉卡拉机构"`                                                                                  // 必选，签约方所属拉卡拉机构
+	EcTypeCode          consts.ECType       `json:"ec_type_code" dc:"合同类别 必选，合同类别编码"`                                                                               // 必选，合同类别编码
+	CertType            consts.CertType     `json:"cert_type" dc:"法人/经营者证件类型 必选，RESIDENT_ID（身份证）；PASSPORT（护照）；HK_MACAO_PASS（港澳居民往来内地通行证）；TAIWAN_PASS（台湾居民来往大陆通行证）"` // 必选，RESIDENT_ID（身份证）；PASSPORT（护照）；HK_MACAO_PASS（港澳居民往来内地通行证）；TAIWAN_PASS（台湾居民来往大陆通行证）
+	CertName            string              `json:"cert_name" dc:"法人/经营者姓名 必选"`                                                                                     // 必选
+	CertNo              string              `json:"cert_no" dc:"法人/经营者证件号码 必选"`                                                                                     // 必选
+	Mobile              string              `json:"mobile" dc:"签约手机号 必选，小微个人商户必须填写经营者本人手机号；个体工商户或企业商户必须填写法人手机号或者经办人手机号"`                                            // 必选，小微个人商户必须填写经营者本人手机号；个体工商户或企业商户必须填写法人手机号或者经办人手机号
+	BusinessLicenseNo   string              `json:"business_license_no" dc:"营业执照号 可选，个体工商户或企业商户必传"`                                                                 // 可选，个体工商户或企业商户必传
+	BusinessLicenseName string              `json:"business_license_name" dc:"营业执照名称 可选，个体工商户或企业商户必传"`                                                              // 可选，个体工商户或企业商户必传
+	OpenningBankCode    string              `json:"openning_bank_code" dc:"企业/经营者结算开户行号 必选"`                                                                        // 必选
+	OpenningBankName    string              `json:"openning_bank_name" dc:"企业/经营者结算开户行名称 必选"`                                                                       // 必选
+	AcctTypeCode        consts.AcctTypeCode `json:"acct_type_code" dc:"企业/经营者结算卡性质 必选，57 对公、 58 对私"`                                                                // 必选，57 对公、 58 对私
+	AcctNo              string              `json:"acct_no" dc:"企业/经营者结算卡号 必选"`                                                                                     // 必选
+	AcctName            string              `json:"acct_name" dc:"企业/经营者结算卡名称 必选"`                                                                                  // 必选
+	EcContentParameters string              `json:"ec_content_parameters" dc:"电子合同内容参数集合 必选，JSON字符串"`                                                               // 必选，JSON字符串
+	AgentTag            consts.AgentTag     `json:"agent_tag" dc:"是否经办签约 可选，0 不启用 1启用，缺省 0"`                                                                        // 可选，0 不启用 1启用，缺省 0
+	AgentName           string              `json:"agent_name" dc:"经办人名称 可选，agentTag为1时必传"`                                                                         // 可选，agentTag为1时必传
+	AgentCertType       consts.CertType     `json:"agent_cert_type" dc:"经办人证件类型 可选，agentTag为1时必传"`                                                                  // 可选，agentTag为1时必传
+	AgentCertNo         string              `json:"agent_cert_no" dc:"经办人证件号 可选，agentTag为1时必传"`                                                                     // 可选，agentTag为1时必传
+	AgentFileName       string              `json:"agent_file_name" dc:"经办签约授权委托书文件名 可选，agentTag为1时必传"`                                                             // 可选，agentTag为1时必传
+	AgentFilePath       string              `json:"agent_file_path" dc:"经办授权委托书文件路径 可选，agentTag为1时必传"`                                                              // 可选，agentTag为1时必传
+	Remark              string              `json:"remark" dc:"备注说明 可选"`                                                                                            // 可选
+	RetUrl              string              `json:"ret_url" dc:"电子合同签约结果回调通知 可选，成功签约才通知"`                                                                           // 可选，成功签约才通知
+}
+
+// ECApplyRequest 电子合同申请请求
+// 请求URL：
+// 测试环境：https://test.wsmsd.cn/sit/api/v3/mms/open_api/ec/apply
+// 生产环境：https://s2.lakala.com/api/v3/mms/open_api/ec/apply
+type ECApplyRequest struct {
+	ReqTime string              `json:"req_time" dc:"请求时间"` // 必选，格式：yyyyMMddHHmmss
+	ReqData *ECApplyRequestData `json:"req_data" dc:"请求数据"` // 请求数据
+	Version string              `json:"version" dc:"版本号"`   // 必选，固定值：1.0
+}

lklsdk/merchant/in_net/ec/apply/response.go

@@ -0,0 +1,20 @@
+package apply
+
+// ECApplyResponseData 电子合同申请响应数据
+type ECApplyResponseData struct {
+	OrderNo   string `json:"order_no" dc:"请求上送的订单号"`         // 请求上送的订单号
+	EcApplyID int64  `json:"ec_apply_id" dc:"电子签约申请受理编号"`    // 电子签约申请受理编号
+	ResultUrl string `json:"result_url" dc:"电子签约申请结果H5链接地址"` // 申请成功时：待签约合同H5链接；申请失败时：错误信息结果H5链接
+}
+
+// ECApplyResponse 电子合同申请响应
+type ECApplyResponse struct {
+	Code     string               `json:"code" dc:"返回码"`         // 成功 000000 其它失败
+	Msg      string               `json:"msg" dc:"返回码描述"`        // 返回码描述
+	RespData *ECApplyResponseData `json:"resp_data" dc:"结果信息集合"` // 结果信息集合
+	RespTime string               `json:"resp_time" dc:"响应时间"`   // 格式：yyyyMMddHHmmss
+}
+
+func (r *ECApplyResponse) SuccessOfFail() bool {
+	return r.Code == "000000"
+}

lklsdk/merchant/in_net/ec/applymanual/api.go

@@ -0,0 +1,43 @@
+package applymanual
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// ApplyManual 电子合同人工复核申请服务
+type ApplyManual struct {
+	Client *common.Client[ECApplyManualResponse]
+}
+
+// NewApplyManual 创建新的电子合同人工复核申请服务
+func NewApplyManual(client *common.Client[ECApplyManualResponse]) *ApplyManual {
+	return &ApplyManual{
+		Client: client,
+	}
+}
+
+// ECApplyManual 电子合同人工复核申请（生产环境）
+// https://o.lakala.com/#/home/document/detail?id=981
+func (a *ApplyManual) ECApplyManual(req *ECApplyManualRequestData) (*ECApplyManualResponse, error) {
+	// 创建请求对象
+	request := ECApplyManualRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_EC_APPLY_MANUAL, request)
+}
+
+// ECApplyManualTest 电子合同人工复核申请（测试环境）
+// https://o.lakala.com/#/home/document/detail?id=981
+func (a *ApplyManual) ECApplyManualTest(req *ECApplyManualRequestData) (*ECApplyManualResponse, error) {
+	// 创建请求对象
+	request := ECApplyManualRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+	return a.Client.DoRequest(consts.BASE_TEST_URL+consts.LKL_EC_APPLY_MANUAL, request)
+}

lklsdk/merchant/in_net/ec/applymanual/request.go

@@ -0,0 +1,31 @@
+package applymanual
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+)
+
+// ECApplyManualRequestData 电子合同人工复核申请请求数据结构体
+type ECApplyManualRequestData struct {
+	Version   string        `json:"version"`           // 版本号，默认1.0
+	OrderNo   string        `json:"order_no"`          // 四方机构自定义订单编号，必填，建议平台编号+14位年月日时分秒+8位随机数
+	OrgID     int           `json:"org_id"`            // 机构号，必填，签约方所属拉卡拉机构
+	EcApplyID string        `json:"ec_apply_id"`       // 电子合同申请受理号，必填，申请接口反馈编号
+	ApplyDesc string        `json:"apply_desc"`        // 申请说明，必填，复议提交的原因说明
+	FileData  []*ECFileData `json:"file_data"`         // 附件信息集合，必填，提供给审核人员核对信息
+	RetURL    string        `json:"ret_url,omitempty"` // 回调地址，可选
+}
+
+// ECFileData 附件信息结构体
+type ECFileData struct {
+	AttachType      consts.AttType `json:"attach_type"`       // 附件类型，必填，枚举值见文档
+	AttachName      string `json:"attach_name"`       // 附件名称，必填，最大32字符
+	AttachExtName   string `json:"attach_ext_name"`   // 附件格式，必填，jpg、pdf等
+	AttachStorePath string `json:"attach_store_path"` // 附件坐标URL，必填，如G1/M00/00/61/CrFdEl3IyceAVVd8AAA0ADuZsA0911.jpg
+}
+
+// ECApplyManualRequest 电子合同人工复核申请请求结构体
+type ECApplyManualRequest struct {
+	ReqTime string                    `json:"req_time"` // 请求时间
+	ReqData *ECApplyManualRequestData `json:"req_data"` // 请求数据
+	Version string                    `json:"version"`  // 接口版本号
+}

lklsdk/merchant/in_net/ec/applymanual/response.go

@@ -0,0 +1,19 @@
+package applymanual
+
+// ECApplyManualResponseData 电子合同人工复核申请响应数据结构体
+type ECApplyManualResponseData struct {
+	// 响应数据为空对象，根据API文档，成功时返回空的resp_data
+}
+
+// ECApplyManualResponse 电子合同人工复核申请响应结构体
+type ECApplyManualResponse struct {
+	Code     string                  `json:"code"`     // 返回码，成功为000000，其他为失败
+	Msg      string                  `json:"msg"`      // 返回码描述
+	RespData ECApplyManualResponseData `json:"resp_data"` // 响应数据
+}
+
+// SuccessOfFail 检查响应是否成功
+// 返回true表示成功，false表示失败
+func (r *ECApplyManualResponse) SuccessOfFail() bool {
+	return r.Code == "000000"
+}

lklsdk/merchant/in_net/ec/download/api.go

@@ -0,0 +1,48 @@
+package download
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type Download struct {
+	Client *common.Client[ECDownloadResponse]
+}
+
+// NewDownload 创建电子合同下载服务实例
+func NewDownload(client *common.Client[ECDownloadResponse]) *Download {
+	return &Download{
+		Client: client,
+	}
+}
+
+// ECDownload 电子合同下载
+// 提供已完成的签约电子合同下载
+// https://o.lakala.com/#/home/document/detail?id=294
+func (d *Download) ECDownload(req *ECDownloadRequestData) (*ECDownloadResponse, error) {
+	// 构建请求
+	baseReq := ECDownloadRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+
+	// 使用生产环境URL
+	return d.Client.DoRequest(consts.BASE_URL+consts.LKL_EC_DOWNLOAD, baseReq)
+}
+
+// ECDownloadTest 电子合同下载（测试环境）
+// 提供已完成的签约电子合同下载
+// https://o.lakala.com/#/home/document/detail?id=294
+func (d *Download) ECDownloadTest(req *ECDownloadRequestData) (*ECDownloadResponse, error) {
+	// 构建请求
+	baseReq := ECDownloadRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+
+	// 使用测试环境URL
+	return d.Client.DoRequest(consts.BASE_TEST_URL+consts.LKL_EC_DOWNLOAD, baseReq)
+}

lklsdk/merchant/in_net/ec/download/request.go

@@ -0,0 +1,15 @@
+package download
+
+// ECDownloadRequestData 电子合同下载请求数据
+type ECDownloadRequestData struct {
+	OrderNo   string `json:"order_no" dc:"四方机构自定义订单编号"`   // 四方机构自定义订单编号
+	OrgCode   int    `json:"org_code" dc:"机构号"`   // 机构号
+	EcApplyID int64  `json:"ec_apply_id" dc:"电子合同申请受理号"` // 电子合同申请受理号
+}
+
+// ECDownloadRequest 电子合同下载请求结构
+type ECDownloadRequest struct {
+	ReqTime string               `json:"req_time"` // 请求时间
+	ReqData *ECDownloadRequestData `json:"req_data"` // 请求数据
+	Version string               `json:"version"`  // 接口版本号
+}

lklsdk/merchant/in_net/ec/download/response.go

@@ -0,0 +1,22 @@
+package download
+
+// ECDownloadResponseData 电子合同下载响应数据
+type ECDownloadResponseData struct {
+	OrderNo   string `json:"order_no"`   // 请求上送的订单号
+	EcApplyID int64  `json:"ec_apply_id"` // 电子签约申请受理编号
+	EcStatus  string `json:"ec_status"`  // 电子合同状态: UNDONE 未完成, COMPLETED 已完成
+	EcNo      string `json:"ec_no"`      // 电子合同号（合同状态为COMPLETED时返回）
+	EcFile    string `json:"ec_file"`    // 电子合同pdf文件(base64格式字符，合同状态为COMPLETED时返回)
+}
+
+// ECDownloadResponse 电子合同下载响应结构
+type ECDownloadResponse struct {
+	Code     string               `json:"code"`      // 返回码
+	Msg      string               `json:"msg"`       // 返回码描述
+	RespData *ECDownloadResponseData `json:"resp_data"` // 结果信息集合
+}
+
+// SuccessOfFail 检查响应是否成功
+func (r *ECDownloadResponse) SuccessOfFail() bool {
+	return r.Code == "000000"
+}

lklsdk/merchant/in_net/ec/qmastatus/api.go

@@ -0,0 +1,41 @@
+package qmastatus
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// QmaStatus 电子合同人工复核结果查询服务
+type QmaStatus struct {
+	Client *common.Client[ECQmaStatusResponse]
+}
+
+// NewQmaStatus 创建新的电子合同人工复核结果查询服务
+func NewQmaStatus(client *common.Client[ECQmaStatusResponse]) *QmaStatus {
+	return &QmaStatus{Client: client}
+}
+
+// ECQmaStatus
+// https://o.lakala.com/#/home/document/detail?id=982
+func (q *QmaStatus) ECQmaStatus(req *ECQmaStatusRequestData) (*ECQmaStatusResponse, error) {
+	// 创建请求对象
+	request := ECQmaStatusRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+	return q.Client.DoRequest(consts.BASE_URL+consts.LKL_EC_QMA_STATUS, request)
+}
+
+// ECQmaStatusTest 电子合同人工复核结果查询（测试环境）
+// https://o.lakala.com/#/home/document/detail?id=982
+func (q *QmaStatus) ECQmaStatusTest(req *ECQmaStatusRequestData) (*ECQmaStatusResponse, error) {
+	// 创建请求对象
+	request := ECQmaStatusRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+	return q.Client.DoRequest(consts.BASE_TEST_URL+consts.LKL_EC_QMA_STATUS, request)
+}

lklsdk/merchant/in_net/ec/qmastatus/request.go

@@ -0,0 +1,16 @@
+package qmastatus
+
+// ECQmaStatusRequestData 电子合同人工复核结果查询请求数据结构体
+type ECQmaStatusRequestData struct {
+	Version   string `json:"version"`   // 版本号，默认1.0
+	OrderNo   string `json:"order_no"`  // 四方机构自定义订单编号，必填，建议平台编号+14位年月日时分秒+8位随机数
+	OrgID     int    `json:"org_id"`    // 机构号，必填，签约方所属拉卡拉机构
+	EcApplyID string `json:"ec_apply_id"` // 电子合同申请受理号，必填，申请接口反馈编号
+}
+
+// ECQmaStatusRequest 电子合同人工复核结果查询请求结构体
+type ECQmaStatusRequest struct {
+	ReqTime string                  `json:"req_time"` // 请求时间
+	ReqData *ECQmaStatusRequestData `json:"req_data"` // 请求数据
+	Version string                  `json:"version"`  // 接口版本号
+}

lklsdk/merchant/in_net/ec/qmastatus/response.go

@@ -0,0 +1,25 @@
+package qmastatus
+
+// ECQmaStatusResponseData 电子合同人工复核结果查询响应数据结构体
+type ECQmaStatusResponseData struct {
+	Version        string `json:"version"`         // 版本号
+	OrderNo        string `json:"order_no"`        // 四方机构自定义订单编号
+	OrgID          int    `json:"org_id"`          // 机构号
+	EcApplyID      string `json:"ec_apply_id"`     // 电子合同申请受理号
+	AuditStatus    string `json:"audit_status"`    // 人工审核状态：WAIT_AUDIT待审核、PASS审核通过、REFUSE审核拒绝、CLOSE审核关闭
+	AuditDesc      string `json:"audit_desc"`      // 人工审核结果说明
+	SignH5URL      string `json:"sign_h5_url"`     // 签约H5地址，审核通过时返回
+	SignH5URLExpTm string `json:"sign_h5_url_exp_tm"` // 签约H5地址过期时间，审核通过时返回
+}
+
+// ECQmaStatusResponse 电子合同人工复核结果查询响应结构体
+type ECQmaStatusResponse struct {
+	Code     string                  `json:"code"`      // 返回码，成功000000，其它失败
+	Msg      string                  `json:"msg"`       // 返回码描述
+	RespData *ECQmaStatusResponseData `json:"resp_data"` // 响应数据
+}
+
+// SuccessOfFail 判断响应是否成功
+func (r *ECQmaStatusResponse) SuccessOfFail() bool {
+	return r != nil && r.Code == "000000"
+}

lklsdk/merchant/in_net/ec/querystatus/api.go

@@ -0,0 +1,48 @@
+package querystatus
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type QStatus struct {
+	Client *common.Client[ECQueryStatusResponse]
+}
+
+// NewQStatus 创建电子合同查询状态服务实例
+func NewQStatus(client *common.Client[ECQueryStatusResponse]) *QStatus {
+	return &QStatus{
+		Client: client,
+	}
+}
+
+// QueryStatus 电子合同查询状态
+// 提供申请过与拉卡拉电子签约用户查询电子合同签署状态
+// https://o.lakala.com/#/home/document/detail?id=293
+func (q *QStatus) QueryStatus(req *ECQueryStatusRequestData) (*ECQueryStatusResponse, error) {
+	// 构建请求
+	baseReq := ECQueryStatusRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+
+	// 使用生产环境URL
+	return q.Client.DoRequest(consts.BASE_URL+consts.LKL_EC_QUERY_STATUS, baseReq)
+}
+
+// QueryStatusTest 电子合同查询状态（测试环境）
+// 提供申请过与拉卡拉电子签约用户查询电子合同签署状态
+// https://o.lakala.com/#/home/document/detail?id=293
+func (q *QStatus) QueryStatusTest(req *ECQueryStatusRequestData) (*ECQueryStatusResponse, error) {
+	// 构建请求
+	baseReq := ECQueryStatusRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		ReqData: req,
+		Version: "1.0",
+	}
+
+	// 使用测试环境URL
+	return q.Client.DoRequest(consts.BASE_TEST_URL+consts.LKL_EC_QUERY_STATUS, baseReq)
+}

lklsdk/merchant/in_net/ec/querystatus/request.go

@@ -0,0 +1,19 @@
+package querystatus
+
+// ECQueryStatusRequestData 电子合同查询状态请求数据
+// 提供申请过与拉卡拉电子签约用户查询电子合同签署状态
+// 请求URL：
+// 测试环境：https://test.wsmsd.cn/sit/api/v3/mms/open_api/ec/q_status
+// 生产环境：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位的随机数（同一接入机构不重复）
+	OrgCode   int    `json:"org_code" dc:"机构号 必选，签约方所属拉卡拉机构"`                                         // 必选，签约方所属拉卡拉机构
+	EcApplyID int64  `json:"ec_apply_id" dc:"电子合同申请受理号 必选，申请接口反馈编号"`                                  // 必选，申请接口反馈编号
+}
+
+// ECQueryStatusRequest 电子合同查询状态请求
+type ECQueryStatusRequest struct {
+	ReqTime string                    `json:"req_time" dc:"请求时间"` // 必选，格式：yyyyMMddHHmmss
+	ReqData *ECQueryStatusRequestData `json:"req_data" dc:"请求数据"` // 请求数据
+	Version string                    `json:"version" dc:"版本号"`   // 必选，固定值：1.0
+}

lklsdk/merchant/in_net/ec/querystatus/response.go

@@ -0,0 +1,22 @@
+package querystatus
+
+// ECQueryStatusResponseData 电子合同查询状态响应数据
+type ECQueryStatusResponseData struct {
+	OrderNo   string `json:"order_no" dc:"请求上送的订单号"`               // 请求上送的订单号
+	EcApplyID int64  `json:"ec_apply_id" dc:"电子签约申请受理编号"`          // 电子签约申请受理编号
+	EcStatus  string `json:"ec_status" dc:"电子合同签署状态"`               // 电子合同签署状态，UNDONE 未完成，COMPLETED 已完成
+	EcNo      string `json:"ec_no" dc:"电子合同号"`                       // 签署完成反馈
+}
+
+// ECQueryStatusResponse 电子合同查询状态响应
+type ECQueryStatusResponse struct {
+	Code     string                     `json:"code" dc:"返回码"`         // 成功 000000 其它失败
+	Msg      string                     `json:"msg" dc:"返回码描述"`        // 返回码描述
+	RespData *ECQueryStatusResponseData `json:"resp_data" dc:"结果信息集合"` // 结果信息集合
+	RespTime string                     `json:"resp_time" dc:"响应时间"`   // 格式：yyyyMMddHHmmss
+}
+
+// SuccessOfFail 检查响应是否成功
+func (r *ECQueryStatusResponse) SuccessOfFail() bool {
+	return r.Code == "000000"
+}

lklsdk/sdk.go

@@ -4,6 +4,11 @@ import (
 	"context"
 
 	"github.com/black1552/lkl_sdk/lklsdk/common"
+	ecApply "github.com/black1552/lkl_sdk/lklsdk/merchant/in_net/ec/apply"
+	ecApplyManual "github.com/black1552/lkl_sdk/lklsdk/merchant/in_net/ec/applymanual"
+	ecDownload "github.com/black1552/lkl_sdk/lklsdk/merchant/in_net/ec/download"
+	ecQmaStatus "github.com/black1552/lkl_sdk/lklsdk/merchant/in_net/ec/qmastatus"
+	ecQuery "github.com/black1552/lkl_sdk/lklsdk/merchant/in_net/ec/querystatus"
 	"github.com/black1552/lkl_sdk/model"
 )
 
@@ -16,6 +21,11 @@ type SDK[T any] struct {
 	UploadFile      *UploadFileService[T]
 	MergePre        *MergePreService[T]
 	Merchant        *MerService[T]
+	EC              *ecApply.Apply
+	ECQuery         *ecQuery.QStatus
+	ECFileDownload  *ecDownload.Download
+	ECPeApplyManual *ecApplyManual.ApplyManual
+	ECPeQmaStatus   *ecQmaStatus.QmaStatus
 }
 
 // NewSDK 创建拉卡拉SDK实例
@@ -29,6 +39,11 @@ func NewSDK[T any](ctx context.Context, cfgJson string) *SDK[T] {
 		UploadFile:      NewUploadFileService(client),
 		MergePre:        NewMergePreService(client),
 		Merchant:        NewMerService(client),
+		EC:              ecApply.NewEcApply(common.NewClient[ecApply.ECApplyResponse](ctx, cfgJson)),
+		ECQuery:         ecQuery.NewQStatus(common.NewClient[ecQuery.ECQueryStatusResponse](ctx, cfgJson)),
+		ECFileDownload:  ecDownload.NewDownload(common.NewClient[ecDownload.ECDownloadResponse](ctx, cfgJson)),
+		ECPeApplyManual: ecApplyManual.NewApplyManual(common.NewClient[ecApplyManual.ECApplyManualResponse](ctx, cfgJson)),
+		ECPeQmaStatus:   ecQmaStatus.NewQmaStatus(common.NewClient[ecQmaStatus.ECQmaStatusResponse](ctx, cfgJson)),
 	}
 }
 
@@ -39,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)
@@ -69,31 +104,55 @@ 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)
+}
+
 // TradeQuery 交易查询
 func (s *SDK[T]) TradeQuery(req *model.TradeQueryReqData) (*T, error) {
 	return s.Trade.TradeQuery(req)
@@ -109,11 +168,72 @@ 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)
+}
+
+// ECApplyTest 电子合同申请（测试环境）
+func (s *SDK[T]) ECApplyTest(req *ecApply.ECApplyRequestData) (*ecApply.ECApplyResponse, error) {
+	return s.EC.ECApplyTest(req)
+}
+
+// ECQueryStatus 电子合同查询状态
+func (s *SDK[T]) ECQueryStatus(req *ecQuery.ECQueryStatusRequestData) (*ecQuery.ECQueryStatusResponse, error) {
+	return s.ECQuery.QueryStatus(req)
+}
+
+// ECQueryStatusTest 电子合同查询状态（测试环境）
+func (s *SDK[T]) ECQueryStatusTest(req *ecQuery.ECQueryStatusRequestData) (*ecQuery.ECQueryStatusResponse, error) {
+	return s.ECQuery.QueryStatusTest(req)
+}
+
+// ECDownload 电子合同下载
+func (s *SDK[T]) ECDownload(req *ecDownload.ECDownloadRequestData) (*ecDownload.ECDownloadResponse, error) {
+	return s.ECFileDownload.ECDownload(req)
+}
+
+// ECDownloadTest 电子合同下载（测试环境）
+func (s *SDK[T]) ECDownloadTest(req *ecDownload.ECDownloadRequestData) (*ecDownload.ECDownloadResponse, error) {
+	return s.ECFileDownload.ECDownloadTest(req)
+}
+
+// ECApplyManual 电子合同人工复核申请
+func (s *SDK[T]) ECApplyManual(req *ecApplyManual.ECApplyManualRequestData) (*ecApplyManual.ECApplyManualResponse, error) {
+	return s.ECPeApplyManual.ECApplyManual(req)
+}
+
+// ECApplyManualTest 电子合同人工复核申请（测试环境）
+func (s *SDK[T]) ECApplyManualTest(req *ecApplyManual.ECApplyManualRequestData) (*ecApplyManual.ECApplyManualResponse, error) {
+	return s.ECPeApplyManual.ECApplyManualTest(req)
+}
+
+// ECQmaStatus 电子合同人工复核结果查询
+func (s *SDK[T]) ECQmaStatus(req *ecQmaStatus.ECQmaStatusRequestData) (*ecQmaStatus.ECQmaStatusResponse, error) {
+	return s.ECPeQmaStatus.ECQmaStatus(req)
+}
+
+// ECQmaStatusTest 电子合同人工复核结果查询（测试环境）
+func (s *SDK[T]) ECQmaStatusTest(req *ecQmaStatus.ECQmaStatusRequestData) (*ecQmaStatus.ECQmaStatusResponse, error) {
+	return s.ECPeQmaStatus.ECQmaStatusTest(req)
+}

lklsdk/split_ledger.go

@@ -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
+}

lklsdk/split_ledger_more.go

@@ -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,22 @@ 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
+}

lklsdk/uploadFile.go

@@ -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
+}

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-金额分账
-	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-平台分润规则(分润规则必传)

model/merchant.go

@@ -81,8 +81,8 @@ type FeeData struct {
 // FileData 附件集合结构体
 
 type FileData struct {
-	AttField string `json:"attField"` // 文件编号/附件上传后返回的编号，必填
+	AttFileId string `json:"attFileId"` // 文件编号/附件上传后返回的编号，必填
-	AttType  string `json:"attType"`  // 附件类型，必填
+	AttType   consts.AcctTypeCode `json:"attType"`   // 附件类型，必填
 }
 
 // MerchantApplyResponse 商户进件响应结构体

model/queryLedgerMer.go

@@ -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 分账商户查询响应结构体
@@ -37,49 +37,49 @@ type QueryLedgerMerResponse struct {
 	// 响应消息
 	Msg string `json:"msg"`
 	// 响应业务数据，当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 string `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 判断分账商户查询请求是否成功