修改商户附件字段名称

- 将 FileData 结构体中的 AttField 字段重命名为 AttFileId
- 保持 AttType 字段不变
- 更新相关注释说明文件编号的含义

README.md

@@ -6,13 +6,15 @@
 
 ```
 lklsdk/
-├── client.go     # 核心客户端
+├── client.go           # 核心客户端
 ├── split_ledger.go     # 分账基本功能
 ├── split_ledger_more.go # 分账扩展功能
-├── trade.go      # 交易相关功能
+├── trade.go            # 交易相关功能
-├── account.go    # 账户相关功能
+├── account.go          # 账户相关功能
-├── merge_pre.go  # 主扫合单交易功能
+├── merge_pre.go        # 主扫合单交易功能
-└── sdk.go        # SDK主入口
+├── sdk.go              # SDK主入口
+├── merchant.go         # 商户相关功能
+└── uploadFile.go       # 文件上传相关功能
 ```
 
 ## 安装
@@ -30,6 +32,7 @@ go get -u github.com/black1552/lkl_sdk
 import (
 	"github.com/black1552/lkl_sdk/lklsdk"
 	"github.com/black1552/lkl_sdk/model"
+	"github.com/black1552/lkl_sdk/consts"
 	"github.com/gogf/gf/v2/os/gctx"
 )
 
@@ -122,7 +125,7 @@ applyLedgerReq := &model.ApplyLedgerMerReqData{
 	SplitLowestRatio:     3.51,                                 // 最低分账比例
 	SplitEntrustFileName: "授权委托书.pdf",                     // 授权委托书文件名
 	SplitEntrustFilePath: "path",                              // 授权委托书文件路径
-	SplitRange:           "ALL",                               // 分账范围（ALL全部交易分账，MARK标记交易分账）
+	SplitRange:           consts.SPLIT_RANGE_ALL,                               // 分账范围（ALL全部交易分账，MARK标记交易分账）
 	RetUrl:               "notifyUrl.com",                     // 回调URL
 }
 
@@ -181,7 +184,7 @@ splitLedgerReq := &model.OrderSplitLedgerReqData{
 	OutSeparateNo: "",              // 商户分账指令流水号
 	TotalAmt:      "",              // 分账总金额，单位为分
 	LklOrgNo:      "",              // 拉卡拉机构编号
-	CalType:       "",              // 分账计算类型（0-按金额，1-按比例）
+	CalType:       consts.CAL_TYPE_AMOUNT,              // 分账计算类型（0-按金额，1-按比例）
 	NotifyUrl:     "",              // 回调地址
 	RecvDatas:     recvDatas,        // 分账接收方数据
 }
@@ -242,8 +245,8 @@ balanceQueryReq := &model.BalanceQueryReqData{
 	MerchantNo: config.MerchantNo,
 	OrgNo:      "",    // 机构号
 	PayNo:      "",    // 支付单号
-	PayType:    "",    // 支付类型
+	PayType:    consts.PAY_TYPE_CARD,    // 支付类型（CARD-卡支付，COUPON-优惠券支付，DISCOUNT-折扣支付，POINT-积分支付，MIX-混合支付）
-	MgtFlag:    "",    // 管理标志
+	MgtFlag:    consts.MGT_FLAG_NO,    // 管理标志（NO-普通交易，YES-管理交易）
 }
 
 // 调用接口
