feat(lklsdk): 添加测试环境接口支持

- 为账户服务增加余额查询和提现的测试接口 - 为分账服务增加商户申请、接收方申请、绑定关系等测试接口 -为上传文件服务增加测试环境查询接口 - 统一测试接口的URL使用BASE_TEST_URL常量 - 完善SDK层对所有新增测试接口的封装支持
refactor(common):优化JSON清理逻辑
2025-11-12 15:52:24 +08:00 · 2025-11-12 15:05:04 +08:00 · 2025-11-12 10:58:30 +08:00 · 2025-11-12 10:51:41 +08:00 · 2025-11-12 10:08:55 +08:00 · 2025-11-12 10:08:36 +08:00
26 changed files with 992 additions and 35 deletions
@@ -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          # 账户相关功能
-├── merge_pre.go        # 主扫合单交易功能
-├── sdk.go              # SDK主入口
-├── merchant.go         # 商户相关功能
+├── unifiedreturn/      # 统一退款功能
+│   ├── mergerefund/    # 合并退款
+│   ├── refund/         # 退款
+│   ├── refundfee/      # 退款手续费
+│   └── refundquery/    # 退款查询
 └── uploadFile.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)
+}
@@ -1,7 +1,8 @@
 package consts

 const (
-	BASE_URL = "https://s2.lakala.com/api"
+	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地址
@@ -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值
@@ -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
+}
@@ -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)
+}
@@ -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
+}
@@ -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"
+}
@@ -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)
+}
@@ -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"`  // 接口版本号
+}
@@ -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"
+}
@@ -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)
+}
@@ -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"`  // 接口版本号
+}
@@ -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"
+}
@@ -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)
+}
@@ -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"`  // 接口版本号
+}
@@ -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"
+}
@@ -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)
+}
@@ -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
+}
@@ -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"
+}
@@ -4,31 +4,46 @@ 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"
 )

 // SDK 拉卡拉SDK主入口
 type SDK[T any] struct {
-	Client      *common.Client[T]
-	SplitLedger *SplitLedgerService[T]
-	Trade       *TradeService[T]
-	Account     *AccountService[T]
-	UploadFile  *UploadFileService[T]
-	MergePre    *MergePreService[T]
-	Merchant    *MerService[T]
+	Client          *common.Client[T]
+	SplitLedger     *SplitLedgerService[T]
+	Trade           *TradeService[T]
+	Account         *AccountService[T]
+	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实例
 func NewSDK[T any](ctx context.Context, cfgJson string) *SDK[T] {
 	client := common.NewClient[T](ctx, cfgJson)
 	return &SDK[T]{
-		Client:      client,
-		SplitLedger: NewSplitLedgerService(client),
-		Trade:       NewTradeService(client),
-		Account:     NewAccountService(client),
-		UploadFile:  NewUploadFileService(client),
-		MergePre:    NewMergePreService(client),
-		Merchant:    NewMerService(client),
+		Client:          client,
+		SplitLedger:     NewSplitLedgerService(client),
+		Trade:           NewTradeService(client),
+		Account:         NewAccountService(client),
+		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)
+}
@@ -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,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
+}
@@ -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
+}
@@ -82,7 +82,7 @@ type FeeData struct {

 type FileData struct {
 	AttFileId string `json:"attFileId"` // 文件编号/附件上传后返回的编号，必填
-	AttType   string `json:"attType"`   // 附件类型，必填
+	AttType   consts.AcctTypeCode `json:"attType"`   // 附件类型，必填
 }

 // MerchantApplyResponse 商户进件响应结构体
Author	SHA1	Message	Date
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
maguodong	c11e75f910	feat(merchant): 添加商户进件及查询测试接口 - 新增 AddMerTest 方法用于商户进件测试 - 新增 QueryMerTest 方法用于商户查询测试 - 新增 MerValidateTest 方法用于商户验证测试 - 修改 ReconsiderSubmit 方法名为 ReconsiderSubmitTest 并调整 URL 为测试环境 - 所有测试方法均使用 BASE_TEST_URL 作为基础地址 - 统一测试方法中 ReqId生成逻辑和请求结构体构建方式	2025-11-08 08:56:09 +08:00
maguodong	8b7a82f6c8	重构项目目录结构以提升模块化 - 将核心客户端移至 common/client.go - 新增账户、商户相关功能文件 - 添加电子合同相关模块及API实现 - 重组分账与交易功能文件 - 引入统一退款功能模块 - 更新文件上传功能位置	2025-10-20 10:37:40 +08:00
maguodong	ee259e7c9a	feat(电子合同): 添加电子合同相关功能及文档链接 - 在model/merchant.go中将AttType字段类型改为consts.AcctTypeCode - 为所有电子合同相关接口添加文档链接注释 - 在consts/url.go中添加测试环境URL和电子合同相关API路径 - 在lklsdk/merchant/in_net/ec/applymanual/request.go中将AttachType字段类型改为consts.AttType - 在lklsdk/sdk.go中添加电子合同相关服务初始化及接口封装	2025-10-20 10:30:13 +08:00
maguodong	e985b790d4	新增电子合同相关接口及数据结构添加电子合同申请、下载、状态查询、人工复核等功能模块包含请求/响应数据结构及API实现新增相关常量定义和类型	2025-10-20 10:28:54 +08:00