@@ -282,6 +285,295 @@ if !resp.SuccessOrFail() {
 // 使用resp获取返回的数据
 ```
 
+### 7. 账户提现
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.WithdrawResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+withdrawReq := &model.WithdrawReqData{
+	MerchantNo: "your_merchant_no",  // 商户号
+	TermNo:     "your_term_no",      // 终端号
+	OutTradeNo: "your_withdraw_out_trade_no", // 提现商户流水号
+	Amount:     "10000",             // 提现金额，单位为分
+	Currency:   "CNY",               // 货币类型
+	AccountType: "WECHAT",           // 账户类型
+}
+
+// 调用接口
+withdrawResp, err := sdk.Withdraw(withdrawReq)
+if err != nil {
+	log.Printf("账户提现失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !withdrawResp.SuccessOrFail() {
+	log.Printf("账户提现失败: %s\n", withdrawResp.Msg)
+}
+```
+
+### 8. 商户进件
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.MerchantApplyResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+merchantApplyReq := &model.MerchantApplyReqData{
+	// 填写商户进件所需的各项参数
+	MerchantName: "商户名称",
+	ContactName:  "联系人姓名",
+	ContactPhone: "联系电话",
+	// ... 其他必要参数
+}
+
+// 调用接口
+merchantApplyResp, err := sdk.AddMer(merchantApplyReq)
+if err != nil {
+	log.Printf("商户进件失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !merchantApplyResp.SuccessOrFail() {
+	log.Printf("商户进件失败: %s\n", merchantApplyResp.Msg)
+}
+```
+
+### 9. 商户进件信息查询
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.QueryMerResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+queryMerReq := &model.QueryMerRequestData{
+	MerchantNo: "your_merchant_no", // 商户号
+	// ... 其他必要参数
+}
+
+// 调用接口
+queryMerResp, err := sdk.QueryMerchant(queryMerReq)
+if err != nil {
+	log.Printf("商户进件信息查询失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !queryMerResp.SuccessOrFail() {
+	log.Printf("商户进件信息查询失败: %s\n", queryMerResp.Msg)
+}
+```
+
+### 10. 商户进件信息校验
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.MerValidateResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+merValidateReq := &model.MerValidateRequestData{
+	// 填写商户进件校验所需的各项参数
+	MerchantName: "商户名称",
+	// ... 其他必要参数
+}
+
+// 调用接口
+merValidateResp, err := sdk.MerValidate(merValidateReq)
+if err != nil {
+	log.Printf("商户进件信息校验失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !merValidateResp.SuccessOrFail() {
+	log.Printf("商户进件信息校验失败: %s\n", merValidateResp.Msg)
+}
+```
+
+### 11. 商户进件复议提交
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.ReConfSubmitResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+reConfSubmitReq := &model.ReConfSubmitRequestData{
+	// 填写商户进件复议所需的各项参数
+	MerchantNo: "your_merchant_no",
+	// ... 其他必要参数
+}
+
+// 调用接口
+reConfSubmitResp, err := sdk.ReconsiderSubmit(reConfSubmitReq)
+if err != nil {
+	log.Printf("商户进件复议提交失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !reConfSubmitResp.SuccessOrFail() {
+	log.Printf("商户进件复议提交失败: %s\n", reConfSubmitResp.Msg)
+}
+```
+
+### 12. 聚合预下单
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.PreorderResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+preOrderReq := &model.PreorderReqData{
+	MerchantNo:  "your_merchant_no",  // 商户号
+	TermNo:      "your_term_no",      // 终端号
+	OutTradeNo:  "your_out_trade_no", // 商户交易流水号
+	AccountType: "WECHAT",            // 账户类型
+	TransType:   "71",                // 交易类型
+	Amount:      "100",               // 金额，单位为分
+	Subject:     "测试订单",           // 订单标题
+	NotifyUrl:   "https://your-notify-url.com", // 回调地址
+}
+
+// 调用接口
+preOrderResp, err := sdk.PreOrder(preOrderReq)
+if err != nil {
+	log.Printf("聚合预下单失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !preOrderResp.SuccessOrFail() {
+	log.Printf("聚合预下单失败: %s\n", preOrderResp.Msg)
+}
+```
+
+### 13. 文件上传查询
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.UploadFileResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+uploadFileReq := &model.UploadFileReqData{
+	// 填写文件上传查询所需的各项参数
+	// ...
+}
+
+// 调用接口
+uploadFileResp, err := sdk.UploadFileQuery(uploadFileReq)
+if err != nil {
+	log.Printf("文件上传查询失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !uploadFileResp.SuccessOrFail() {
+	log.Printf("文件上传查询失败: %s\n", uploadFileResp.Msg)
+}
+```
+
+### 14. 分账接收方创建申请
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.ApplyLedgerReceiverResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+applyLedgerReceiverReq := &model.ApplyLedgerReceiverReqData{
+	MerchantNo:    "your_merchant_no",  // 商户号
+	TermNo:        "your_term_no",      // 终端号
+	ReceiverType:  "PERSON",            // 接收方类型
+	ReceiverName:  "接收方名称",         // 接收方名称
+	ReceiverNo:    "接收方编号",         // 接收方编号
+	ReceiverAccNo: "接收方账号",         // 接收方账号
+	// ... 其他必要参数
+}
+
+// 调用接口
+applyLedgerReceiverResp, err := sdk.ApplyLedgerReceiver(applyLedgerReceiverReq)
+if err != nil {
+	log.Printf("分账接收方创建申请失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !applyLedgerReceiverResp.SuccessOrFail() {
+	log.Printf("分账接收方创建申请失败: %s\n", applyLedgerReceiverResp.Msg)
+}
+```
+
+### 15. 分账关系绑定申请
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.ApplyBindResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+applyBindReq := &model.ApplyBindReqData{
+	MerchantNo:   "your_merchant_no",  // 商户号
+	TermNo:       "your_term_no",      // 终端号
+	ReceiverType: "PERSON",            // 接收方类型
+	ReceiverNo:   "接收方编号",         // 接收方编号
+	BindType:     "1",                 // 绑定类型
+	// ... 其他必要参数
+}
+
+// 调用接口
+applyBindResp, err := sdk.ApplyBind(applyBindReq)
+if err != nil {
+	log.Printf("分账关系绑定申请失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !applyBindResp.SuccessOrFail() {
+	log.Printf("分账关系绑定申请失败: %s\n", applyBindResp.Msg)
+}
+```
+
+### 16. 可分账金额查询
+
+```go
+// 初始化特定响应类型的SDK
+sdk := lklsdk.NewSDK[model.SplitBalanceResponse](gctx.New(), cfgJson)
+
+// 构建请求参数
+splitBalanceReq := &model.SplitBalanceReqData{
+	MerchantNo: "your_merchant_no",  // 商户号
+	TermNo:     "your_term_no",      // 终端号
+	// ... 其他必要参数
+}
+
+// 调用接口
+splitBalanceResp, err := sdk.QuerySplitBalance(splitBalanceReq)
+if err != nil {
+	log.Printf("可分账金额查询失败: %v\n", err)
+}
+
+// 使用SuccessOrFail方法判断请求是否成功
+if !splitBalanceResp.SuccessOrFail() {
+	log.Printf("可分账金额查询失败: %s\n", splitBalanceResp.Msg)
+}
+```
+
+## 错误处理
+
+SDK使用两层错误处理机制，请确保同时检查网络错误和业务响应状态：
+
+```go
+// 1. 首先检查网络或SDK层面的错误
+resp, err := sdk.SomeFunction(req)
+if err != nil {
+	log.Printf("调用接口失败: %v\n", err)
+	// 处理网络错误或SDK内部错误
+	return err
+}
+
+// 2. 然后使用SuccessOrFail()方法判断业务响应是否成功
+if !resp.SuccessOrFail() {
+	log.Printf("业务处理失败: %s\n", resp.Msg) // 或resp.RetMsg
+	// 处理业务失败情况
+	return errors.New("业务处理失败")
+}
+
+// 处理成功响应
+// 使用resp获取返回的数据
+```
+
 ## 注意事项
 
 1. 请妥善保管您的AppID、商户号、密钥等敏感信息

consts/account.go

@@ -27,6 +27,13 @@ func (at AttType) Ptr() string {
 	return string(at)
 }
 
+type MgtFlag string
+
+const (
+	MGT_FLAG_AVERAGE   MgtFlag = "01" // 一般账户
+	MGT_FLAG_HOUSEHOLD MgtFlag = "03" // 虚户
+)
+
 type SplitRange string
 
 const (

consts/url.go

@@ -46,3 +46,15 @@ const (
 	// LKL_RECONF_SUBMIT 拉卡拉商户进件复议提交
 	LKL_RECONF_SUBMIT = "/v2/mms/openApi/reconsiderSubmit"
 )
+
+// unifiedReturn  统一退货API地址
+const (
+	// LKL_UNIFIED_RETURN_MERGE_REFUND_URL 拉卡拉合单退货
+	LKL_UNIFIED_RETURN_MERGE_REFUND_URL = "/v3/rfd/refund_front/merge_refund"
+	// LKL_UNIFIED_RETURN_REFUND_URL 拉卡拉退货
+	LKL_UNIFIED_RETURN_REFUND_URL = "/v3/rfd/refund_front/refund"
+	// LKL_UNIFIED_RETURN_REFUND_QUERY_URL 拉卡拉退货查询
+	LKL_UNIFIED_RETURN_REFUND_QUERY_URL = "/v3/rfd/refund_front/refund_query"
+	// LKL_UNIFIED_RETURN_REFUND_FEE_URL 拉卡拉退货手续费查询
+	LKL_UNIFIED_RETURN_REFUND_FEE_URL = "/v3/rfd/refund_front/refund_fee"
+)

go.mod

@@ -20,6 +20,7 @@ require (
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-sql-driver/mysql v1.9.2 // indirect
 	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.3 // indirect
+	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect

lklsdk/account.go

@@ -1,19 +1,19 @@
 package lklsdk
 
 import (
-	"time"
-
 	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
 	"github.com/black1552/lkl_sdk/model"
+	"github.com/gogf/gf/v2/os/gtime"
 )
 
 // AccountService 账户服务
 type AccountService[T any] struct {
-	client *Client[T]
+	client *common.Client[T]
 }
 
 // NewAccountService 创建账户服务实例
-func NewAccountService[T any](client *Client[T]) *AccountService[T] {
+func NewAccountService[T any](client *common.Client[T]) *AccountService[T] {
 	return &AccountService[T]{
 		client: client,
 	}
@@ -26,12 +26,12 @@ func (a *AccountService[T]) BalanceQuery(req *model.BalanceQueryReqData) (*T, er
 
 	// 构建BaseModel请求
 	baseReq := model.BalanceQueryRequest{
-		ReqTime: time.Now().Format("20060102150405"),
+		ReqTime: gtime.Now().Format("YmdHis"),
 		Version: "3.0",
 		ReqData: req,
 	}
 	// 发送请求
-	respBody, err := a.client.doRequest(url, baseReq)
+	respBody, err := a.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -46,13 +46,13 @@ func (a *AccountService[T]) Withdraw(req *model.WithdrawReqData) (*T, error) {
 
 	// 构建BaseModel请求
 	baseReq := model.WithdrawRequest{
-		ReqTime: time.Now().Format("20060102150405"),
+		ReqTime: gtime.Now().Format("YmdHis"),
 		Version: "3.0",
 		ReqData: req,
 	}
 
 	// 发送请求
-	respBody, err := a.client.doRequest(url, baseReq)
+	respBody, err := a.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}

lklsdk/common/client.go

@@ -1,4 +1,4 @@
-package lklsdk
+package common
 
 import (
 	"context"
@@ -8,33 +8,21 @@ import (
 	"crypto/sha256"
 	"crypto/x509"
 	"encoding/base64"
-	"encoding/json"
 	"encoding/pem"
 	"fmt"
 	ran "math/rand"
 	"time"
 
 	"github.com/black1552/base-common/utils"
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
-// Config 拉卡拉SDK配置
-type Config struct {
-	PublicKey   string `json:"public_key" dc:"公钥字符串"`
-	PrivateKey  string `json:"private_key" dc:"私钥字符串"`
-	AppId       string `json:"app_id" dc:"lakala应用ID"`
-	SerialNo    string `json:"serial_no" dc:"序列号"`
-	SubAppId    string `json:"sub_app_id" dc:"子应用ID 微信AppId"`
-	Version     string `json:"version" dc:"lakala版本号"`
-	AccountType string `json:"account_type" dc:"账户类型"`
-	TransType   string `json:"trans_type" dc:"交易类型"`
-	NotifyUrl   string `json:"notify_url" dc:"回调地址"`
-}
-
 // Client 拉卡拉SDK客户端
 type Client[T any] struct {
-	config   *Config
+	Config   *Config
 	response T
 	ctx      context.Context
 }
@@ -47,7 +35,7 @@ func NewClient[T any](ctx context.Context, cfgJson string) *Client[T] {
 		return nil
 	}
 	return &Client[T]{
-		config: config,
+		Config: config,
 		ctx:    ctx,
 	}
 }
@@ -68,7 +56,7 @@ func (c *Client[T]) generateSign(request []byte) (string, error) {
 	timestamp := fmt.Sprintf("%d", time.Now().Unix())
 
 	// 构建待签名报文
-	signData := fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n", c.config.AppId, c.config.SerialNo, timestamp, nonceStr, string(request))
+	signData := fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n", c.Config.AppId, c.Config.SerialNo, timestamp, nonceStr, string(request))
 
 	// 计算签名
 	hashed := sha256.Sum256([]byte(signData))
@@ -85,12 +73,12 @@ func (c *Client[T]) generateSign(request []byte) (string, error) {
 
 	// 构建Authorization头
 	authorization := fmt.Sprintf("LKLAPI-SHA256withRSA appid=\"%s\",serial_no=\"%s\",timestamp=\"%s\",nonce_str=\"%s\",signature=\"%s\"",
-		c.config.AppId, c.config.SerialNo, timestamp, nonceStr, signatureBase64)
+		c.Config.AppId, c.Config.SerialNo, timestamp, nonceStr, signatureBase64)
 	return authorization, nil
 }
 
 func (c *Client[T]) loadPrivateKey() (*rsa.PrivateKey, error) {
-	block, _ := pem.Decode(gfile.GetBytes(c.config.PrivateKey))
+	block, _ := pem.Decode(gfile.GetBytes(c.Config.PrivateKey))
 	if block == nil {
 		return nil, fmt.Errorf("无法解码私钥PEM数据")
 	}
@@ -102,15 +90,19 @@ func (c *Client[T]) loadPrivateKey() (*rsa.PrivateKey, error) {
 	return privateKey.(*rsa.PrivateKey), nil
 }
 
-// doRequest 发送HTTP请求
+// DoRequest 发送HTTP请求
-func (c *Client[T]) doRequest(url string, reqData interface{}) (*T, error) {
+func (c *Client[T]) DoRequest(url string, reqData interface{}) (*T, error) {
-	// 序列化为JSON
+	jsonStr, err := gjson.EncodeString(reqData)
-	jsonData, err := json.Marshal(reqData)
 	if err != nil {
-		return nil, fmt.Errorf("序列化请求数据失败: %v", err)
+		return nil, fmt.Errorf("请求参数转JSON字符串失败: %v", err)
 	}
+	reqJson, err := CleanJSON(jsonStr)
+	if err != nil {
+		return nil, fmt.Errorf("清理JSON空值失败: %v", err)
+	}
+	g.Log().Infof(c.ctx, "清理后的json: %v", string(reqJson))
 
-	auth, err := c.generateSign(jsonData)
+	auth, err := c.generateSign(reqJson)
 	if err != nil {
 		return nil, fmt.Errorf("生成签名失败: %v", err)
 	}
@@ -121,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

@@ -0,0 +1,118 @@
+package common
+
+import (
+	"encoding/json"
+	"reflect"
+)
+
+// 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
+	}
+
+	// 递归清理数据
+	cleaned := cleanData(data)
+
+	// 转换回JSON字符串
+	result, err := json.Marshal(cleaned)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+// cleanData 递归清理map或slice中的空值和0值
+func cleanData(data interface{}) interface{} {
+	if data == nil {
+		return nil
+	}
+
+	v := reflect.ValueOf(data)
+
+	switch v.Kind() {
+	case reflect.Map:
+		cleanedMap := make(map[string]interface{})
+		for _, key := range v.MapKeys() {
+			val := v.MapIndex(key)
+			if val.Interface() != nil && !isEmptyValue(val) {
+				cleanedVal := cleanData(val.Interface())
+				// 只有清理后的值不为空才添加
+				if !isCleanedValueEmpty(cleanedVal) {
+					cleanedMap[key.String()] = cleanedVal
+				}
+			}
+		}
+		return cleanedMap
+
+	case reflect.Slice:
+		cleanedSlice := make([]interface{}, 0)
+		for i := 0; i < v.Len(); i++ {
+			item := v.Index(i)
+			if item.Interface() != nil && !isEmptyValue(item) {
+				cleanedItem := cleanData(item.Interface())
+				if !isCleanedValueEmpty(cleanedItem) {
+					cleanedSlice = append(cleanedSlice, cleanedItem)
+				}
+			}
+		}
+		// 如果slice为空，则返回nil而不是空slice
+		if len(cleanedSlice) == 0 {
+			return nil
+		}
+		return cleanedSlice
+
+	default:
+		return data
+	}
+}
+
+// isEmptyValue 检查值是否为空值或0值
+func isEmptyValue(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Interface, reflect.Ptr:
+		return v.IsNil()
+	case reflect.Slice, reflect.Map:
+		return v.Len() == 0
+	case reflect.String:
+		return v.String() == "" || v.String() == "0"
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	}
+
+	// 特殊处理nil值
+	if !v.IsValid() {
+		return true
+	}
+
+	return false
+}
+
+// isCleanedValueEmpty 检查清理后的值是否为空
+func isCleanedValueEmpty(val interface{}) bool {
+	if val == nil {
+		return true
+	}
+
+	v := reflect.ValueOf(val)
+	switch v.Kind() {
+	case reflect.Map:
+		return v.Len() == 0
+	case reflect.Slice:
+		return v.Len() == 0
+	case reflect.String:
+		return val == ""
+	}
+
+	return false
+}

lklsdk/common/structs.go

@@ -0,0 +1,14 @@
+package common
+
+// Config 拉卡拉SDK配置
+type Config struct {
+	PublicKey   string `json:"public_key" dc:"公钥字符串"`
+	PrivateKey  string `json:"private_key" dc:"私钥字符串"`
+	AppId       string `json:"app_id" dc:"lakala应用ID"`
+	SerialNo    string `json:"serial_no" dc:"序列号"`
+	SubAppId    string `json:"sub_app_id" dc:"子应用ID 微信AppId"`
+	Version     string `json:"version" dc:"lakala版本号"`
+	AccountType string `json:"account_type" dc:"账户类型"`
+	TransType   string `json:"trans_type" dc:"交易类型"`
+	NotifyUrl   string `json:"notify_url" dc:"回调地址"`
+}

lklsdk/merchant.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
 	"github.com/black1552/lkl_sdk/model"
 	"github.com/gogf/gf/v2/crypto/gmd5"
 	"github.com/gogf/gf/v2/util/gconv"
@@ -12,11 +13,11 @@ import (
 
 // MerService 商户服务
 type MerService[T any] struct {
-	client *Client[T]
+	client *common.Client[T]
 }
 
 // NewMerService 创建交易服务实例
-func NewMerService[T any](client *Client[T]) *MerService[T] {
+func NewMerService[T any](client *common.Client[T]) *MerService[T] {
 	return &MerService[T]{
 		client: client,
 	}
@@ -39,7 +40,7 @@ func (t *MerService[T]) AddMer(req *model.MerchantApplyReqData) (*T, error) {
 	}
 
 	// 发送请求
-	respBody, err := t.client.doRequest(url, baseReq)
+	respBody, err := t.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -62,7 +63,7 @@ func (t *MerService[T]) QueryMer(req *model.QueryMerRequestData) (*T, error) {
 	}
 
 	// 发送请求
-	respBody, err := t.client.doRequest(url, baseReq)
+	respBody, err := t.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -84,7 +85,7 @@ func (t *MerService[T]) MerValidate(req *model.MerValidateRequestData) (*T, erro
 	}
 
 	// 发送请求
-	respBody, err := t.client.doRequest(url, baseReq)
+	respBody, err := t.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -107,7 +108,7 @@ func (t *MerService[T]) ReconsiderSubmit(req *model.ReConfSubmitRequestData) (*T
 	}
 
 	// 发送请求
-	respBody, err := t.client.doRequest(url, baseReq)
+	respBody, err := t.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}

lklsdk/mergePre.go

@@ -2,16 +2,17 @@ package lklsdk
 
 import (
 	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
 	"github.com/black1552/lkl_sdk/model"
 	"github.com/gogf/gf/v2/os/gtime"
 )
 
 type MergePreService[T any] struct {
-	client *Client[T]
+	client *common.Client[T]
 }
 
 // NewMergePreService 创建拉卡拉主扫合单交易
-func NewMergePreService[T any](client *Client[T]) *MergePreService[T] {
+func NewMergePreService[T any](client *common.Client[T]) *MergePreService[T] {
 	return &MergePreService[T]{
 		client: client,
 	}
@@ -29,7 +30,7 @@ func (s *MergePreService[T]) PreOrder(req *model.MergePreorderReqData) (*T, erro
 	}
 
 	// 发送请求
-	respBody, err := s.client.doRequest(url, baseReq)
+	respBody, err := s.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}

lklsdk/sdk.go

@@ -3,12 +3,13 @@ package lklsdk
 import (
 	"context"
 
+	"github.com/black1552/lkl_sdk/lklsdk/common"
 	"github.com/black1552/lkl_sdk/model"
 )
 
 // SDK 拉卡拉SDK主入口
 type SDK[T any] struct {
-	Client      *Client[T]
+	Client      *common.Client[T]
 	SplitLedger *SplitLedgerService[T]
 	Trade       *TradeService[T]
 	Account     *AccountService[T]
@@ -19,7 +20,7 @@ type SDK[T any] struct {
 
 // NewSDK 创建拉卡拉SDK实例
 func NewSDK[T any](ctx context.Context, cfgJson string) *SDK[T] {
-	client := NewClient[T](ctx, cfgJson)
+	client := common.NewClient[T](ctx, cfgJson)
 	return &SDK[T]{
 		Client:      client,
 		SplitLedger: NewSplitLedgerService(client),

lklsdk/split_ledger.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
 	"github.com/black1552/lkl_sdk/model"
 	"github.com/gogf/gf/v2/crypto/gmd5"
 	"github.com/gogf/gf/v2/os/gtime"
@@ -13,11 +14,11 @@ import (
 
 // SplitLedgerService 分账服务
 type SplitLedgerService[T any] struct {
-	client *Client[T]
+	client *common.Client[T]
 }
 
 // NewSplitLedgerService 创建分账服务实例
-func NewSplitLedgerService[T any](client *Client[T]) *SplitLedgerService[T] {
+func NewSplitLedgerService[T any](client *common.Client[T]) *SplitLedgerService[T] {
 	return &SplitLedgerService[T]{
 		client: client,
 	}
@@ -41,7 +42,7 @@ func (s *SplitLedgerService[T]) ApplyLedgerMer(req *model.ApplyLedgerMerReqData)
 	}
 
 	// 发送请求
-	respBody, err := s.client.doRequest(url, baseReq)
+	respBody, err := s.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -67,7 +68,7 @@ func (s *SplitLedgerService[T]) ApplyLedgerReceiver(req *model.ApplyLedgerReceiv
 	}
 
 	// 发送请求
-	respBody, err := s.client.doRequest(url, baseReq)
+	respBody, err := s.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -88,7 +89,7 @@ func (s *SplitLedgerService[T]) QueryLedgerMer(req *model.QueryLedgerMerReqData)
 	}
 
 	// 发送请求
-	respBody, err := s.client.doRequest(url, baseReq)
+	respBody, err := s.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}

lklsdk/split_ledger_more.go

@@ -29,7 +29,7 @@ func (s *SplitLedgerService[T]) ApplyBind(req *model.ApplyBindReqData) (*T, erro
 	}
 
 	// 发送请求
-	respBody, err := s.client.doRequest(url, baseReq)
+	respBody, err := s.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -49,7 +49,7 @@ func (s *SplitLedgerService[T]) QuerySplitBalance(req *model.SplitBalanceReqData
 	}
 
 	// 发送请求
-	respBody, err := s.client.doRequest(url, baseReq)
+	respBody, err := s.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -69,7 +69,7 @@ func (s *SplitLedgerService[T]) OrderSplitLedger(req *model.OrderSplitLedgerReqD
 	}
 
 	// 发送请求
-	respBody, err := s.client.doRequest(url, baseReq)
+	respBody, err := s.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}

lklsdk/trade.go

@@ -4,16 +4,17 @@ import (
 	"time"
 
 	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
 	"github.com/black1552/lkl_sdk/model"
 )
 
 // TradeService 交易服务
 type TradeService[T any] struct {
-	client *Client[T]
+	client *common.Client[T]
 }
 
 // NewTradeService 创建交易服务实例
-func NewTradeService[T any](client *Client[T]) *TradeService[T] {
+func NewTradeService[T any](client *common.Client[T]) *TradeService[T] {
 	return &TradeService[T]{
 		client: client,
 	}
@@ -28,12 +29,12 @@ func (t *TradeService[T]) TradeQuery(req *model.TradeQueryReqData) (*T, error) {
 	baseReq := model.TradeQuery{
 		ReqTime:    time.Now().Format("20060102150405"),
 		Version:    "3.0",
-		OutOrgCode: t.client.config.AppId,
+		OutOrgCode: t.client.Config.AppId,
 		ReqData:    req,
 	}
 
 	// 发送请求
-	respBody, err := t.client.doRequest(url, baseReq)
+	respBody, err := t.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -49,7 +50,7 @@ func (t *TradeService[T]) PreOrder(req *model.PreorderReqData) (*T, error) {
 	baseReq := model.NewPreorder(req)
 
 	// 发送请求
-	respBody, err := t.client.doRequest(url, baseReq)
+	respBody, err := t.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}
@@ -65,7 +66,7 @@ func (t *TradeService[T]) Refound(req *model.RefundReqData) (*T, error) {
 	// 构建BaseModel请求
 	baseReq := model.NewRefund(req)
 	// 发送请求
-	respBody, err := t.client.doRequest(url, baseReq)
+	respBody, err := t.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}

lklsdk/unifiedReturn/mergeRefund/api.go

@@ -0,0 +1,34 @@
+package mergerefund
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type MergeRefund[T any] struct {
+	client *common.Client[T]
+}
+
+func NewMergeRefund[T any](client *common.Client[T]) *MergeRefund[T] {
+	return &MergeRefund[T]{
+		client: client,
+	}
+}
+func (t *MergeRefund[T]) MergeRefund(req *RequestDataMergeRefund) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_URL + consts.LKL_UNIFIED_RETURN_MERGE_REFUND_URL
+	// 构建BaseModel请求
+	baseReq := RequestMergeRefund{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: req,
+	}
+
+	// 发送请求
+	respBody, err := t.client.DoRequest(url, baseReq)
+	if err != nil {
+		return nil, err
+	}
+	return respBody, nil
+}

lklsdk/unifiedReturn/mergeRefund/request.go

@@ -0,0 +1,42 @@
+package mergerefund
+
+// RequestMergeRefund 统一退货基础请求结构体
+type RequestMergeRefund struct {
+	ReqTime string                  `json:"req_time" dc:"ReqTime 请求时间 必填，格式yyyyMMddHHmmss"`
+	Version string                  `json:"version" dc:"Version 版本号 必填，固定为\"3\""`
+	ReqData *RequestDataMergeRefund `json:"req_data" dc:"ReqData 请求参数 必填，具体字段见对应的数据结构体"`
+}
+
+// RequestDataMergeRefund 合单退货请求参数结构体
+type RequestDataMergeRefund struct {
+	MerchantNo       string                `json:"merchant_no" dc:"MerchantNo 商户号 必填，拉卡拉分配的商户号"`
+	TermNo           string                `json:"term_no" dc:"TermNo 终端号 必填，拉卡拉分配的终端号"`
+	OutTradeNo       string                `json:"out_trade_no" dc:"OutTradeNo 商户请求流水号 必填，商户系统唯一"`
+	RefundAmount     string                `json:"refund_amount" dc:"RefundAmount 退款金额 必填，单位分，整数数字型字符"`
+	RefundReason     string                `json:"refund_reason,omitempty" dc:"RefundReason 退货原因 可选"`
+	OriginLogNo      string                `json:"origin_log_no,omitempty" dc:"OriginLogNo 拉卡拉对账单流水号 可选，正交易返回的拉卡拉对账单流水号"`
+	OriginOutTradeNo string                `json:"origin_out_trade_no,omitempty" dc:"OriginOutTradeNo 原商户交易流水号 可选"`
+	OriginTradeNo    string                `json:"origin_trade_no,omitempty" dc:"OriginTradeNo 原交易拉卡拉交易订单号 可选"`
+	LocationInfo     *LocationInfo         `json:"location_info" dc:"LocationInfo 地址位置信息 必填"`
+	NotifyURL        string                `json:"notify_url,omitempty" dc:"NotifyURL 后台通知地址 可选，交易结果通知地址"`
+	RefundAccMode    string                `json:"refund_acc_mode,omitempty" dc:"RefundAccMode 退货账户模式 可选，00退货账户余额 05商户余额 06终端余额"`
+	RefundSplitInfo  []*RelateOutSplitInfo `json:"refund_split_info,omitempty" dc:"RefundSplitInfo 请参合单域 可选"`
+}
+
+// LocationInfo 地址位置信息结构体
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip" dc:"RequestIP 请求方IP地址 必填，格式如36.45.36.95"`
+	Location    string `json:"location,omitempty" dc:"Location 维度,经度 可选，商户终端的地理位置，格式：纬度,经度，+表示北纬、东经，-表示南纬、西经，精度最长支持小数点后9位"`
+	BaseStation string `json:"base_station,omitempty" dc:"BaseStation 基站信息 可选，客户端设备的基站信息"`
+}
+
+// RelateOutSplitInfo 请求合单域结构体
+type RelateOutSplitInfo struct {
+	OutSubTradeNo       string `json:"out_sub_trade_no" dc:"OutSubTradeNo 外部子退款交易流水号 必填，商户子交易退款流水号，商户号下唯一"`
+	MerchantNo          string `json:"merchant_no" dc:"MerchantNo 商户号 必填，拉卡拉分配的商户号"`
+	TermNo              string `json:"term_no" dc:"TermNo 终端号 必填，拉卡拉分配的业务终端号"`
+	RefundAmount        string `json:"refund_amount" dc:"RefundAmount 申请退款金额 必填，单位分，整数型字符"`
+	OriginOutSubTradeNo string `json:"origin_out_sub_trade_no,omitempty" dc:"OriginOutSubTradeNo 原商户交易流水号 可选，下单时的商户子单请求流水号"`
+	OriginSubTradeNo    string `json:"origin_sub_trade_no,omitempty" dc:"OriginSubTradeNo 原拉卡拉子交易流水号 可选，下单成功时，返回的拉卡拉交易子流水"`
+	OriginSubLogNo      string `json:"origin_sub_log_no,omitempty" dc:"OriginSubLogNo 原对账单子流水号 可选，原交易的tradeNo的后14位，必须是66开头的"`
+}

lklsdk/unifiedReturn/mergeRefund/response.go

@@ -0,0 +1,53 @@
+package mergerefund
+
+// ResponseMergeRefund 统一退货响应结构体
+type ResponseMergeRefund struct {
+	Code     string                   `json:"code" dc:"Code 响应码"`
+	Msg      string                   `json:"msg" dc:"Msg 响应描述"`
+	RespTime string                   `json:"resp_time" dc:"RespTime 响应时间"`
+	RespData *ResponseDataMergeRefund `json:"resp_data" dc:"RespData 响应数据"`
+}
+
+func (r *ResponseMergeRefund) SuccessOrFail() bool {
+	return r.Code == "000000"
+}
+
+// ResponseDataMergeRefund 合单退货响应数据结构体
+type ResponseDataMergeRefund struct {
+	TradeState       string                   `json:"trade_state" dc:"TradeState 交易状态 必填，INIT-初始化；SUCCESS-交易成功；FAIL-交易失败；DEAL-交易处理中/未知；PROCESSING-交易已受理；TIMEOUT-超时未知；EXCEPTION-异常"`
+	RefundType       string                   `json:"refund_type" dc:"RefundType 退货模式 必填"`
+	MerchantNo       string                   `json:"merchant_no" dc:"MerchantNo 商户号 必填，拉卡拉分配的商户号"`
+	OutTradeNo       string                   `json:"out_trade_no" dc:"OutTradeNo 商户请求流水号 必填，请求中的商户请求流水号"`
+	TradeNo          string                   `json:"trade_no" dc:"TradeNo 拉卡拉交易流水号 必填"`
+	LogNo            string                   `json:"log_no" dc:"LogNo 拉卡拉对账单流水号 必填，tradeNo的后14位"`
+	AccTradeNo       string                   `json:"acc_trade_no,omitempty" dc:"AccTradeNo 账户端交易订单号 可选"`
+	AccountType      string                   `json:"account_type,omitempty" dc:"AccountType 钱包类型 可选，微信：WECHAT；支付宝：ALIPAY；银联：UQRCODEPAY；翼支付:BESTPAY；苏宁易付宝:SUNING"`
+	TotalAmount      string                   `json:"total_amount" dc:"TotalAmount 交易金额 必填，单位分，整数数字型字符串"`
+	RefundAmount     string                   `json:"refund_amount" dc:"RefundAmount 申请退款金额 必填，单位分，整数数字型字符串"`
+	PayerAmount      string                   `json:"payer_amount" dc:"PayerAmount 实际退款金额 必填，单位分，整数数字型字符串"`
+	TradeTime        string                   `json:"trade_time,omitempty" dc:"TradeTime 退款时间 可选，实际退款时间。yyyyMMddHHmmss"`
+	OriginLogNo      string                   `json:"origin_log_no,omitempty" dc:"OriginLogNo 原拉卡拉对账单流水号 可选，如果请求中携带，则返回"`
+	OriginTradeNo    string                   `json:"origin_trade_no,omitempty" dc:"OriginTradeNo 原拉卡拉交易流水号 可选，如果请求中携带，则返回"`
+	OriginOutTradeNo string                   `json:"origin_out_trade_no,omitempty" dc:"OriginOutTradeNo 原商户请求流水号 可选，如果请求中携带，则返回"`
+	UpIssAddnData    string                   `json:"up_iss_addn_data,omitempty" dc:"UpIssAddnData 单品营销附加数据 可选，扫码交易，参与单品营销优惠时返回"`
+	UpCouponInfo     string                   `json:"up_coupon_info,omitempty" dc:"UpCouponInfo 银联优惠信息 可选，扫码交易，参与单品营销优惠时返回"`
+	TradeInfo        string                   `json:"trade_info,omitempty" dc:"TradeInfo 出资方信息 可选，扫码交易"`
+	ChannelRetDesc   string                   `json:"channel_ret_desc" dc:"ChannelRetDesc 返回描述信息 必填"`
+	RefundSplitInfo  []*RelateOutSplitRspInfo `json:"refund_split_info" dc:"RefundSplitInfo 响应合单域 必填"`
+}
+
+// RelateOutSplitRspInfo 响应合单域结构体
+type RelateOutSplitRspInfo struct {
+	OutSubTradeNo       string `json:"out_sub_trade_no" dc:"OutSubTradeNo 外部子退款交易流水号 必填，请求中的商户子流水号"`
+	MerchantNo          string `json:"merchant_no" dc:"MerchantNo 商户号 必填，拉卡拉分配的商户号"`
+	TermNo              string `json:"term_no" dc:"TermNo 终端号 必填，拉卡拉分配的业务终端号"`
+	TradeState          string `json:"trade_state" dc:"TradeState 交易状态 必填，INIT-初始化；SUCCESS-交易成功；FAIL-交易失败；DEAL-交易处理中/未知；PROCESSING-交易已受理；TIMEOUT-超时未知；EXCEPTION-异常"`
+	SubTradeNo          string `json:"sub_trade_no" dc:"SubTradeNo 拉卡拉子交易流水号 必填"`
+	SubLogNo            string `json:"sub_log_no" dc:"SubLogNo 拉卡拉子对账单流水号 必填"`
+	RefundAmount        string `json:"refund_amount" dc:"RefundAmount 申请退款金额 必填，单位分，整数型字符"`
+	PayerAmount         string `json:"payer_amount" dc:"PayerAmount 实际退款金额 必填，单位分，整数型字符"`
+	TotalAmount         string `json:"total_amount" dc:"TotalAmount 交易金额 必填，单位分，整数型字符"`
+	OriginSubLogNo      string `json:"origin_sub_log_no,omitempty" dc:"OriginSubLogNo 原拉卡拉子对账单流水号 可选，如果请求中携带，则返回"`
+	OriginSubTradeNo    string `json:"origin_sub_trade_no,omitempty" dc:"OriginSubTradeNo 原拉卡拉子交易流水号 可选，如果请求中携带，则返回"`
+	OriginOutSubTradeNo string `json:"origin_out_sub_trade_no,omitempty" dc:"OriginOutSubTradeNo 原商户子交易流水号 可选，如果请求中携带，则返回"`
+}

lklsdk/unifiedReturn/refund/api.go

@@ -0,0 +1,40 @@
+package refund
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// Refund 统一退货API结构体
+type Refund[T any] struct {
+	client *common.Client[T]
+}
+
+// NewRefund 创建统一退货API实例
+func NewRefund[T any](client *common.Client[T]) *Refund[T] {
+	return &Refund[T]{
+		client: client,
+	}
+}
+
+// Refund 发起统一退货请求
+// request: 统一退货请求参数
+// 返回统一退货响应结果和错误信息
+func (api *Refund[T]) Refund(req *RequestDataRefund) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_URL + consts.LKL_UNIFIED_RETURN_REFUND_URL
+	// 构建BaseModel请求
+	baseReq := RequestRefund{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: req,
+	}
+
+	// 发送请求
+	respBody, err := api.client.DoRequest(url, baseReq)
+	if err != nil {
+		return nil, err
+	}
+	return respBody, nil
+}

lklsdk/unifiedReturn/refund/reponse.go

@@ -0,0 +1,37 @@
+package refund
+
+// ResponseRefund 统一退货响应结构体
+// 参考文档：https://o.lakala.com/#/home/document/detail?id=892
+type ResponseRefund struct {
+	Code     string              `json:"code" dc:"Code 返回业务代码 必填，通讯成功返回码：000000；交易未知：RFD11105/RFD11112；其他返回码可视为失败"`
+	Msg      string              `json:"msg" dc:"Msg 返回业务代码描述 必填，如\"成功\""`
+	RespTime string              `json:"resp_time" dc:"RespTime 响应时间 必填，格式yyyyMMddHHmmss"`
+	RespData *ResponseDataRefund `json:"resp_data" dc:"RespData 响应数据 必填，具体字段根据接口返回"`
+}
+
+func (r *ResponseRefund) SuccessOrFail() bool {
+	return r.Code == "000000"
+}
+
+// ResponseDataRefund 统一退货响应数据结构体
+type ResponseDataRefund struct {
+	TradeState       string `json:"trade_state" dc:"TradeState 交易状态 必填，INIT-初始化；SUCCESS-交易成功；FAIL-交易失败；DEAL-交易处理中/未知；PROCESSING-交易已受理；TIMEOUT-超时未知；EXCEPTION-异常"`
+	RefundType       string `json:"refund_type" dc:"RefundType 退货模式 必填"`
+	MerchantNo       string `json:"merchant_no" dc:"MerchantNo 商户号 必填，拉卡拉分配的商户号"`
+	OutTradeNo       string `json:"out_trade_no" dc:"OutTradeNo 商户请求流水号 必填，请求中的商户请求流水号"`
+	TradeNo          string `json:"trade_no" dc:"TradeNo 拉卡拉交易流水号 必填"`
+	LogNo            string `json:"log_no" dc:"LogNo 拉卡拉对账单流水号 必填，tradeNo的后14位"`
+	AccTradeNo       string `json:"acc_trade_no,omitempty" dc:"AccTradeNo 账户端交易订单号 可选"`
+	AccountType      string `json:"account_type,omitempty" dc:"AccountType 钱包类型 可选，微信：WECHAT；支付宝：ALIPAY；银联：UQRCODEPAY；翼支付:BESTPAY；苏宁易付宝:SUNING"`
+	TotalAmount      string `json:"total_amount" dc:"TotalAmount 交易金额 必填，单位分，整数数字型字符串"`
+	RefundAmount     string `json:"refund_amount" dc:"RefundAmount 申请退款金额 必填，单位分，整数数字型字符串"`
+	PayerAmount      string `json:"payer_amount" dc:"PayerAmount 实际退款金额 必填，单位分，整数数字型字符串"`
+	TradeTime        string `json:"trade_time,omitempty" dc:"TradeTime 退款时间 可选，实际退款时间。yyyyMMddHHmmss"`
+	OriginLogNo      string `json:"origin_log_no,omitempty" dc:"OriginLogNo 原拉卡拉对账单流水号 可选，如果请求中携带，则返回"`
+	OriginTradeNo    string `json:"origin_trade_no,omitempty" dc:"OriginTradeNo 原拉卡拉交易流水号 可选，如果请求中携带，则返回"`
+	OriginOutTradeNo string `json:"origin_out_trade_no,omitempty" dc:"OriginOutTradeNo 原商户请求流水号 可选，如果请求中携带，则返回"`
+	UpIssAddData     string `json:"up_iss_add_data,omitempty" dc:"UpIssAddData 单品营销附加数据 可选，扫码交易，参与单品营销优惠时返回"`
+	UpCouponInfo     string `json:"up_coupon_info,omitempty" dc:"UpCouponInfo 银联优惠信息 可选，扫码交易，参与单品营销优惠时返回"`
+	TradeInfo        string `json:"trade_info,omitempty" dc:"TradeInfo 出资方信息 可选，扫码交易"`
+	ChannelRetDesc   string `json:"channel_ret_desc" dc:"ChannelRetDesc 返回描述信息 必填"`
+}

lklsdk/unifiedReturn/refund/request.go

@@ -0,0 +1,34 @@
+package refund
+
+// RequestRefund 统一退货基础请求结构体
+// 参考文档：https://o.lakala.com/#/home/document/detail?id=894
+type RequestRefund struct {
+	ReqTime string             `json:"req_time"`
+	Version string             `json:"version"`
+	ReqData *RequestDataRefund `json:"req_data"`
+}
+
+// RequestDataRefund 统一退货请求数据结构体
+// 注意：origin_out_trade_no、origin_log_no、origin_trade_no至少一个必填（调用收银台下单接口拉起交易后发起退款时至少要传两个）
+// 优先级顺序：origin_trade_no > origin_log_no > origin_out_trade_no
+type RequestDataRefund struct {
+	MerchantNo       string        `json:"merchant_no"`                   // merchant_no: 商户号 (必填，拉卡拉分配的商户号，String(15))
+	TermNo           string        `json:"term_no"`                       // term_no: 终端号 (必填，拉卡拉分配的终端号，String(8))
+	OutTradeNo       string        `json:"out_trade_no"`                  // out_trade_no: 商户请求流水号 (必填，商户系统唯一，String(32))
+	RefundAmount     string        `json:"refund_amount"`                 // refund_amount: 退款金额 (必填，单位分，整数数字型字符，String(12))
+	RefundReason     string        `json:"refund_reason,omitempty"`       // refund_reason: 退货原因 (可选，String(32))
+	OriginLogNo      string        `json:"origin_log_no,omitempty"`       // origin_log_no: 拉卡拉对账单流水号 (可选，正交易返回的拉卡拉对账单流水号，String(14))
+	OriginOutTradeNo string        `json:"origin_out_trade_no,omitempty"` // origin_out_trade_no: 原商户交易流水号 (可选，String(32))
+	OriginTradeNo    string        `json:"origin_trade_no,omitempty"`     // origin_trade_no: 原交易拉卡拉交易订单号 (可选，String(32))
+	LocationInfo     *LocationInfo `json:"location_info"`                 // location_info: 地址位置信息 (必填)
+	RefundAccMode    string        `json:"refund_acc_mode,omitempty"`     // refund_acc_mode: 退货账户模式 (可选，00退货账户余额 05商户余额 06终端余额 30终点账户，String(2))
+	NotifyURL        string        `json:"notify_url,omitempty"`          // notify_url: 后台通知地址 (可选，交易结果通知地址，String(128))
+	RefundAmtSts     string        `json:"refund_amt_sts,omitempty"`      // refund_amt_sts: 退货资金状态 (可选，00 分账前，01 分账后；分账交易部分退货的情况，需要前端上送交易的分账状态，String(2))
+}
+
+// LocationInfo 地址位置信息结构体
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`             // request_ip: 请求IP (必填)
+	Location    string `json:"location"`               // location: 位置信息 (必填，如经纬度等)
+	BaseStation string `json:"base_station,omitempty"` // base_station: 基站信息 (可选)
+}

lklsdk/unifiedReturn/refundfee/api.go

@@ -0,0 +1 @@
+package refundfee

lklsdk/unifiedReturn/refundfee/request.go

@@ -0,0 +1 @@
+package refundfee

lklsdk/unifiedReturn/refundfee/response.go

@@ -0,0 +1 @@
+package refundfee

lklsdk/unifiedReturn/refundquery/api.go

@@ -0,0 +1,37 @@
+package refundquery
+
+import (
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type RefundQuery[T any] struct {
+	client *common.Client[T]
+}
+
+// NewRefundQuery 创建统一退货查询API实例
+func NewRefundQuery[T any](client *common.Client[T]) *RefundQuery[T] {
+	return &RefundQuery[T]{
+		client: client,
+	}
+}
+
+// RefundQuery 发起统一退货查询请求
+func (api *RefundQuery[T]) RefundQuery(req *RequestDataRefundQuery) (*T, error) {
+	// 构建请求参数
+	url := consts.BASE_URL + consts.LKL_UNIFIED_RETURN_REFUND_QUERY_URL
+	// 构建BaseModel请求
+	baseReq := RequestRefundQuery{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: req,
+	}
+
+	// 发送请求
+	respBody, err := api.client.DoRequest(url, baseReq)
+	if err != nil {
+		return nil, err
+	}
+	return respBody, nil
+}

lklsdk/unifiedReturn/refundquery/request.go

@@ -0,0 +1,18 @@
+package refundquery
+
+// RequestRefundQuery 统一退货查询请求结构体
+// API文档: https://o.lakala.com/#/home/document/detail?id=893
+type RequestRefundQuery struct {
+	ReqTime string                  `json:"req_time" dc:"ReqTime 请求时间 格式yyyyMMddHHmmss"`
+	Version string                  `json:"version" dc:"Version 版本号 固定值3.0"`
+	ReqData *RequestDataRefundQuery `json:"req_data" dc:"ReqData 请求数据"`
+}
+
+// RequestDataRefundQuery 统一退货查询请求数据结构体
+// API文档: https://o.lakala.com/#/home/document/detail?id=893
+type RequestDataRefundQuery struct {
+	MerchantNo string `json:"merchant_no" dc:"MerchantNo 商户号 必填，拉卡拉分配的商户号，String(15)"`
+	TermNo     string `json:"term_no" dc:"TermNo 终端号 必填，拉卡拉分配的业务终端号，String(8)"`
+	OutTradeNo string `json:"out_trade_no,omitempty" dc:"OutTradeNo 商户交易流水号 选填，下单时的商户请求流水号，String(32) 与拉卡拉交易流水号二选一"`
+	TradeNo    string `json:"trade_no,omitempty" dc:"TradeNo 拉卡拉交易流水号 选填，拉卡拉交易流水号，String(32) 与商户交易流水号二选一"`
+}

lklsdk/unifiedReturn/refundquery/response.go

@@ -0,0 +1,56 @@
+package refundquery
+
+// ResponseRefundQuery 统一退货查询响应结构体
+// API文档: https://o.lakala.com/#/home/document/detail?id=893
+type ResponseRefundQuery struct {
+	Code string                   `json:"code" dc:"Code 响应码 RFD00000#成功、RFD11112#网络请求超时"`
+	Msg  string                   `json:"msg" dc:"Msg 响应描述"`
+	Data *ResponseDataRefundQuery `json:"data,omitempty" dc:"Data 响应数据"`
+	Sign string                   `json:"sign" dc:"Sign 签名"`
+}
+
+// ResponseDataRefundQuery 统一退货查询响应数据结构体
+// API文档: https://o.lakala.com/#/home/document/detail?id=893
+type ResponseDataRefundQuery struct {
+	OutTradeNo         string                   `json:"out_trade_no" dc:"OutTradeNo 商户请求流水号 必填，原退款交易商户请求流水号（扫码交易返回）"`
+	TradeTime          string                   `json:"trade_time" dc:"TradeTime 交易时间 必填，交易时间yyyyMMddHHmmss"`
+	TradeState         string                   `json:"trade_state" dc:"TradeState 交易状态 必填，INIT-初始化；SUCCESS-交易成功；FAIL-交易失败；DEAL-交易处理中/未知；TIMEOUT-超时未知；EXCEPTION-异常"`
+	TradeNo            string                   `json:"trade_no" dc:"TradeNo 拉卡拉商户订单号 必填，拉卡拉生成的交易流水"`
+	LogNo              string                   `json:"log_no" dc:"LogNo 拉卡拉对账单流水号 必填，拉卡拉生成的对账单流水号（新增）"`
+	AccTradeNo         string                   `json:"acc_trade_no,omitempty" dc:"AccTradeNo 账户端交易订单号 选填，账户端交易流水号，String(32)"`
+	RefundAmount       string                   `json:"refund_amount" dc:"RefundAmount 交易金额 必填"`
+	PayMode            string                   `json:"pay_mode,omitempty" dc:"PayMode 支付方式 选填，00 借记卡 01 贷记卡 02 准贷记卡 银行卡交易返回"`
+	CrdNo              string                   `json:"crd_no,omitempty" dc:"CrdNo 卡号 选填，脱敏卡号，前六后四，中间用*替换"`
+	AccountType        string                   `json:"account_type,omitempty" dc:"AccountType 钱包类型 选填，微信：WECHAT 支付宝：ALIPAY 银联：UNION 翼支付: BESTPAY 苏宁易付宝: SUNING 扫码交易返回"`
+	PayerAmount        string                   `json:"payer_amount,omitempty" dc:"PayerAmount 付款人实付金额 选填，实际退款金额，单位分 扫码交易返回"`
+	AccSettleAmount    string                   `json:"acc_settle_amount,omitempty" dc:"AccSettleAmount 账户端结算金额 选填，账户端应结订单金额，单位分 扫码交易返回"`
+	AccMdiscountAmount string                   `json:"acc_mdiscount_amount,omitempty" dc:"AccMdiscountAmount 商户侧优惠金额（账户端） 选填，商户优惠金额，单位分 扫码交易返回"`
+	AccDiscountAmount  string                   `json:"acc_discount_amount,omitempty" dc:"AccDiscountAmount 账户端优惠金额 选填，拉卡拉优惠金额， 扫码交易返回"`
+	ChannelRetDesc     string                   `json:"channel_ret_desc" dc:"ChannelRetDesc 返回描述信息 必填，code#msg：RFD00000#成功、RFD11112#网络请求超时"`
+	RefundSplitInfo    []*RelateOutSplitRspInfo `json:"refund_split_info,omitempty" dc:"RefundSplitInfo 退款拆单信息 选填，合单交易退款查询时返回"`
+	OriginLogNo        string                   `json:"origin_log_no" dc:"OriginLogNo 拉卡拉对账单流水号 必填，原交易拉卡拉对账单流水号"`
+	OriginOutTradeNo   string                   `json:"origin_out_trade_no" dc:"OriginOutTradeNo 原商户交易流水号 必填"`
+	OriginTradeNo      string                   `json:"origin_trade_no" dc:"OriginTradeNo 原交易拉卡拉交易订单号 必填"`
+	OriginTotalAmount  string                   `json:"origin_total_amount" dc:"OriginTotalAmount 原交易金额 必填，原正交易订单金额"`
+	RefundType         string                   `json:"refund_type,omitempty" dc:"RefundType 退货模式 选填"`
+}
+
+// RelateOutSplitRspInfo 退款拆单信息结构体
+// API文档: https://o.lakala.com/#/home/document/detail?id=893
+type RelateOutSplitRspInfo struct {
+	OutSubTradeNo string `json:"out_sub_trade_no" dc:"OutSubTradeNo 外部子退款交易流水号 必填，商户子交易流水号，商户号下唯一"`
+	MerchantNo    string `json:"merchant_no" dc:"MerchantNo 商户号 必填，拉卡拉分配的商户号"`
+	TermNo        string `json:"term_no" dc:"TermNo 终端号 必填，拉卡拉分配的业务终端号"`
+	RefundAmount  string `json:"refund_amount" dc:"RefundAmount 申请退款金额 必填，单位分，整数型字符"`
+	SubTradeNo    string `json:"sub_trade_no,omitempty" dc:"SubTradeNo 拉卡拉子交易流水号 选填"`
+	SubLogNo      string `json:"sub_log_no,omitempty" dc:"SubLogNo 对账单子流水号 选填，sub_trade_no后14位"`
+	TradeState    string `json:"trade_state,omitempty" dc:"TradeState 子交易状态 选填，SUCCESS-交易成功 FAIL-交易失败"`
+	ResultCode    string `json:"result_code,omitempty" dc:"ResultCode 处理结果码 选填"`
+	ResultMsg     string `json:"result_msg,omitempty" dc:"ResultMsg 处理描述 选填"`
+}
+
+// SuccessOrFail 判断交易是否成功
+// 返回true表示交易成功，false表示交易失败或处理中
+func (r *ResponseRefundQuery) SuccessOrFail() bool {
+	return r.Code == "000000"
+}

lklsdk/unifiedReturn/unifiedReturn.go

@@ -0,0 +1,43 @@
+package unifiedreturn
+
+import (
+	"context"
+
+	"github.com/black1552/lkl_sdk/lklsdk/common"
+	"github.com/black1552/lkl_sdk/lklsdk/unifiedreturn/mergerefund"
+	"github.com/black1552/lkl_sdk/lklsdk/unifiedreturn/refund"
+	"github.com/black1552/lkl_sdk/lklsdk/unifiedreturn/refundquery"
+)
+
+type Server[T any] struct {
+	Client       *common.Client[T]
+	MergeRefound *mergerefund.MergeRefund[T]
+	Refound      *refund.Refund[T]
+	RefoundQuery *refundquery.RefundQuery[T]
+}
+
+// NewServer 创建拉卡拉统一退货服务实例
+func NewServer[T any](ctx context.Context, cfgJson string) *Server[T] {
+	client := common.NewClient[T](ctx, cfgJson)
+	return &Server[T]{
+		Client:       client,
+		MergeRefound: mergerefund.NewMergeRefund[T](client),
+		Refound:      refund.NewRefund[T](client),
+		RefoundQuery: refundquery.NewRefundQuery[T](client),
+	}
+}
+
+// MergeRefund 合单退货
+func (u *Server[T]) MergeRefund(req *mergerefund.RequestDataMergeRefund) (*T, error) {
+	return u.MergeRefound.MergeRefund(req)
+}
+
+// Refund 退货
+func (u *Server[T]) Refund(req *refund.RequestDataRefund) (*T, error) {
+	return u.Refound.Refund(req)
+}
+
+// RefundQuery 退货查询
+func (u *Server[T]) RefundQuery(req *refundquery.RequestDataRefundQuery) (*T, error) {
+	return u.RefoundQuery.RefundQuery(req)
+}

lklsdk/uploadFile.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/black1552/lkl_sdk/consts"
+	"github.com/black1552/lkl_sdk/lklsdk/common"
 	"github.com/black1552/lkl_sdk/model"
 	"github.com/gogf/gf/v2/crypto/gmd5"
 	"github.com/gogf/gf/v2/util/gconv"
@@ -12,11 +13,11 @@ import (
 
 // UploadFileService 交易服务
 type UploadFileService[T any] struct {
-	client *Client[T]
+	client *common.Client[T]
 }
 
 // NewUploadFileService 创建交易服务实例
-func NewUploadFileService[T any](client *Client[T]) *UploadFileService[T] {
+func NewUploadFileService[T any](client *common.Client[T]) *UploadFileService[T] {
 	return &UploadFileService[T]{
 		client: client,
 	}
@@ -39,7 +40,7 @@ func (t *UploadFileService[T]) UploadFileQuery(req *model.UploadFileReqData) (*T
 	}
 
 	// 发送请求
-	respBody, err := t.client.doRequest(url, baseReq)
+	respBody, err := t.client.DoRequest(url, baseReq)
 	if err != nil {
 		return nil, err
 	}

model/balanceQuery.go

@@ -27,7 +27,7 @@ type BalanceQueryReqData struct {
 	// 账号类型（01：收款账户，02：付款账户，03：分账商户账户，04：分账接收方账户，05：充值代付账户，06：结算代付账户）-未上送则默认01，非必传，最大长度32
 	PayType consts.PayType `json:"pay_type"`
 	// 账户标志（01:一般账户;03:虚户）-未上送则默认01，非必传，最大长度32
-	MgtFlag string `json:"mgt_flag"`
+	MgtFlag consts.MgtFlag `json:"mgt_flag"`
 }
 
 // BalanceQueryResponse 余额查询响应结构体

model/merValidate.go

@@ -49,6 +49,10 @@ type MerValidateResponse struct {
 	CmdRetCode string `json:"cmdRetCode"`
 	// ReqId 请求ID
 	ReqId string `json:"reqId"`
+	// md 随机字符串
+	Md string `json:"md"`
+	// RespData 响应业务参数
+	RespData *MerValidateResponseData `json:"respData"`
 	// RetCode 返回码
 	RetCode string `json:"retCode"`
 	// RetMsg 返回消息
@@ -59,6 +63,13 @@ type MerValidateResponse struct {
 	Ver string `json:"ver"`
 }
 
+type MerValidateResponseData struct {
+	// OrgCode 机构代码
+	OrgCode string `json:"orgCode"`
+	// OrderNo 订单号
+	OrderNo string `json:"orderNo"`
+}
+
 func (t *MerValidateResponse) SuccessOrFail() bool {
 	return t.RetCode == "000000"
 }

model/merchant.go

@@ -10,7 +10,7 @@ type MerchantApplyRequest struct {
 	ReqId     string                `json:"reqId"`     // 请求时间，格式为yyyyMMddHHmmss，必填
 	Timestamp int64                 `json:"timestamp"` // 接口版本，固定值"1.0"，必填
 	Ver       string                `json:"ver"`       // 接口版本，固定值"1.0"，必填
-	ReqData   *MerchantApplyReqData `json:"req_data"`  // 请求业务参数，必填
+	ReqData   *MerchantApplyReqData `json:"reqData"`   // 请求业务参数，必填
 }
 
 // MerchantApplyReqData 商户进件请求业务数据结构体
@@ -81,16 +81,17 @@ type FeeData struct {
 // FileData 附件集合结构体
 
 type FileData struct {
-	AttField string `json:"attField"` // 文件编号/附件上传后返回的编号，必填
+	AttFileId string `json:"attFileId"` // 文件编号/附件上传后返回的编号，必填
-	AttType  string `json:"attType"`  // 附件类型，必填
+	AttType   string `json:"attType"`   // 附件类型，必填
 }
 
 // MerchantApplyResponse 商户进件响应结构体
 
 type MerchantApplyResponse struct {
-	RetCode    string                 `json:"retCode"`    // 响应码，成功为"0000"，其他为错误码
+	RetCode    string                 `json:"retCode"`   // 响应码，成功为"0000"，其他为错误码
-	RetMsg     string                 `json:"retMsg"`     // 响应描述
+	RetMsg     string                 `json:"retMsg"`    // 响应描述
-	Timestamp  int64                  `json:"timestamp"`  // 响应描述
+	Timestamp  int64                  `json:"timestamp"` // 响应描述
+	Md         string                 `json:"md"`
 	Ver        string                 `json:"ver"`        // 响应描述
 	ReqId      string                 `json:"reqId"`      // 响应描述
 	CmdRetCode string                 `json:"cmdRetCode"` // 响应描述

model/queryMer.go

@@ -41,6 +41,8 @@ type QueryMerResponse struct {
 	RespData *QueryMerResponseData `json:"respData"`
 	// RetCode 返回码
 	RetCode string `json:"retCode"`
+	// md 随机字符串
+	Md string `json:"md"`
 	// RetMsg 返回消息
 	RetMsg string `json:"retMsg"`
 	// Timestamp 时间戳
@@ -52,8 +54,12 @@ type QueryMerResponse struct {
 // QueryMerResponseData 商户进件信息查询响应业务参数
 
 type QueryMerResponseData struct {
+	// OrgCode 机构代码
+	OrgCode string `json:"orgCode"`
 	// OrderNo 订单号
 	OrderNo string `json:"orderNo"`
+	// ContractId 进件ID
+	ContractId string `json:"contractId"`
 	// ContractStatus 进件状态
 	// 未提交：NO_COMMIT
 	// 已提交：COMMIT
@@ -63,16 +69,12 @@ type QueryMerResponseData struct {
 	// 审核通过：WAIT_FOR_CONTACT
 	// 审核驳回：INNER_CHECK_REJECTED
 	ContractStatus string `json:"contractStatus"`
-	// OrgCode 机构代码
-	OrgCode string `json:"orgCode"`
-	// ContractId 进件ID
-	ContractId string `json:"contractId"`
-	// MerInnerNo 拉卡拉内部商户号（该属性审核通过才有）
-	MerInnerNo string `json:"merInnerNo"`
 	// ContractMemo 进件描述
 	// 进件审核通过，返回"审核通过"
 	// 进件审核驳回，返回具体的驳回理由
 	ContractMemo string `json:"contractMemo"`
+	// MerInnerNo 拉卡拉内部商户号（该属性审核通过才有）
+	MerInnerNo string `json:"merInnerNo"`
 	// MerCupNo 银联商户号（该属性审核通过才有）
 	MerCupNo string `json:"merCupNo"`
 	// TermDatas 终端列表信息（该属性审核通过并且是增商、增终进件才有）

model/reConfSubmit.go

@@ -38,6 +38,10 @@ type ReConfSubmitResponse struct {
 	ReqId string `json:"reqId"`
 	// RetCode 返回码
 	RetCode string `json:"retCode"`
+	// md 随机字符串
+	Md string `json:"md"`
+	// RespData 响应业务参数
+	RespData *ReConfSubmitResponseData `json:"respData"`
 	// RetMsg 返回消息
 	RetMsg string `json:"retMsg"`
 	// Timestamp 时间戳
@@ -45,6 +49,12 @@ type ReConfSubmitResponse struct {
 	// Ver 版本号
 	Ver string `json:"ver"`
 }
+type ReConfSubmitResponseData struct {
+	// OrgCode 机构代码
+	OrgCode string `json:"orgCode"`
+	// OrderNo 订单号
+	OrderNo string `json:"orderNo"`
+}
 
 func (t *ReConfSubmitResponse) SuccessOrFail() bool {
 	return t.RetCode == "000000"