Merge branch 'menu' of https://github.com/black1552/lkl_sdk into menu

添加微支付交易模块的基础文件，包括api、请求和响应文件

README.md

@@ -6,45 +6,14 @@
 
 ```
 lklsdk/
-├── account.go          # 账户相关功能
+├── client.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            # 交易相关功能
-├── unifiedreturn/      # 统一退款功能
+├── account.go          # 账户相关功能
-│   ├── mergerefund/    # 合并退款
+├── merge_pre.go        # 主扫合单交易功能
-│   ├── refund/         # 退款
+├── sdk.go              # SDK主入口
-│   ├── refundfee/      # 退款手续费
+├── merchant.go         # 商户相关功能
-│   └── refundquery/    # 退款查询
 └── uploadFile.go       # 文件上传相关功能
 ```
 

basePay/dcp/transPreorder/api.go

@@ -0,0 +1,34 @@
+package transpreorder
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type TransPreorder struct {
+	client *common.Client[TransPreorderResponse]
+}
+
+func NewTransPreorderApi(client *common.Client[TransPreorderResponse]) *TransPreorder {
+	return &TransPreorder{client: client}
+}
+
+func (tp *TransPreorder) TransPreorder(reqData *TransPreorderRequestData) (*TransPreorderResponse, error) {
+	// 构建请求结构体
+	request := &TransPreorderRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+	return tp.client.DoRequest(consts.BASE_URL+consts.LKL_DCP_TRANS_PREORDER_URL, request)
+}
+func (tp *TransPreorder) TransPreorderTest(reqData *TransPreorderRequestData) (*TransPreorderResponse, error) {
+	// 构建请求结构体
+	request := &TransPreorderRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+	return tp.client.DoRequest(consts.BASE_TEST_URL+consts.LKL_DCP_TRANS_PREORDER_URL, request)
+}

basePay/dcp/transPreorder/request.go

@@ -0,0 +1,16 @@
+package transpreorder
+
+type TransPreorderRequest struct {
+	ReqTime string                    `json:"req_time"`
+	Version string                    `json:"version"`
+	ReqData *TransPreorderRequestData `json:"req_data"`
+}
+
+type TransPreorderRequestData struct {
+	OutTradeNo  string `json:"out_trade_no"`
+	TotalAmount string `json:"total_amount"`
+	Subject     string `json:"subject"`
+	Body        string `json:"body"`
+	NotifyUrl   string `json:"notify_url"`
+	ExpireTime  string `json:"expire_time"`
+}

basePay/dcp/transPreorder/response.go

@@ -0,0 +1,4 @@
+package transpreorder
+
+type TransPreorderResponse struct {
+}

basePay/labs/labs.go

@@ -0,0 +1,39 @@
+package labs
+
+import (
+	"context"
+
+	relationclose "github.com/black1552/lkl_sdk/basePay/labs/relationClose"
+	"github.com/black1552/lkl_sdk/basePay/labs/relationRefund"
+	"github.com/black1552/lkl_sdk/basePay/labs/relationRevoked"
+	transmicropay "github.com/black1552/lkl_sdk/basePay/labs/transMicropay"
+	"github.com/black1552/lkl_sdk/basePay/labs/transMicropayEncry"
+	"github.com/black1552/lkl_sdk/basePay/labs/transPreorder"
+	"github.com/black1552/lkl_sdk/basePay/labs/transPreorederEncry"
+	transquery "github.com/black1552/lkl_sdk/basePay/labs/transQuery"
+	"github.com/black1552/lkl_sdk/common"
+)
+
+type Labs struct {
+	RelationClose      *relationclose.RelationCloseServer
+	RelationRefund     *relationRefund.RelationRefundServer
+	RelationRevoked    *relationRevoked.RelationRevokedServer
+	TransMicropay      *transmicropay.TransMicropayServer
+	TransMicropayEncry *transMicropayEncry.TransMicropayEncryServer
+	TransPreorder      *transPreorder.TransPreorderServer
+	TransPreorderEncry *transPreorederEncry.TransPreorderEncryServer
+	TransQuery         *transquery.TransQueryServer
+}
+
+func NewLabs(ctx context.Context, cfgJson string) *Labs {
+	return &Labs{
+		RelationClose:      relationclose.NewRelationCloseServer(common.NewClient[relationclose.RelationCloseResponse](ctx, cfgJson)),
+		RelationRefund:     relationRefund.NewRelationRefundServer(common.NewClient[relationRefund.RelationRefundResponse](ctx, cfgJson)),
+		RelationRevoked:    relationRevoked.NewRelationRevokedServer(common.NewClient[relationRevoked.RelationRevokedResponse](ctx, cfgJson)),
+		TransMicropay:      transmicropay.NewTransMicropayServer(common.NewClient[transmicropay.TransMicropayResponse](ctx, cfgJson)),
+		TransMicropayEncry: transMicropayEncry.NewTransMicropayEncryServer(common.NewClient[transMicropayEncry.TransMicropayEncryResponse](ctx, cfgJson)),
+		TransPreorder:      transPreorder.NewTransPreorderServer(common.NewClient[transPreorder.TransPreorderResponse](ctx, cfgJson)),
+		TransPreorderEncry: transPreorederEncry.NewTransPreorderEncryServer(common.NewClient[transPreorederEncry.TransPreorederEncryResponse](ctx, cfgJson)),
+		TransQuery:         transquery.NewTransQueryServer(common.NewClient[transquery.TransQueryResponse](ctx, cfgJson)),
+	}
+}

basePay/labs/relationClose/api.go

@@ -0,0 +1,51 @@
+package relationclose
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// RelationCloseServer 聚合扫码关单API结构体
+type RelationCloseServer struct {
+	Client *common.Client[RelationCloseResponse]
+}
+
+// NewAPI 创建聚合扫码关单API实例
+func NewRelationCloseServer(client *common.Client[RelationCloseResponse]) *RelationCloseServer {
+	return &RelationCloseServer{
+		Client: client,
+	}
+}
+
+// RelationClose 执行聚合扫码关单请求
+// - merchantNo: 商户号
+// - termNo: 终端号
+// - 原交易标识：originOutTradeNo、originTradeNo、(originOutOrderSource+originOutOrderNo) 三者必选其一
+// - locationInfo: 地址位置信息（风控要求必送）
+func (a *RelationCloseServer) RelationClose(reqData *RelationCloseRequestData) (*RelationCloseResponse, error) {
+	// 构建请求结构体
+	request := &RelationCloseRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+	// 发送请求 - 使用consts中定义的聚合扫码关单URL
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_RELATION_CLOSE_URL, request)
+}
+
+// RelationCloseTest 执行聚合扫码关单测试请求
+// - merchantNo: 商户号
+// - termNo: 终端号
+// - 原交易标识：originOutTradeNo、originTradeNo、(originOutOrderSource+originOutOrderNo) 三者必选其一
+// - locationInfo: 地址位置信息（风控要求必送）
+func (a *RelationCloseServer) RelationCloseTest(reqData *RelationCloseRequestData) (*RelationCloseResponse, error) {
+	// 构建请求结构体
+	request := &RelationCloseRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+	// 发送请求 - 使用consts中定义的聚合扫码关单URL
+	return a.Client.DoRequest(consts.BASE_TEST_URL+consts.LKL_BASE_URL_RELATION_CLOSE_URL, request)
+}

basePay/labs/relationClose/request.go

@@ -0,0 +1,26 @@
+package relationclose
+
+// LocationInfo 地址位置信息结构体
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`             // 请求方IP地址 (必填)
+	BaseStation string `json:"base_station,omitempty"` // 基站信息 (可选)
+	Location    string `json:"location,omitempty"`     // 纬度,经度 (可选)
+}
+
+// RelationCloseRequestData 聚合扫码关单请求数据结构体
+type RelationCloseRequestData struct {
+	MerchantNo           string        `json:"merchant_no" dc:"商户号 (必填)"`                             // 商户号 (必填)
+	TermNo               string        `json:"term_no" dc:"终端号 (必填)"`                                 // 终端号 (必填)
+	OriginOutTradeNo     string        `json:"origin_out_trade_no,omitempty" dc:"原商户交易流水号 (可选)"`      // 原商户交易流水号 (可选)
+	OriginTradeNo        string        `json:"origin_trade_no,omitempty" dc:"原交易拉卡拉交易流水号 (可选)"`       // 原交易拉卡拉交易流水号 (可选)
+	OriginOutOrderSource string        `json:"origin_out_order_source,omitempty" dc:"原订单外部订单来源 (可选)"` // 原订单外部订单来源 (可选)
+	OriginOutOrderNo     string        `json:"origin_out_order_no,omitempty" dc:"原订单外部商户订单号 (可选)"`    // 原订单外部商户订单号 (可选)
+	LocationInfo         *LocationInfo `json:"location_info" dc:"地址位置信息 (必填)"`                        // 地址位置信息 (必填)
+}
+
+// RelationCloseRequest 聚合扫码关单请求结构体
+type RelationCloseRequest struct {
+	ReqTime string                    `json:"req_time"`
+	Version string                    `json:"version"`
+	ReqData *RelationCloseRequestData `json:"req_data"`
+}

basePay/labs/relationClose/response.go

@@ -0,0 +1,23 @@
+package relationclose
+
+// RelationCloseResponseData 聚合扫码关单响应数据结构体
+type RelationCloseResponseData struct {
+	OriginTradeNo        string `json:"origin_trade_no"`                   // 原拉卡拉订单号
+	OriginOutTradeNo     string `json:"origin_out_trade_no"`               // 原商户请求流水号
+	OriginOutOrderSource string `json:"origin_out_order_source,omitempty"` // 原订单外部订单来源
+	OriginOutOrderNo     string `json:"origin_out_order_no,omitempty"`     // 原订单外部商户订单号
+	TradeTime            string `json:"trade_time"`                        // 交易时间
+}
+
+// RelationCloseResponse 聚合扫码关单响应结构体
+type RelationCloseResponse struct {
+	RespTime string                     `json:"resp_time"`
+	Code     string                     `json:"code"`
+	Msg      string                     `json:"msg"`
+	RespData *RelationCloseResponseData `json:"resp_data,omitempty"`
+}
+
+// SuccessOrFail 判断响应是否成功
+func (r *RelationCloseResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

basePay/labs/relationRefund/api.go

@@ -0,0 +1,33 @@
+package relationRefund
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// RelationRefundServer 聚合扫码退款API结构体
+type RelationRefundServer struct {
+	Client *common.Client[RelationRefundResponse]
+}
+
+// NewRelationRefundServer 创建聚合扫码退款API实例
+func NewRelationRefundServer(client *common.Client[RelationRefundResponse]) *RelationRefundServer {
+	return &RelationRefundServer{
+		Client: client,
+	}
+}
+
+// RelationRefund 聚合扫码退款方法
+// - reqData: 退款请求数据
+func (a *RelationRefundServer) RelationRefund(reqData *RelationRefundRequestData) (*RelationRefundResponse, error) {
+	// 构建请求结构体
+	request := &RelationRefundRequest{
+		ReqTime: gtime.Now().Format("20060102150405"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+
+	// 调用Client发送请求
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_RELATION_REFUND_URL, request)
+}

basePay/labs/relationRefund/request.go

@@ -0,0 +1,29 @@
+package relationRefund
+
+// LocationInfo 地址位置信息结构体
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`             // 请求方IP地址，必填
+	BaseStation string `json:"base_station,omitempty"` // 基站信息，可选
+	Location    string `json:"location,omitempty"`     // 维度,经度，可选
+}
+
+// RelationRefundRequestData 聚合扫码退款请求数据结构体
+type RelationRefundRequestData struct {
+	MerchantNo       string       `json:"merchant_no"`                   // 商户号，必填
+	TermNo           string       `json:"term_no"`                       // 终端号，必填
+	OutTradeNo       string       `json:"out_trade_no"`                  // 商户交易流水号，必填
+	RefundAmount     string       `json:"refund_amount"`                 // 退款金额，必填
+	RefundReason     string       `json:"refund_reason"`                 // 退款原因，必填
+	OriginOutTradeNo string       `json:"origin_out_trade_no,omitempty"` // 原商户交易流水号，可选（退款时origin_out_trade_no，origin_trade_no，origin_log_no必送其一）
+	OriginTradeNo    string       `json:"origin_trade_no,omitempty"`     // 原拉卡拉交易流水号，可选
+	OriginLogNo      string       `json:"origin_log_no,omitempty"`       // 原对账单流水号，可选
+	TradeReqDate     string       `json:"trade_req_date,omitempty"`      // 交易请求日期，可选（送原商户交易流水号退款时必填）
+	LocationInfo     LocationInfo `json:"location_info"`                 // 地址位置信息，必填
+}
+
+// RelationRefundRequest 聚合扫码退款请求结构体
+type RelationRefundRequest struct {
+	ReqTime string                     `json:"req_time"`
+	Version string                     `json:"version"`
+	ReqData *RelationRefundRequestData `json:"req_data"`
+}

basePay/labs/relationRefund/response.go

@@ -0,0 +1,34 @@
+package relationRefund
+
+// RelationRefundResponseData 聚合扫码退款响应数据结构体
+type RelationRefundResponseData struct {
+	MerchantNo       string `json:"merchant_no"`                   // 商户号
+	OutTradeNo       string `json:"out_trade_no"`                  // 商户请求流水号
+	TradeNo          string `json:"trade_no"`                      // 拉卡拉退款单号
+	LogNo            string `json:"log_no"`                        // 拉卡拉对账单流水号
+	AccTradeNo       string `json:"acc_trade_no,omitempty"`        // 账户端交易订单号
+	AccountType      string `json:"account_type,omitempty"`        // 钱包类型
+	TotalAmount      string `json:"total_amount"`                  // 交易金额
+	RefundAmount     string `json:"refund_amount"`                 // 申请退款金额
+	PayerAmount      string `json:"payer_amount"`                  // 实际退款金额
+	TradeTime        string `json:"trade_time,omitempty"`          // 退款时间
+	OriginTradeNo    string `json:"origin_trade_no,omitempty"`     // 原拉卡拉订单号
+	OriginOutTradeNo string `json:"origin_out_trade_no,omitempty"` // 原商户请求流水号
+	UpIssAddnData    string `json:"up_iss_addn_data,omitempty"`    // 单品营销附加数据
+	UpCouponInfo     string `json:"up_coupon_info,omitempty"`      // 银联优惠信息、出资方信息
+	TradeInfo        string `json:"trade_info,omitempty"`          // 出资方信息
+	FundBillList     string `json:"fund_bill_list,omitempty"`      // 交易支付使用的资金渠道
+}
+
+// RelationRefundResponse 聚合扫码退款响应结构体
+type RelationRefundResponse struct {
+	Code     string                      `json:"code"`
+	Msg      string                      `json:"msg"`
+	RespTime string                      `json:"resp_time"`
+	RespData *RelationRefundResponseData `json:"resp_data,omitempty"`
+}
+
+// SuccessOrFail 判断响应是否成功
+func (r *RelationRefundResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

basePay/labs/relationRevoked/api.go

@@ -0,0 +1,33 @@
+package relationRevoked
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// RelationRevokedServer 聚合扫码撤销API结构体
+type RelationRevokedServer struct {
+	Client *common.Client[RelationRevokedResponse]
+}
+
+// NewRelationRevokedServer 创建聚合扫码撤销API实例
+func NewRelationRevokedServer(client *common.Client[RelationRevokedResponse]) *RelationRevokedServer {
+	return &RelationRevokedServer{
+		Client: client,
+	}
+}
+
+// RelationRevoked 聚合扫码撤销方法
+// - reqData: 撤销请求数据
+func (a *RelationRevokedServer) RelationRevoked(reqData *RelationRevokedRequestData) (*RelationRevokedResponse, error) {
+	// 构建请求结构体
+	request := &RelationRevokedRequest{
+		ReqTime: gtime.Now().Format("20060102150405"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+
+	// 调用Client发送请求
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_RELATION_REVOKED_URL, request)
+}

basePay/labs/relationRevoked/request.go

@@ -0,0 +1,25 @@
+package relationRevoked
+
+// LocationInfo 地址位置信息结构体
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`             // 请求方IP地址，必填
+	BaseStation string `json:"base_station,omitempty"` // 基站信息，可选
+	Location    string `json:"location,omitempty"`     // 维度,经度，可选
+}
+
+// RelationRevokedRequestData 聚合扫码撤销请求数据结构体
+type RelationRevokedRequestData struct {
+	MerchantNo       string       `json:"merchant_no"`                   // 商户号，必填
+	TermNo           string       `json:"term_no"`                       // 终端号，必填
+	OutTradeNo       string       `json:"out_trade_no"`                  // 商户交易流水号，必填
+	OriginOutTradeNo string       `json:"origin_out_trade_no,omitempty"` // 原商户交易流水号，可选（撤销时origin_out_trade_no，origin_trade_no必送其一）
+	OriginTradeNo    string       `json:"origin_trade_no,omitempty"`     // 原拉卡拉交易流水号，可选（撤销时origin_out_trade_no，origin_trade_no必送其一）
+	LocationInfo     LocationInfo `json:"location_info"`                 // 地址位置信息，必填
+}
+
+// RelationRevokedRequest 聚合扫码关单请求结构体
+type RelationRevokedRequest struct {
+	ReqTime string                      `json:"req_time"`
+	Version string                      `json:"version"`
+	ReqData *RelationRevokedRequestData `json:"req_data"`
+}

basePay/labs/relationRevoked/response.go

@@ -0,0 +1,28 @@
+package relationRevoked
+
+// RelationRevokedResponseData 聚合扫码撤销响应数据结构体
+type RelationRevokedResponseData struct {
+	MerchantNo       string `json:"merchant_no"`                   // 商户号
+	OutTradeNo       string `json:"out_trade_no"`                  // 商户请求流水号
+	TradeNo          string `json:"trade_no,omitempty"`            // 拉卡拉商户订单号
+	LogNo            string `json:"log_no"`                        // 拉卡拉对账单流水号
+	AccTradeNo       string `json:"acc_trade_no,omitempty"`        // 账户端交易订单号
+	AccountType      string `json:"account_type"`                  // 钱包类型
+	TotalAmount      string `json:"total_amount"`                  // 交易金额
+	TradeTime        string `json:"trade_time"`                    // 交易完成时间
+	OriginOutTradeNo string `json:"origin_out_trade_no,omitempty"` // 原商户请求流水号
+	OriginTradeNo    string `json:"origin_trade_no,omitempty"`     // 原拉卡拉交易流水号
+}
+
+// RelationRevokedResponse 聚合扫码撤销响应结构体
+type RelationRevokedResponse struct {
+	Code     string                      `json:"code"`                // 响应码
+	Msg      string                      `json:"msg"`                 // 响应信息
+	RespTime string                      `json:"resp_time"`           // 响应时间
+	RespData RelationRevokedResponseData `json:"resp_data,omitempty"` // 响应数据
+}
+
+// SuccessOrFail 判断响应是否成功
+func (r *RelationRevokedResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

basePay/labs/transMicropay/api.go

@@ -0,0 +1,39 @@
+package transmicropay
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// API 聚合被扫API结构体
+type TransMicropayServer struct {
+	Client *common.Client[TransMicropayResponse]
+}
+
+// NewAPI 创建聚合被扫API实例
+func NewTransMicropayServer(client *common.Client[TransMicropayResponse]) *TransMicropayServer {
+	return &TransMicropayServer{
+		Client: client,
+	}
+}
+
+// TransMicropay 执行聚合被扫请求
+// - merchantNo: 商户号
+// - termNo: 终端号
+// - outTradeNo: 商户交易流水号
+// - authCode: 支付授权码
+// - totalAmount: 金额
+// - locationInfo: 地址位置信息
+// - 其他可选参数通过TransMicropayRequestData的其他字段设置
+func (a *TransMicropayServer) TransMicropay(reqData *TransMicropayRequestData) (*TransMicropayResponse, error) {
+	// 构建请求结构体
+	request := &TransMicropayRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+
+	// 发送请求 - 使用consts中定义的聚合被扫URL
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_TRANS_MICROPAY_URL, request)
+}

basePay/labs/transMicropay/request.go

@@ -0,0 +1,56 @@
+package transmicropay
+
+// LocationInfo 地址位置信息结构体
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`             // 请求方IP地址 (必填)
+	BaseStation string `json:"base_station,omitempty"` // 基站信息 (可选)
+	Location    string `json:"location,omitempty"`     // 纬度,经度 (银联二维码交易必填)
+}
+
+// GoodsInfo 商品信息结构体
+type GoodsInfo struct {
+	GoodsId    string `json:"goods_id,omitempty"`    // 商品ID (可选)
+	GoodsName  string `json:"goods_name,omitempty"`  // 商品名称 (可选)
+	Price      string `json:"price,omitempty"`       // 商品单价 (可选)
+	Quantity   string `json:"quantity,omitempty"`    // 商品数量 (可选)
+	CategoryId string `json:"category_id,omitempty"` // 商品类目ID (可选)
+	Body       string `json:"body,omitempty"`        // 商品描述 (可选)
+}
+
+// AccBusiFields 账户端业务信息域结构体
+type AccBusiFields struct {
+	ExtendParams       string `json:"extend_params,omitempty"`        // 业务扩展参数 (可选)
+	GoodsDetail        string `json:"goods_detail,omitempty"`         // 商品详情 (可选)
+	StoreId            string `json:"store_id,omitempty"`             // 商户门店编号 (可选)
+	AlipayStoreId      string `json:"alipay_store_id,omitempty"`      // 支付宝店铺编号 (不再使用)
+	TimeoutExpress     string `json:"timeout_express,omitempty"`      // 交易有效时间 (可选)
+	DisablePayChannels string `json:"disable_pay_channels,omitempty"` // 支付宝禁用支付渠道 (可选)
+	BusinessParams     string `json:"business_params,omitempty"`      // 商户传入业务信息 (可选)
+	MinAge             string `json:"min_age,omitempty"`              // 允许的最小买家年龄 (可选)
+	PromoParams        string `json:"promo_params,omitempty"`         // 优惠明细 (可选)
+}
+
+// TransMicropayRequestData 聚合被扫请求数据结构体
+type TransMicropayRequestData struct {
+	MerchantNo    string         `json:"merchant_no"`               // 商户号 (必填)
+	TermNo        string         `json:"term_no"`                   // 终端号 (必填)
+	OutTradeNo    string         `json:"out_trade_no"`              // 商户交易流水号 (必填)
+	AuthCode      string         `json:"auth_code"`                 // 支付授权码 (必填)
+	TotalAmount   string         `json:"total_amount"`              // 金额 (必填)
+	LocationInfo  *LocationInfo  `json:"location_info"`             // 地址位置信息 (必填)
+	BusiMode      string         `json:"busi_mode,omitempty"`       // 业务模式 (可选)
+	Subject       string         `json:"subject,omitempty"`         // 订单标题 (可选，微信支付必送)
+	PayOrderNo    string         `json:"pay_order_no,omitempty"`    // 支付业务订单号 (可选)
+	NotifyURL     string         `json:"notify_url,omitempty"`      // 商户通知地址 (可选)
+	SettleType    string         `json:"settle_type,omitempty"`     // 结算类型 (可选)
+	Remark        string         `json:"remark,omitempty"`          // 备注 (可选)
+	ScanType      string         `json:"scan_type,omitempty"`       // 扫码类型 (可选)
+	AccBusiFields *AccBusiFields `json:"acc_busi_fields,omitempty"` // 账户端业务信息域 (可选)
+}
+
+// TransMicropayRequest 聚合被扫请求结构体
+type TransMicropayRequest struct {
+	ReqTime string                    `json:"req_time"`
+	Version string                    `json:"version"`
+	ReqData *TransMicropayRequestData `json:"req_data"`
+}

basePay/labs/transMicropay/response.go

@@ -0,0 +1,31 @@
+package transmicropay
+
+// TransMicropayResponseData 聚合被扫响应数据结构体
+type TransMicropayResponseData struct {
+	MerchantNo     string `json:"merchant_no"`                // 商户号
+	TermNo         string `json:"term_no"`                    // 终端号
+	OutTradeNo     string `json:"out_trade_no"`               // 商户交易流水号
+	TradeNo        string `json:"trade_no"`                   // 拉卡拉交易流水号
+	LogNo          string `json:"log_no"`                     // 拉卡拉对账单流水号
+	TotalAmount    string `json:"total_amount"`               // 交易总金额
+	TradeTime      string `json:"trade_time"`                 // 交易时间
+	PayStatus      string `json:"pay_status"`                 // 支付状态
+	OrderDesc      string `json:"order_desc,omitempty"`       // 订单描述
+	PayAmount      string `json:"pay_amount,omitempty"`       // 实际支付金额
+	PayChannel     string `json:"pay_channel,omitempty"`      // 支付渠道
+	ChannelTradeNo string `json:"channel_trade_no,omitempty"` // 渠道交易号
+	AuthCode       string `json:"auth_code,omitempty"`        // 支付授权码
+}
+
+// TransMicropayResponse 聚合被扫响应结构体
+type TransMicropayResponse struct {
+	RespTime string                     `json:"resp_time"`
+	Code     string                     `json:"code"`
+	Msg      string                     `json:"msg"`
+	RespData *TransMicropayResponseData `json:"resp_data,omitempty"`
+}
+
+// SuccessOrFail 判断响应是否成功
+func (r *TransMicropayResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

basePay/labs/transMicropayEncry/api.go

@@ -0,0 +1,32 @@
+package transMicropayEncry
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// TransMicropayEncryServer 聚合扫码被扫接口（全报文加密）服务结构体
+type TransMicropayEncryServer struct {
+	Client *common.Client[TransMicropayEncryResponse]
+}
+
+// NewTransMicropayEncryServer 创建聚合扫码被扫接口（全报文加密）服务实例
+func NewTransMicropayEncryServer(client *common.Client[TransMicropayEncryResponse]) *TransMicropayEncryServer {
+	return &TransMicropayEncryServer{
+		Client: client,
+	}
+}
+
+// TransMicropayEncry 聚合扫码被扫接口（全报文加密）接口
+func (a *TransMicropayEncryServer) TransMicropayEncry(reqData *TransMicropayEncryRequestData) (*TransMicropayEncryResponse, error) {
+	// 构建请求体
+	request := &TransMicropayEncryRequest{
+		ReqTime: gtime.Now().Format("20060102150405"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+
+	// 调用Client发送请求
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_TRANS_MICROPAY_ENCRY_URL, request)
+}

basePay/labs/transMicropayEncry/request.go

@@ -0,0 +1,46 @@
+package transMicropayEncry
+
+// LocationInfo 地址位置信息，风控要求必送
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`   // 请求方IP地址，必填
+	BaseStation string `json:"base_station"` // 客户端设备的基站信息
+	Location    string `json:"location"`     // 商户终端的地理位置，整体格式：纬度,经度
+}
+
+// AccBusiFields 账户端业务信息域
+type AccBusiFields struct {
+	ExtendParams       map[string]interface{} `json:"extend_params"`        // 支付宝业务扩展参数，主要用于花呗分期
+	BusinessParams     string                 `json:"business_params"`      // 商户传入业务信息
+	GoodsDetail        string                 `json:"goods_detail"`         // 订单包含的商品列表信息，Json数组
+	StoreID            string                 `json:"store_id"`             // 商户门店编号
+	TimeoutExpress     string                 `json:"timeout_express"`      // 交易有效时间，以分钟为单位
+	DisablePayChannels string                 `json:"disable_pay_channels"` // 支付宝禁用支付渠道
+	MinAge             string                 `json:"min_age"`              // 允许的最小买家年龄
+	PriorityPayAssets  map[string]interface{} `json:"priority_pay_assets"`  // 优先使用资产
+}
+
+// TransMicropayEncryRequestData 聚合扫码被扫接口（全报文加密）请求数据
+type TransMicropayEncryRequestData struct {
+	MerchantNo    string        `json:"merchant_no"`     // 商户号，必填
+	TermNo        string        `json:"term_no"`         // 终端号，必填
+	OutTradeNo    string        `json:"out_trade_no"`    // 商户交易流水号，必填
+	AuthCode      string        `json:"auth_code"`       // 支付授权码，必填
+	TotalAmount   string        `json:"total_amount"`    // 金额，必填，单位分，整数型字符
+	LocationInfo  LocationInfo  `json:"location_info"`   // 地址位置信息，必填
+	BusiMode      string        `json:"busi_mode"`       // 业务模式，可选：ACQ-收单，不填默认为"ACQ-收单"
+	Subject       string        `json:"subject"`         // 订单标题，可选，微信支付必送
+	PayOrderNo    string        `json:"pay_order_no"`    // 拉卡拉支付业务订单号，可选
+	NotifyURL     string        `json:"notify_url"`      // 商户通知地址，可选
+	SettleType    string        `json:"settle_type"`     // 结算类型，可选："0"或者空，常规结算方式
+	Remark        string        `json:"remark"`          // 备注，可选
+	ScanType      string        `json:"scan_type"`       // 扫码类型，可选：0或不填：扫码支付，1：支付宝刷脸支付，2: 微信刷脸支付
+	IdentityInfo  string        `json:"identity_info"`   // 实名支付信息，可选，json字符串
+	AccBusiFields AccBusiFields `json:"acc_busi_fields"` // 账户端业务信息域，可选
+}
+
+// TransMicropayEncryRequest 聚合扫码被扫接口（全报文加密）请求结构
+type TransMicropayEncryRequest struct {
+	ReqTime string                         `json:"req_time"` // 请求时间
+	Version string                         `json:"version"`  // 版本号
+	ReqData *TransMicropayEncryRequestData `json:"req_data"` // 请求数据
+}

basePay/labs/transMicropayEncry/response.go

@@ -0,0 +1,27 @@
+package transMicropayEncry
+
+// TransMicropayEncryResponseData 聚合扫码被扫接口（全报文加密）响应数据
+type TransMicropayEncryResponseData struct {
+	MerchantNo  string `json:"merchant_no"`  // 商户号
+	TermNo      string `json:"term_no"`      // 终端号
+	OutTradeNo  string `json:"out_trade_no"` // 商户交易流水号
+	TotalAmount string `json:"total_amount"` // 金额，单位分
+	PayOrderNo  string `json:"pay_order_no"` // 拉卡拉订单系统订单号
+	TradeType   string `json:"trade_type"`   // 交易类型
+	Status      string `json:"status"`       // 交易状态
+	PayTime     string `json:"pay_time"`     // 支付完成时间
+}
+
+// TransMicropayEncryResponse 聚合扫码被扫接口（全报文加密）响应结构
+type TransMicropayEncryResponse struct {
+	RespTime string                          `json:"resp_time"` // 响应时间
+	Version  string                          `json:"version"`   // 版本号
+	Code     string                          `json:"code"`      // 响应码
+	Msg      string                          `json:"msg"`       // 响应信息
+	RespData *TransMicropayEncryResponseData `json:"resp_data"` // 响应数据
+}
+
+// SuccessOrFail 判断响应是否成功
+func (r *TransMicropayEncryResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

basePay/labs/transPreorder/api.go

@@ -0,0 +1,32 @@
+package transPreorder
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// TransPreorderServer 聚合主扫API结构体
+type TransPreorderServer struct {
+	client *common.Client[TransPreorderResponse]
+}
+
+// NewTransPreorderServer 创建聚合主扫API实例
+func NewTransPreorderServer(client *common.Client[TransPreorderResponse]) *TransPreorderServer {
+	return &TransPreorderServer{
+		client: client,
+	}
+}
+
+// TransPreorder 执行聚合主扫交易
+func (a *TransPreorderServer) TransPreorder(req *TransPreorderRequestData) (*TransPreorderResponse, error) {
+	// 构建BaseModel请求
+	baseReq := TransPreorderRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: req,
+	}
+
+	// 发送请求
+	return a.client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_TRANS_PREORDER_URL, baseReq)
+}

basePay/labs/transPreorder/request.go

@@ -0,0 +1,59 @@
+package transPreorder
+
+// LocationInfo 地址位置信息结构体
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`             // 请求方IP地址 (必填)
+	BaseStation string `json:"base_station,omitempty"` // 基站信息 (可选)
+	Location    string `json:"location,omitempty"`     // 纬度,经度 (可选，银联二维码交易必填)
+}
+
+// GoodsInfo 商品信息结构体
+type GoodsInfo struct {
+	GoodsId    string `json:"goods_id,omitempty"`    // 商品ID (可选)
+	GoodsName  string `json:"goods_name,omitempty"`  // 商品名称 (可选)
+	Price      string `json:"price,omitempty"`       // 商品单价 (可选)
+	Quantity   string `json:"quantity,omitempty"`    // 商品数量 (可选)
+	CategoryId string `json:"category_id,omitempty"` // 商品类目ID (可选)
+	Body       string `json:"body,omitempty"`        // 商品描述 (可选)
+}
+
+// AccBusiFields 账户端业务信息域结构体
+type AccBusiFields struct {
+	UserId            string `json:"user_id,omitempty"`             // 买家在支付宝的用户id (支付宝JSAPI支付必填)
+	TimeoutExpress    string `json:"timeout_express,omitempty"`     // 预下单有效时间 (可选)
+	ExtendParams      string `json:"extend_params,omitempty"`       // 业务扩展参数 (可选)
+	GoodsDetail       string `json:"goods_detail,omitempty"`        // 商品详情 (可选)
+	StoreId           string `json:"store_id,omitempty"`            // 商户门店编号 (可选)
+	BusinessParams    string `json:"business_params,omitempty"`     // 商户传入业务信息 (可选)
+	MinAge            string `json:"min_age,omitempty"`             // 允许的最小买家年龄 (可选)
+	PromoParams       string `json:"promo_params,omitempty"`        // 优惠明细 (可选)
+	EnablePayChannels string `json:"enable_pay_channels,omitempty"` // 支付通道 (可选)
+}
+
+// TransPreorderRequestData 预订单请求数据结构体
+type TransPreorderRequestData struct {
+	MerchantNo        string         `json:"merchant_no"`                   // 商户号 (必填)
+	TermNo            string         `json:"term_no"`                       // 终端号 (必填)
+	OutTradeNo        string         `json:"out_trade_no"`                  // 商户交易流水号 (必填)
+	AccountType       string         `json:"account_type"`                  // 钱包类型 (必填)
+	TransType         string         `json:"trans_type"`                    // 接入方式 (必填)
+	TotalAmount       string         `json:"total_amount"`                  // 金额 (必填)
+	LocationInfo      *LocationInfo  `json:"location_info"`                 // 地址位置信息 (必填)
+	BusiMode          string         `json:"busi_mode,omitempty"`           // 业务模式 (可选)
+	Subject           string         `json:"subject,omitempty"`             // 订单标题 (可选，微信支付必送)
+	PayOrderNo        string         `json:"pay_order_no,omitempty"`        // 支付业务订单号 (可选)
+	NotifyURL         string         `json:"notify_url,omitempty"`          // 商户通知地址 (可选)
+	SettleType        string         `json:"settle_type,omitempty"`         // 结算类型 (可选)
+	Remark            string         `json:"remark,omitempty"`              // 备注 (可选)
+	AccBusiFields     *AccBusiFields `json:"acc_busi_fields,omitempty"`     // 账户端业务信息域 (可选)
+	CompleteNotifyURL string         `json:"complete_notify_url,omitempty"` // 发货确认通知地址 (可选)
+	GoodsTag          string         `json:"goods_tag,omitempty"`           // 商品标签 (可选)
+	GoodsInfo         []*GoodsInfo   `json:"goods_info,omitempty"`          // 商品信息 (可选)
+}
+
+// TransPreorderRequest 预订单请求结构体
+type TransPreorderRequest struct {
+	ReqTime string                    `json:"req_time"`
+	Version string                    `json:"version"`
+	ReqData *TransPreorderRequestData `json:"req_data"`
+}

basePay/labs/transPreorder/response.go

@@ -0,0 +1,36 @@
+package transPreorder
+
+// ResponseData 聚合主扫响应数据结构体
+type ResponseData struct {
+	MerchantNo     string `json:"merchant_no"`                // 商户号
+	TermNo         string `json:"term_no"`                    // 终端号
+	OutTradeNo     string `json:"out_trade_no"`               // 商户交易流水号
+	TradeNo        string `json:"trade_no"`                   // 拉卡拉交易流水号
+	LogNo          string `json:"log_no"`                     // 拉卡拉对账单流水号
+	TotalAmount    string `json:"total_amount"`               // 交易总金额
+	TradeTime      string `json:"trade_time"`                 // 交易时间
+	PayStatus      string `json:"pay_status"`                 // 支付状态
+	OrderDesc      string `json:"order_desc,omitempty"`       // 订单描述
+	PayAmount      string `json:"pay_amount,omitempty"`       // 实际支付金额
+	PayChannel     string `json:"pay_channel,omitempty"`      // 支付渠道
+	ChannelTradeNo string `json:"channel_trade_no,omitempty"` // 渠道交易号
+	QrCode         string `json:"qr_code,omitempty"`          // 支付二维码内容 (NATIVE支付时返回)
+	CodeURL        string `json:"code_url,omitempty"`         // 二维码链接 (NATIVE支付时返回)
+	PayParams      string `json:"pay_params,omitempty"`       // 支付参数 (JSAPI/APP支付时返回)
+	AppId          string `json:"app_id,omitempty"`           // 应用ID
+	MchId          string `json:"mch_id,omitempty"`           // 商户号
+	PrepayId       string `json:"prepay_id,omitempty"`        // 预支付交易会话ID
+}
+
+// TransPreorderResponse 预订单响应结构体
+type TransPreorderResponse struct {
+	RespTime string        `json:"resp_time"`
+	Code     string        `json:"code"`
+	Msg      string        `json:"msg"`
+	RespData *ResponseData `json:"resp_data,omitempty"`
+}
+
+// SuccessOrFail 判断响应是否成功
+func (r *TransPreorderResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

basePay/labs/transPreorederEncry/api.go

@@ -0,0 +1,32 @@
+package transPreorederEncry
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// TransPreorderEncryServer 聚合扫码主扫交易（全报文加密）服务结构体
+type TransPreorderEncryServer struct {
+	Client *common.Client[TransPreorederEncryResponse]
+}
+
+// NewTransPreorderEncryServer 创建聚合扫码主扫交易（全报文加密）服务实例
+func NewTransPreorderEncryServer(client *common.Client[TransPreorederEncryResponse]) *TransPreorderEncryServer {
+	return &TransPreorderEncryServer{
+		Client: client,
+	}
+}
+
+// TransPreorderEncry 聚合扫码主扫交易（全报文加密）接口
+func (a *TransPreorderEncryServer) TransPreorderEncry(reqData *TransPreorederEncryRequestData) (*TransPreorederEncryResponse, error) {
+	// 构建请求体
+	request := &TransPreorederEncryRequest{
+		ReqTime: gtime.Now().Format("20060102150405"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+
+	// 调用Client发送请求
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_TRANS_PREORDER_ENCRY_URL, request)
+}

basePay/labs/transPreorederEncry/request.go

@@ -0,0 +1,46 @@
+package transPreorederEncry
+
+// LocationInfo 地址位置信息，风控要求必送
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`   // 请求方IP地址，必填
+	BaseStation string `json:"base_station"` // 客户端设备的基站信息（主扫时基站信息使用该字段）
+	Location    string `json:"location"`     // 商户终端的地理位置，整体格式：纬度,经度
+}
+
+// AccBusiFields 账户端业务信息域
+type AccBusiFields struct {
+	UserID             string                 `json:"user_id"`              // 买家在支付宝的用户id
+	TimeoutExpress     string                 `json:"timeout_express"`      // 预下单有效时间，以分钟为单位
+	ExtendParams       map[string]interface{} `json:"extend_params"`        // 支付宝业务扩展参数
+	GoodsDetail        string                 `json:"goods_detail"`         // 订单包含的商品列表信息，Json数组
+	StoreID            string                 `json:"store_id"`             // 商户门店编号
+	DisablePayChannels string                 `json:"disable_pay_channels"` // 支付宝禁用支付渠道
+	BusinessParams     string                 `json:"business_params"`      // 商户传入业务信息
+	MinAge             string                 `json:"min_age"`              // 允许的最小买家年龄
+}
+
+// RequestData 聚合扫码主扫交易（全报文加密）请求数据
+type TransPreorederEncryRequestData struct {
+	MerchantNo    string         `json:"merchant_no"`     // 商户号，必填
+	TermNo        string         `json:"term_no"`         // 终端号，必填
+	OutTradeNo    string         `json:"out_trade_no"`    // 商户交易流水号，必填
+	AccountType   string         `json:"account_type"`    // 钱包类型，必填：WECHAT、ALIPAY、UQRCODEPAY等
+	TransType     string         `json:"trans_type"`      // 接入方式，必填：41:NATIVE、51:JSAPI、71:微信小程序支付、61:APP支付
+	TotalAmount   string         `json:"total_amount"`    // 金额，必填，单位分，整数型字符
+	LocationInfo  *LocationInfo  `json:"location_info"`   // 地址位置信息，必填
+	BusiMode      string         `json:"busi_mode"`       // 业务模式，可选：ACQ-收单，不填默认为"ACQ-收单"
+	Subject       string         `json:"subject"`         // 订单标题，可选，微信支付必送
+	PayOrderNo    string         `json:"pay_order_no"`    // 支付业务订单号，可选
+	NotifyURL     string         `json:"notify_url"`      // 商户通知地址，可选
+	SettleType    string         `json:"settle_type"`     // 结算类型，可选："0"或者空为常规结算，"1"为拉卡拉分账
+	Remark        string         `json:"remark"`          // 备注，可选
+	IdentityInfo  string         `json:"identity_info"`   // 实名支付信息，可选，json字符串
+	AccBusiFields *AccBusiFields `json:"acc_busi_fields"` // 账户端业务信息域，可选
+}
+
+// Request 聚合扫码主扫交易（全报文加密）请求结构
+type TransPreorederEncryRequest struct {
+	ReqTime string                          `json:"req_time"` // 请求时间
+	Version string                          `json:"version"`  // 版本号
+	ReqData *TransPreorederEncryRequestData `json:"req_data"` // 请求数据
+}

basePay/labs/transPreorederEncry/response.go

@@ -0,0 +1,26 @@
+package transPreorederEncry
+
+// TransPreorederEncryResponseData 聚合扫码主扫交易（全报文加密）响应数据
+type TransPreorederEncryResponseData struct {
+	MerchantNo  string `json:"merchant_no"`  // 商户号
+	TermNo      string `json:"term_no"`      // 终端号
+	OutTradeNo  string `json:"out_trade_no"` // 商户交易流水号
+	TotalAmount string `json:"total_amount"` // 金额，单位分
+	PayOrderNo  string `json:"pay_order_no"` // 拉卡拉订单系统订单号
+	CodeUrl     string `json:"code_url"`     // 二维码内容，用于生成支付二维码
+	TradeType   string `json:"trade_type"`   // 交易类型
+}
+
+// TransPreorederEncryResponse 聚合扫码主扫交易（全报文加密）响应结构
+type TransPreorederEncryResponse struct {
+	RespTime string                          `json:"resp_time"` // 响应时间
+	Version  string                          `json:"version"`   // 版本号
+	Code     string                          `json:"code"`      // 响应码
+	Msg      string                          `json:"msg"`       // 响应信息
+	RespData TransPreorederEncryResponseData `json:"resp_data"` // 响应数据
+}
+
+// SuccessOrFail 判断响应是否成功
+func (r *TransPreorederEncryResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

basePay/labs/transQuery/api.go

@@ -0,0 +1,36 @@
+package transquery
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// API 聚合扫码交易查询API结构体
+type TransQueryServer struct {
+	Client *common.Client[TransQueryResponse]
+}
+
+// NewAPI 创建聚合扫码交易查询API实例
+func NewTransQueryServer(client *common.Client[TransQueryResponse]) *TransQueryServer {
+	return &TransQueryServer{
+		Client: client,
+	}
+}
+
+// TransQuery 执行聚合扫码交易查询请求
+// - merchantNo: 商户号
+// - termNo: 终端号
+// - outTradeNo: 商户交易流水号（可选，与tradeNo二选一）
+// - tradeNo: 拉卡拉交易流水号（可选，与outTradeNo二选一）
+func (a *TransQueryServer) TransQuery(reqData *TransQueryRequestData) (*TransQueryResponse, error) {
+	// 构建请求结构体
+	request := &TransQueryRequest{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+
+	// 发送请求 - 使用consts中定义的聚合扫码交易查询URL
+	return a.Client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_TRANS_QUERY_URL, request)
+}

basePay/labs/transQuery/request.go

@@ -0,0 +1,16 @@
+package transquery
+
+// TransQueryRequestData 聚合扫码交易查询请求数据结构体
+type TransQueryRequestData struct {
+	MerchantNo string `json:"merchant_no"`            // 商户号 (必填)
+	TermNo     string `json:"term_no"`                // 终端号 (必填)
+	OutTradeNo string `json:"out_trade_no,omitempty"` // 商户交易流水号 (可选，与trade_no二选一)
+	TradeNo    string `json:"trade_no,omitempty"`     // 拉卡拉交易流水号 (可选，与out_trade_no二选一)
+}
+
+// TransQueryRequest 聚合扫码交易查询请求结构体
+type TransQueryRequest struct {
+	ReqTime string                 `json:"req_time"`
+	Version string                 `json:"version"`
+	ReqData *TransQueryRequestData `json:"req_data"`
+}

basePay/labs/transQuery/response.go

@@ -0,0 +1,78 @@
+package transquery
+
+// SplitInfo 拆单信息结构体
+type SplitInfo struct {
+	SubTradeNo    string `json:"sub_trade_no"`     // 子单交易流水号
+	SubLogNo      string `json:"sub_log_no"`       // 子单对账单流水号
+	OutSubTradeNo string `json:"out_sub_trade_no"` // 外部子交易流水号
+	MerchantNo    string `json:"merchant_no"`      // 商户号
+	MerchantName  string `json:"merchant_name"`    // 商户名称
+	TermNo        string `json:"term_no"`          // 终端号
+	Amount        string `json:"amount"`           // 金额
+}
+
+// RefundSplitInfo 合单退款拆单信息结构体
+type RefundSplitInfo struct {
+	OutSubTradeNo string `json:"out_sub_trade_no"`       // 外部子退款交易流水号
+	MerchantNo    string `json:"merchant_no"`            // 商户号
+	TermNo        string `json:"term_no"`                // 终端号
+	RefundAmount  string `json:"refund_amount"`          // 申请退款金额
+	SubTradeNo    string `json:"sub_trade_no,omitempty"` // 拉卡拉子交易流水号
+	SubLogNo      string `json:"sub_log_no,omitempty"`   // 对账单子流水号
+	TradeState    string `json:"trade_state,omitempty"`  // 子交易状态
+	ResultCode    string `json:"result_code,omitempty"`  // 处理结果码
+	ResultMsg     string `json:"result_msg,omitempty"`   // 处理描述
+}
+
+// AccRespFields 账户端返回信息域结构体
+type AccRespFields struct {
+	UserId            string `json:"user_id,omitempty"`             // 买家在支付宝的用户id
+	StoreId           string `json:"store_id,omitempty"`            // 商户门店编号
+	AlipayStoreId     string `json:"alipay_store_id,omitempty"`     // 支付宝店铺编号（不再使用）
+	FundBillList      string `json:"fund_bill_list,omitempty"`      // 交易支付使用的资金渠道
+	VoucherDetailList string `json:"voucher_detail_list,omitempty"` // 所有优惠券信息
+	HbFqPayInfo       string `json:"hb_fq_pay_info,omitempty"`      // 花呗分期支付信息
+}
+
+// TransQueryResponseData 聚合扫码交易查询响应数据结构体
+type TransQueryResponseData struct {
+	MerchantNo             string             `json:"merchant_no"`                         // 拉卡拉分配的商户号
+	OutTradeNo             string             `json:"out_trade_no"`                        // 商户请求流水号
+	TradeNo                string             `json:"trade_no"`                            // 拉卡拉商户订单号
+	LogNo                  string             `json:"log_no"`                              // 拉卡拉对账单流水号
+	TradeMainType          string             `json:"trade_main_type,omitempty"`           // 交易大类
+	SplitAttr              string             `json:"split_attr,omitempty"`                // 拆单属性
+	SplitInfo              []*SplitInfo       `json:"split_info,omitempty"`                // 拆单信息
+	AccTradeNo             string             `json:"acc_trade_no"`                        // 账户端交易订单号
+	AccountType            string             `json:"account_type"`                        // 钱包类型
+	TradeState             string             `json:"trade_state"`                         // 交易状态
+	TradeStateDesc         string             `json:"trade_state_desc,omitempty"`          // 交易状态描述
+	TotalAmount            string             `json:"total_amount"`                        // 订单金额
+	PayerAmount            string             `json:"payer_amount,omitempty"`              // 付款人实付金额
+	AccSettleAmount        string             `json:"acc_settle_amount,omitempty"`         // 账户端结算金额
+	AccMDiscountAmount     string             `json:"acc_mdiscount_amount,omitempty"`      // 商户侧优惠金额（账户端）
+	AccDiscountAmount      string             `json:"acc_discount_amount,omitempty"`       // 账户端优惠金额
+	AccOtherDiscountAmount string             `json:"acc_other_discount_amount,omitempty"` // 账户端其它优惠金额
+	TradeTime              string             `json:"trade_time"`                          // 交易完成时间
+	UserId1                string             `json:"user_id1,omitempty"`                  // 用户标识1
+	UserId2                string             `json:"user_id2,omitempty"`                  // 用户标识2
+	BankType               string             `json:"bank_type,omitempty"`                 // 付款银行
+	CardType               string             `json:"card_type,omitempty"`                 // 银行卡类型
+	AccActivityId          string             `json:"acc_activity_id,omitempty"`           // 活动ID
+	TradeReqDate           string             `json:"trade_req_date"`                      // 交易请求日期
+	AccRespFields          *AccRespFields     `json:"acc_resp_fields,omitempty"`           // 账户端返回信息域
+	RefundSplitInfo        []*RefundSplitInfo `json:"refund_split_info,omitempty"`         // 合单退款拆单信息
+}
+
+// TransQueryResponse 聚合扫码交易查询响应结构体
+type TransQueryResponse struct {
+	RespTime string                  `json:"resp_time"`
+	Code     string                  `json:"code"`
+	Msg      string                  `json:"msg"`
+	RespData *TransQueryResponseData `json:"resp_data,omitempty"`
+}
+
+// SuccessOrFail 判断响应是否成功
+func (r *TransQueryResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

basePay/labs/transShareCode/api.go

@@ -0,0 +1,30 @@
+package transShareCode
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// TransShareCodeServer 聚合扫码申请支付宝吱口令服务
+type TransShareCodeServer struct {
+	client *common.Client[TransShareCodeResponse]
+}
+
+// NewTransShareCodeServer 创建聚合扫码申请支付宝吱口令服务实例
+func NewTransShareCodeServer(client *common.Client[TransShareCodeResponse]) *TransShareCodeServer {
+	return &TransShareCodeServer{
+		client: client,
+	}
+}
+
+// TransShareCode 聚合扫码申请支付宝吱口令
+func (s *TransShareCodeServer) TransShareCode(reqData *TransShareCodeRequestData) (*TransShareCodeResponse, error) {
+	// 构建请求
+	request := &TransShareCodeRequest{
+		ReqTime: gtime.Now().Format("20060102150405"),
+		Version: "3.0",
+		ReqData: reqData,
+	}
+	return s.client.DoRequest(consts.BASE_URL+consts.LKL_BASE_URL_TRANS_SHARE_CODE_URL, request)
+}

basePay/labs/transShareCode/request.go

@@ -0,0 +1,41 @@
+package transShareCode
+
+// LocationInfo 地址位置信息
+type LocationInfo struct {
+	RequestIP   string `json:"request_ip"`   // 请求方IP地址，必填
+	BaseStation string `json:"base_station"` // 客户端设备的基站信息
+	Location    string `json:"location"`     // 商户终端的地理位置，整体格式：纬度,经度
+}
+
+// ExtInfo 扩展内容，主要满足花呗分期相关的额鉴权验等功能
+type ExtInfo struct {
+	FqNumber        string `json:"fq_number"`         // 花呗分期期数，支付宝花呗分期必送字段: 花呗分期数 3：3期 6：6期 12：12期
+	FqSellerPercent string `json:"fq_seller_percent"` // 卖家承担手续费比例，支付宝花呗分期必送字段: 卖家承担收费比例，商家承担手续费传入100，用户承担手续费传入0
+}
+
+// AccBusiFields 账户端业务信息域
+type AccBusiFields struct {
+	Source   string   `json:"source"`    // 业务来源，必填
+	BizLink  string   `json:"biz_link"`  // 跳转业务链接，必填
+	SellerID string   `json:"seller_id"` // 卖家支付宝ID，可选
+	ExtInfo  *ExtInfo `json:"ext_info"`  // 扩展内容，可选
+}
+
+// TransShareCodeRequestData 请求数据
+type TransShareCodeRequestData struct {
+	MerchantNo      string         `json:"merchant_no"`       // 商户号，必填
+	TermNo          string         `json:"term_no"`           // 终端号，必填
+	OutTradeNo      string         `json:"out_trade_no"`      // 商户交易流水号，必填
+	AccountType     string         `json:"account_type"`      // 钱包类型，必填，支付宝：ALIPAY
+	TotalAmount     string         `json:"total_amount"`      // 金额，必填，单位分，整数型字符
+	LocationInfo    LocationInfo   `json:"location_info"`     // 地址位置信息，必填
+	CodeValidPeriod string         `json:"code_valid_period"` // 码有效期，可选，秒为单位,整型
+	AccBusiFields   *AccBusiFields `json:"acc_busi_fields"`   // 账户端业务信息域，可选
+}
+
+// TransShareCodeRequest 整体请求结构
+type TransShareCodeRequest struct {
+	ReqTime string                     `json:"req_time"` // 请求时间
+	Version string                     `json:"version"`  // 版本号
+	ReqData *TransShareCodeRequestData `json:"req_data"` // 请求数据
+}

basePay/labs/transShareCode/response.go

@@ -0,0 +1,28 @@
+package transShareCode
+
+// AccRespFields 账户端返回信息域
+type AccRespFields struct {
+	ShareToken string `json:"share_token"` // 吱口令，必填
+	ExpireDate string `json:"expire_date"` // 吱口令失效时间，可选，若为空则表示永久有效
+}
+
+// TransShareCodeResponseData 响应数据
+type TransShareCodeResponseData struct {
+	MerchantNo    string         `json:"merchant_no"`     // 商户号
+	OutTradeNo    string         `json:"out_trade_no"`    // 商户请求流水号
+	TradeNo       string         `json:"trade_no"`        // 拉卡拉交易流水号
+	AccRespFields *AccRespFields `json:"acc_resp_fields"` // 账户端返回信息域
+}
+
+// TransShareCodeResponse 整体响应结构
+type TransShareCodeResponse struct {
+	Code     string                      `json:"code"`      // 响应码
+	Msg      string                      `json:"msg"`       // 响应信息
+	RespTime string                      `json:"resp_time"` // 响应时间
+	RespData *TransShareCodeResponseData `json:"resp_data"` // 响应数据
+}
+
+// SuccessOrFail 判断请求是否成功
+func (r *TransShareCodeResponse) SuccessOrFail() bool {
+	return r.Code == "BBS00000"
+}

common/json_cleaner.go

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

consts/ec.go

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

consts/url.go

@@ -5,61 +5,32 @@ const (
 	BASE_TEST_URL = "https://test.wsmsd.cn/sit/api"
 )
 
+// basePay/labs 基础支付聚合扫码API地址
 const (
-	// LKL_UPLOAD_FILE_URL 拉卡拉附件上传地址
+	// LKL_BASE_URL_TRANS_PREORDER_URL 拉卡拉聚合主扫
-	LKL_UPLOAD_FILE_URL = "/v2/mms/openApi/uploadFile"
+	LKL_BASE_URL_TRANS_PREORDER_URL = "/v3/labs/trans/preorder"
-	// LKL_SPLIT_LEDGER_URL 拉卡拉商户分账业务开通申请
+	// LKL_DCP_TRANS_PREORDER_URL 拉卡拉直连主扫
-	LKL_SPLIT_LEDGER_URL = "/v2/mms/openApi/ledger/applyLedgerMer"
+	LKL_DCP_TRANS_PREORDER_URL = "/v3/dcp/trans/preorder"
-	// LKL_SPLIT_LEDGER_QUERY_URL 拉卡拉商户分账信息查询
+	// LKL_BASE_URL_TRANS_PREORDER_ENCRY_URL 拉卡拉聚合主扫交易（全报文加密）
-	LKL_SPLIT_LEDGER_QUERY_URL = "/v2/mms/openApi/ledger/queryLedgerMer"
+	LKL_BASE_URL_TRANS_PREORDER_ENCRY_URL = "/v3/labs/trans/preorder_encry"
-	// LKL_SPLIT_LEDGER_RECEIVE_URL 拉卡拉分账接收方创建申请
+	// LKL_BASE_URL_TRANS_MICROPAY_URL 拉卡拉聚合被扫
-	LKL_SPLIT_LEDGER_RECEIVE_URL = "/v2/mms/openApi/ledger/applyLedgerReceiver"
+	LKL_BASE_URL_TRANS_MICROPAY_URL = "/v3/labs/trans/micropay"
-	// LKL_SPLIT_LEDGER_RECEIVE_BIND_URL 拉卡拉分账关系绑定申请
+	// LKL_BASE_URL_TRANS_MICROPAY_ENCRY_URL 拉卡拉聚合被扫接口（全报文加密）
-	LKL_SPLIT_LEDGER_RECEIVE_BIND_URL = "/v2/mms/openApi/ledger/applyBind"
+	LKL_BASE_URL_TRANS_MICROPAY_ENCRY_URL = "/v3/labs/trans/micropay_encry"
-	// LKL_SPLIT_LEDGER_BALANCE_URL 拉卡拉可分账金额查询
+	// LKL_BASE_URL_TRANS_SHARE_CODE_URL 拉卡拉聚合扫码申请支付宝吱口令
-	LKL_SPLIT_LEDGER_BALANCE_URL = "/v3/sacs/queryAmt"
+	LKL_BASE_URL_TRANS_SHARE_CODE_URL = "/v3/labs/trans/share_code"
-	// LKL_ORDER_SPLIT_LEDGER_URL 拉卡拉订单分账
+	// LKL_BASE_URL_TRANS_QUERY_URL 拉卡拉聚合扫码交易查询
-	LKL_ORDER_SPLIT_LEDGER_URL = "/v3/sacs/separate"
+	LKL_BASE_URL_TRANS_QUERY_URL = "/v3/labs/query/tradequery"
-	// LKL_ACCOUNT_BALANCE_QUERY_URL 拉卡拉账户余额查询
+	// LKL_BASE_URL_RELATION_CLOSE_URL 拉卡拉聚合扫码关单
-	LKL_ACCOUNT_BALANCE_QUERY_URL = "/v2/laep/industry/ewalletBalanceQuery"
+	LKL_BASE_URL_RELATION_CLOSE_URL = "/v3/labs/relation/close"
-	// LKL_ACCOUNT_WITHDRAW_URL 拉卡拉账户提现
+	// LKL_BASE_URL_RELATION_REVOKED_URL 拉卡拉聚合扫码撤销
-	LKL_ACCOUNT_WITHDRAW_URL      = "/v2/laep/industry/ewalletWithdrawD1"
+	LKL_BASE_URL_RELATION_REVOKED_URL = "/v3/labs/relation/revoked"
-	LKL_SPLIT_LEDGER_FALLBACK_URL = "/v3/sacs/fallback"
+	// LKL_BASE_URL_RELATION_REFUND_URL 拉卡拉聚合扫码退款
+	LKL_BASE_URL_RELATION_REFUND_URL = "/v3/labs/relation/refund"
 )
 
-const (
+// basePay/dcp 基础支付直接扫码API地址
-	// LKL_TRADE_QUERY_URL 拉卡拉交易查询
+const ()
-	LKL_TRADE_QUERY_URL = "/v3/labs/query/tradequery"
-	// LKL_PRE_ORDER_URL 拉卡拉聚合预下单
-	LKL_PRE_ORDER_URL = "/v3/labs/trans/preorder"
-	// LKL_MERGE_ORDER_URL 拉卡拉主扫合单交易
-	LKL_MERGE_ORDER_URL = "/v3/labs/trans/merge/preorder"
-	// LKL_REFOUND_URL 拉卡拉退款
-	LKL_REFOUND_URL = "/v3/rfd/refund_front/refund"
-)
-
-const (
-	// LKL_ADD_MER 拉卡拉商户进件
-	LKL_ADD_MER = "/v2/mms/openApi/addMer"
-	// LKL_QUERY_MER 拉卡拉商户查询
-	LKL_QUERY_MER = "/v2/mms/openApi/queryContract"
-	// LKL_MER_VALIDATE 拉卡拉商户进件效验
-	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"
-	LKL_QUERY_SUB_MER_INFO_URL    = "/v2/mms/openApi/querySubMerInfo"
-	LKL_MRCH_AUTH_STATE_QUERY_URL = "/v2/mms/sme/mrchAuthStateQuery"
-)
 
 // unifiedReturn  统一退货API地址
 const (

lklsdk/account.go

@@ -1,98 +0,0 @@
-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"
-)
-
-// AccountService 账户服务
-type AccountService[T any] struct {
-	client *common.Client[T]
-}
-
-// NewAccountService 创建账户服务实例
-func NewAccountService[T any](client *common.Client[T]) *AccountService[T] {
-	return &AccountService[T]{
-		client: client,
-	}
-}
-
-// BalanceQuery 账户余额查询
-func (a *AccountService[T]) BalanceQuery(req *model.BalanceQueryReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-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) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-func (a *AccountService[T]) WithdrawTest(req *model.WithdrawReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_ACCOUNT_WITHDRAW_URL
-
-	// 构建BaseModel请求
-	baseReq := model.WithdrawRequest{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := a.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}

lklsdk/basePay/dcp/transMicropay/api.go

@@ -0,0 +1 @@
+package transmicropay

lklsdk/basePay/dcp/transMicropay/requset.go

@@ -0,0 +1 @@
+package transmicropay

lklsdk/basePay/dcp/transMicropay/response.go

@@ -0,0 +1 @@
+package transmicropay

lklsdk/merchant.go

@@ -1,252 +0,0 @@
-package lklsdk
-
-import (
-	"fmt"
-	"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"
-)
-
-// MerService 商户服务
-type MerService[T any] struct {
-	client *common.Client[T]
-}
-
-// NewMerService 创建交易服务实例
-func NewMerService[T any](client *common.Client[T]) *MerService[T] {
-	return &MerService[T]{
-		client: client,
-	}
-}
-
-// AddMer 商户进件
-func (t *MerService[T]) AddMer(req *model.MerchantApplyReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-// 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
-	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]) 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
-	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]) 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) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_RECONF_SUBMIT
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.ReConfSubmitRequest{
-		ReqData:   req,
-		ReqId:     md5,
-		Timestamp: time.Now().Unix(),
-		Ver:       "1.0",
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-
-func (t *MerService[T]) ReconsiderSubmitTest(req *model.ReConfSubmitRequestData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_RECONF_SUBMIT
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.ReConfSubmitRequest{
-		ReqData:   req,
-		ReqId:     md5,
-		Timestamp: time.Now().Unix(),
-		Ver:       "1.0",
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-
-func (t *MerService[T]) QuerySubMerInfo(req *model.QuerySubMerInfoReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_QUERY_SUB_MER_INFO_URL
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.QuerySubMerInfoRequest{
-		ReqData:   req,
-		ReqId:     md5,
-		Timestamp: time.Now().Unix(),
-		Ver:       "1.0",
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-func (t *MerService[T]) MrchAuthStateQuery(req *model.MrchAuthStateQueryReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_MRCH_AUTH_STATE_QUERY_URL
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.MrchAuthStateQueryRequest{
-		ReqData:   req,
-		ReqId:     md5,
-		Timestamp: time.Now().Unix(),
-		Ver:       "1.0",
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,19 +0,0 @@
-package querystatus
-
-// ECQueryStatusRequestData 电子合同查询状态请求数据
-// 提供申请过与拉卡拉电子签约用户查询电子合同签署状态
-// 请求URL：
-// 测试环境：https://test.wsmsd.cn/sit/api/v3/mms/open_api/ec/q_status
-// 生产环境：https://s2.lakala.com/api/v3/mms/open_api/ec/q_status
-type ECQueryStatusRequestData struct {
-	OrderNo   string `json:"order_no" dc:"四方机构自定义订单编号 必选，建议：平台编号+14位年月日时（24小时制）分秒+8位的随机数（同一接入机构不重复）"` // 必选，建议：平台编号+14位年月日时（24小时制）分秒+8位的随机数（同一接入机构不重复）
-	OrgCode   int    `json:"org_code" dc:"机构号 必选，签约方所属拉卡拉机构"`                                         // 必选，签约方所属拉卡拉机构
-	EcApplyID int64  `json:"ec_apply_id" dc:"电子合同申请受理号 必选，申请接口反馈编号"`                                  // 必选，申请接口反馈编号
-}
-
-// ECQueryStatusRequest 电子合同查询状态请求
-type ECQueryStatusRequest struct {
-	ReqTime string                    `json:"req_time" dc:"请求时间"` // 必选，格式：yyyyMMddHHmmss
-	ReqData *ECQueryStatusRequestData `json:"req_data" dc:"请求数据"` // 请求数据
-	Version string                    `json:"version" dc:"版本号"`   // 必选，固定值：1.0
-}

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

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

lklsdk/mergePre.go

@@ -1,39 +0,0 @@
-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 *common.Client[T]
-}
-
-// NewMergePreService 创建拉卡拉主扫合单交易
-func NewMergePreService[T any](client *common.Client[T]) *MergePreService[T] {
-	return &MergePreService[T]{
-		client: client,
-	}
-}
-
-func (s *MergePreService[T]) PreOrder(req *model.MergePreorderReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_MERGE_ORDER_URL
-
-	// 构建BaseModel请求
-	baseReq := model.MergePreorder{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "2.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBody, nil
-}

lklsdk/sdk.go

@@ -1,252 +0,0 @@
-package lklsdk
-
-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]
-	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),
-		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)),
-	}
-}
-
-// 以下为便捷方法，直接通过SDK调用各服务的主要功能
-
-// ReconsiderSubmit 商户进件复议提交
-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)
-}
-
-// Refound 退款
-func (s *SDK[T]) Refound(req *model.RefundReqData) (*T, error) {
-	return s.Trade.Refound(req)
-}
-
-// ApplyLedgerMer 商户分账业务开通申请
-func (s *SDK[T]) ApplyLedgerMer(req *model.ApplyLedgerMerReqData) (*T, error) {
-	return s.SplitLedger.ApplyLedgerMer(req)
-}
-
-func (s *SDK[T]) ApplyLedgerMerTest(req *model.ApplyLedgerMerReqData) (*T, error) {
-	return s.SplitLedger.ApplyLedgerMerTest(req)
-}
-
-// QueryLedgerMer 商户分账信息查询
-func (s *SDK[T]) QueryLedgerMer(req *model.QueryLedgerMerReqData) (*T, error) {
-	return s.SplitLedger.QueryLedgerMer(req)
-}
-
-func (s *SDK[T]) QueryLedgerMerTest(req *model.QueryLedgerMerReqData) (*T, error) {
-	return s.SplitLedger.QueryLedgerMerTest(req)
-}
-
-// ApplyLedgerReceiver 分账接收方创建申请
-func (s *SDK[T]) ApplyLedgerReceiver(req *model.ApplyLedgerReceiverReqData) (*T, error) {
-	return s.SplitLedger.ApplyLedgerReceiver(req)
-}
-
-func (s *SDK[T]) ApplyLedgerReceiverTest(req *model.ApplyLedgerReceiverReqData) (*T, error) {
-	return s.SplitLedger.ApplyLedgerReceiverTest(req)
-}
-
-// ApplyBind 分账关系绑定申请
-func (s *SDK[T]) ApplyBind(req *model.ApplyBindReqData) (*T, error) {
-	return s.SplitLedger.ApplyBind(req)
-}
-
-func (s *SDK[T]) ApplyBindTest(req *model.ApplyBindReqData) (*T, error) {
-	return s.SplitLedger.ApplyBindTest(req)
-}
-
-// QuerySplitBalance 可分账金额查询
-func (s *SDK[T]) QuerySplitBalance(req *model.SplitBalanceReqData) (*T, error) {
-	return s.SplitLedger.QuerySplitBalance(req)
-}
-
-func (s *SDK[T]) QuerySplitBalanceTest(req *model.SplitBalanceReqData) (*T, error) {
-	return s.SplitLedger.QuerySplitBalanceTest(req)
-}
-
-// OrderSplitLedger 订单分账
-func (s *SDK[T]) OrderSplitLedger(req *model.OrderSplitLedgerReqData) (*T, error) {
-	return s.SplitLedger.OrderSplitLedger(req)
-}
-
-func (s *SDK[T]) OrderSplitLedgerTest(req *model.OrderSplitLedgerReqData) (*T, error) {
-	return s.SplitLedger.OrderSplitLedgerTest(req)
-}
-
-// OrderSplitLedgerFallback 订单分账回退
-func (s *SDK[T]) OrderSplitLedgerFallback(req *model.OrderSplitLedgerFallbackReqData) (*T, error) {
-	return s.SplitLedger.OrderSplitLedgerFallback(req)
-}
-
-// TradeQuery 交易查询
-func (s *SDK[T]) TradeQuery(req *model.TradeQueryReqData) (*T, error) {
-	return s.Trade.TradeQuery(req)
-}
-
-// PreOrder 聚合预下单
-func (s *SDK[T]) PreOrder(req *model.PreorderReqData) (*T, error) {
-	return s.Trade.PreOrder(req)
-}
-
-// BalanceQuery 账户余额查询
-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)
-}
-
-func (s *SDK[T]) QuerySubMerInfo(req *model.QuerySubMerInfoReqData) (*T, error) {
-	return s.Merchant.QuerySubMerInfo(req)
-}
-
-func (s *SDK[T]) MrchAuthStateQuery(req *model.MrchAuthStateQueryReqData) (*T, error) {
-	return s.Merchant.MrchAuthStateQuery(req)
-}

lklsdk/split_ledger.go

@@ -1,168 +0,0 @@
-package lklsdk
-
-import (
-	"fmt"
-	"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"
-	"github.com/gogf/gf/v2/util/gconv"
-)
-
-// SplitLedgerService 分账服务
-type SplitLedgerService[T any] struct {
-	client *common.Client[T]
-}
-
-// NewSplitLedgerService 创建分账服务实例
-func NewSplitLedgerService[T any](client *common.Client[T]) *SplitLedgerService[T] {
-	return &SplitLedgerService[T]{
-		client: client,
-	}
-}
-
-// ApplyLedgerMer 商户分账业务开通申请
-func (s *SplitLedgerService[T]) ApplyLedgerMer(req *model.ApplyLedgerMerReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-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) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-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) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-func (s *SplitLedgerService[T]) QueryLedgerMerTest(req *model.QueryLedgerMerReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_SPLIT_LEDGER_QUERY_URL
-
-	// 构建BaseModel请求
-	baseReq := model.QueryLedgerMerRequest{
-		ReqTime: time.Now().Format("20060102150405"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBody, nil
-}

lklsdk/split_ledger_more.go

@@ -1,158 +0,0 @@
-package lklsdk
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/black1552/lkl_sdk/consts"
-	"github.com/black1552/lkl_sdk/model"
-	"github.com/gogf/gf/v2/crypto/gmd5"
-	"github.com/gogf/gf/v2/os/gtime"
-	"github.com/gogf/gf/v2/util/gconv"
-)
-
-// ApplyBind 分账关系绑定申请
-func (s *SplitLedgerService[T]) ApplyBind(req *model.ApplyBindReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-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) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-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) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_ORDER_SPLIT_LEDGER_URL
-
-	// 构建BaseModel请求
-	baseReq := model.OrderSplitLedgerRequest{
-		ReqTime: time.Now().Format("20060102150405"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-
-func (s *SplitLedgerService[T]) OrderSplitLedgerTest(req *model.OrderSplitLedgerReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_ORDER_SPLIT_LEDGER_URL
-
-	// 构建BaseModel请求
-	baseReq := model.OrderSplitLedgerRequest{
-		ReqTime: time.Now().Format("20060102150405"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-
-func (s *SplitLedgerService[T]) OrderSplitLedgerFallback(req *model.OrderSplitLedgerFallbackReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_SPLIT_LEDGER_FALLBACK_URL
-
-	// 构建BaseModel请求
-	baseReq := model.OrderSplitLedgerFallbackRequest{
-		ReqTime: time.Now().Format("20060102150405"),
-		Version: "3.0",
-		ReqData: req,
-	}
-
-	// 发送请求
-	respBody, err := s.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}

lklsdk/trade.go

@@ -1,75 +0,0 @@
-package lklsdk
-
-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 *common.Client[T]
-}
-
-// NewTradeService 创建交易服务实例
-func NewTradeService[T any](client *common.Client[T]) *TradeService[T] {
-	return &TradeService[T]{
-		client: client,
-	}
-}
-
-// TradeQuery 交易查询
-func (t *TradeService[T]) TradeQuery(req *model.TradeQueryReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_TRADE_QUERY_URL
-
-	// 构建BaseModel请求
-	baseReq := model.TradeQuery{
-		ReqTime:    time.Now().Format("20060102150405"),
-		Version:    "3.0",
-		OutOrgCode: t.client.Config.AppId,
-		ReqData:    req,
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}
-
-// PreOrder 聚合预下单
-func (t *TradeService[T]) PreOrder(req *model.PreorderReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_PRE_ORDER_URL
-
-	// 构建BaseModel请求
-	baseReq := model.NewPreorder(req)
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBody, nil
-}
-
-// Refound 退款
-func (t *TradeService[T]) Refound(req *model.RefundReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_URL + consts.LKL_REFOUND_URL
-
-	// 构建BaseModel请求
-	baseReq := model.NewRefund(req)
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBody, nil
-}

lklsdk/unifiedReturn/mergeRefund/api.go

@@ -1,34 +0,0 @@
-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/refundquery/api.go

@@ -1,37 +0,0 @@
-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/unifiedReturn.go

@@ -1,43 +0,0 @@
-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

@@ -1,71 +0,0 @@
-package lklsdk
-
-import (
-	"fmt"
-	"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"
-)
-
-// UploadFileService 交易服务
-type UploadFileService[T any] struct {
-	client *common.Client[T]
-}
-
-// NewUploadFileService 创建交易服务实例
-func NewUploadFileService[T any](client *common.Client[T]) *UploadFileService[T] {
-	return &UploadFileService[T]{
-		client: client,
-	}
-}
-
-// UploadFileQuery 交易查询
-func (t *UploadFileService[T]) UploadFileQuery(req *model.UploadFileReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_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
-}
-
-func (t *UploadFileService[T]) UploadFileQueryTest(req *model.UploadFileReqData) (*T, error) {
-	// 构建请求参数
-	url := consts.BASE_TEST_URL + consts.LKL_UPLOAD_FILE_URL
-	md5, err := gmd5.Encrypt(gconv.String(time.Now().Unix()))
-	if err != nil {
-		return nil, fmt.Errorf("创建ReqId失败")
-	}
-	// 构建BaseModel请求
-	baseReq := model.UploadFileRequest{
-		Timestamp: gconv.String(time.Now().Unix()),
-		Ver:       "1.0",
-		ReqId:     md5,
-		ReqData:   req,
-	}
-
-	// 发送请求
-	respBody, err := t.client.DoRequest(url, baseReq)
-	if err != nil {
-		return nil, err
-	}
-	return respBody, nil
-}

model/applyBind.go

@@ -1,54 +0,0 @@
-package model
-
-import "github.com/black1552/lkl_sdk/consts"
-
-// ApplyBindRequest 分账关系绑定请求结构体
-// 用于发起分账接收方与商户的关系绑定申请
-// 拉卡拉SDK接口文档：分账关系绑定接口
-
-type ApplyBindRequest struct {
-	ReqData *ApplyBindReqData `json:"reqData"` // 请求业务数据
-	ReqId   string            `json:"reqId"`   // 请求ID，唯一标识一笔请求
-	Version string            `json:"version"` // 接口版本号
-	ReqTime string            `json:"reqTime"` // 请求时间，格式为yyyyMMddHHmmss
-}
-
-// ApplyBindReqData 分账关系绑定请求业务数据结构体
-// 包含分账关系绑定所需的详细业务参数
-
-type ApplyBindReqData struct {
-	Version         string                 `json:"version"`               // 接口版本号，必传，长度8，取值说明：1.0
-	OrderNo         string                 `json:"orderNo"`               // 订单编号，必传，长度32，用于后续跟踪排查问题及核对报文，格式为14位年月日(24小时制)分秒+8位随机数（不重复）
-	OrgCode         string                 `json:"orgCode"`               // 分账接收方所属机构代码，必传，长度32
-	MerInnerNo      string                 `json:"merInnerNo"`            // 分账商户内部商户号，必传，长度32，与MerCupNo选传其一，不能都为空
-	MerCupNo        string                 `json:"merCupNo"`              // 分账商户银联商户号，必传，长度32，与MerInnerNo选传其一，不能都为空
-	ReceiverNo      string                 `json:"receiverNo"`            // 分账接收方编号，必传，长度32
-	EntrustFileName string                 `json:"entrustFileName"`       // 合作协议附件名称，必传，长度32
-	EntrustFilePath string                 `json:"entrustFilePath"`       // 合作协议附件路径，必传，长度32，通过调用附件上传接口获取
-	RetUrl          string                 `json:"retUrl"`                // 回调通知地址，必传，长度128，审核通过后通知地址
-	Attachments     []*ApplyBindAttachment `json:"attachments,omitempty"` // 附加资料，可选，集合类型，其他附加资料文件信息
-}
-
-type ApplyBindAttachment struct {
-	AttachType      consts.AttType `json:"attachType"`      // 附件类型编码，必传，长度32
-	AttachName      string         `json:"attachName"`      // 附件名称，必传，长度32
-	AttachStorePath string         `json:"attachStorePath"` // 附件路径，必传，长度128，通过调用附件上传接口获取
-}
-
-// ApplyBindResponse 分账关系绑定响应结构体
-// 包含分账关系绑定申请的处理结果信息
-
-type ApplyBindResponse struct {
-	RetCode  string `json:"retCode"` // 响应码，000000表示成功
-	RetMsg   string `json:"retMsg"`  // 响应消息，描述响应结果
-	RespData struct {
-		Version string `json:"version"` // 接口版本号，例如：547110502170558464
-		OrderNo string `json:"orderNo"` // 订单编号，例如：2021020112000012345678
-		OrgCode string `json:"orgCode"` // 机构代码，例如：200669
-		ApplyId int64  `json:"applyId"` // 受理编号，例如：548099616395186176
-	} `json:"respData"` // 响应业务数据，当retCode为000000时返回
-}
-
-func (a *ApplyBindResponse) SuccessOrFail() bool {
-	return a.RetCode == "000000"
-}

model/applyLedgerMer.go

@@ -1,48 +0,0 @@
-package model
-
-import "github.com/black1552/lkl_sdk/consts"
-
-// ApplyLedgerMerRequest 商户分账业务开通申请请求结构体
-type ApplyLedgerMerRequest struct {
-	ReqData *ApplyLedgerMerReqData `json:"reqData"` // 请求业务数据
-	ReqId   string                 `json:"reqId"`   // 请求ID
-	Version string                 `json:"version"` // 接口版本号
-	ReqTime string                 `json:"reqTime"` // 请求时间
-}
-
-// ApplyLedgerMerReqData 商户分账业务开通申请请求业务数据结构体
-type ApplyLedgerMerReqData struct {
-	Version              string                 `json:"version"`               // 版本号，必传，长度8，取值说明：1.0
-	OrderNo              string                 `json:"orderNo"`               // 订单编号，必传，长度32，用于后续处理查询及回调通知消息标识，2014年月日时分秒毫秒组成
-	OrgCode              string                 `json:"orgCode"`               // 机构代码，必传，长度12
-	MerInnerNo           string                 `json:"merInnerNo"`            // 拉卡拉内部商户号，可选，长度32，拉卡拉内部商户号和银联商户号必须传一个，默认以内部商户号为准
-	MerCupNo             string                 `json:"merCupNo"`              // 银联商户号，可选，长度32，拉卡拉内部商户号和银联商户号必须传一个，默认以内部商户号为准
-	ContactMobile        string                 `json:"contactMobile"`         // 联系手机号，必传，长度32
-	SplitLowestRatio     float64                `json:"splitLowestRatio"`      // 最低分账比例，必传，长度12，百分比，支持2位精度，取值范围：70-70.50
-	SplitEntrustFileName string                 `json:"splitEntrustFileName"`  // 分账授权委托书文件名称，必传，长度64，文件格式：pdf
-	SplitEntrustFilePath string                 `json:"splitEntrustFilePath"`  // 分账授权委托书文件路径，必传，长度64，调用附件上传接口获取
-	SplitRange           consts.SplitRange      `json:"splitRange"`            // 分账范围，必传，长度32，取值说明：ALL-全部交易分账(所有交易默认都分账)，MARK-标记交易分账(只有带标记交易才分账，其余交易正常结算)
-	SepFundSource        consts.SepFundSource   `json:"sepFundSource"`         // 分账依据，非必传，长度32，取值说明：TRA-交易分账，BAR-金额分账
-	EleContractNo        string                 `json:"eleContractNo"`         // 电子合同编号，非必传，长度32，收单已签约交易电子合同编号，供审核人员复核使用
-	SplitLaunchMode      consts.SplitLaunchMode `json:"splitLaunchMode"`       // 分账发起方式，非必传，长度32，取值说明：AUTO-自动触发分账，POINTTRUE-指定规则分账，MANUAL-手动分账
-	SettleType           consts.SplitSettleType `json:"settleType"`            // 结算类型，非必传，长度32，取值说明：01-主扫现结，02-复扫现结，03-交易自动结算
-	SplitRuleSource      consts.SplitRuleSource `json:"splitRuleSource"`       // 分账规则来源，条件必传，长度32，取值说明：MER-商户自定规则，PLATFORM-平台分润规则(分润规则必传)
-	RetUrl               string                 `json:"retUrl"`                // 回调通知地址，必传，长度128，分账申请结果以异步消息或同步返回的方式通知，如需无线路由处理，也可以通过第三方商户信息查询接口确定结算结果
-	Attachments          []*ApplyBindAttachment `json:"attachments,omitempty"` // 附加资料，可选，集合，其他需附加的文件信息
-}
-
-// ApplyLedgerMerResponse 商户分账业务开通申请响应结构体
-type ApplyLedgerMerResponse struct {
-	RetCode  string `json:"retCode"` // 返回码，000000表示成功
-	RetMsg   string `json:"retMsg"`  // 返回消息
-	RespData struct {
-		Version string `json:"version"` // 接口版本号，例如：547110502170558464
-		OrderNo string `json:"orderNo"` // 订单编号，例如：2021020112000012345678
-		OrgCode string `json:"orgCode"` // 机构代码，例如：200669
-		ApplyId int64  `json:"applyId"` // 受理编号，例如：548099616395186176
-	} `json:"respData"` // 响应数据
-}
-
-func (a *ApplyLedgerMerResponse) SuccessOrFail() bool {
-	return a.RetCode == "000000"
-}

model/applyLedgerReceiver.go

@@ -1,99 +0,0 @@
-package model
-
-import "github.com/black1552/lkl_sdk/consts"
-
-// ApplyLedgerReceiverRequest 分账接收方创建请求结构体
-// 用于向拉卡拉接口发送分账接收方创建请求
-// 包含请求头信息和业务数据
-type ApplyLedgerReceiverRequest struct {
-	// 请求业务数据
-	ReqData *ApplyLedgerReceiverReqData `json:"reqData"`
-	// 请求ID，用于幂等性校验
-	ReqId string `json:"reqId"`
-	// 接口版本号
-	Version string `json:"version"`
-	// 请求时间，格式为yyyyMMddHHmmss
-	ReqTime string `json:"reqTime"`
-}
-
-// ApplyLedgerReceiverReqData 分账接收方创建请求业务数据结构体
-// 包含分账接收方创建所需的具体业务参数
-// 用于创建分账接收方信息
-type ApplyLedgerReceiverReqData struct {
-	// 接口版本号，必传，长度8，取值说明：1.0
-	Version string `json:"version"`
-	// 订单编号（便于后续跟踪排查问题及核对报文），必传，长度32，取值说明：14位年月日（24小时制）分秒+8位的随机数（不重复）
-	OrderNo string `json:"orderNo"`
-	// 机构代码，必传，长度32
-	OrgCode string `json:"orgCode"`
-	// 分账接收方名称，必传，长度64
-	ReceiverName string `json:"receiverName"`
-	// 联系手机号，必传，长度16
-	ContactMobile string `json:"contactMobile"`
-	// 营业执照号码，可选，长度32，取值说明：收款账户类型为对公，必须上送
-	LicenseNo string `json:"licenseNo"`
-	// 营业执照名称，可选，长度128，取值说明：收款账户类型为对公，必须上送
-	LicenseName string `json:"licenseName"`
-	// 法人姓名，可选，长度32，取值说明：收款账户类型为对公，必须上送
-	LegalPersonName string `json:"legalPersonName"`
-	// 法人证件类型，可选，长度32，取值说明：17身份证，18护照，19港澳居民来往内地通行证，20台湾居民来往内地通行证，收款账户类型为对公，必须上送，身份证外类型先咨询后再使用
-	LegalPersonCertificateType consts.AcctCertificateType `json:"legalPersonCertificateType"`
-	// 法人证件号，可选，长度32，取值说明：收款账户类型为对公，必须上送
-	LegalPersonCertificateNo string `json:"legalPersonCertificateNo"`
-	// 收款账户卡号，必传，长度32
-	AcctNo string `json:"acctNo"`
-	// 收款账户名称，必传，长度32
-	AcctName string `json:"acctName"`
-	// 收款账户类型代码，必传，长度32，取值说明：57：对公，58：对私
-	AcctTypeCode consts.AcctTypeCode `json:"acctTypeCode"`
-	// 收款账户证件类型，必传，长度32，取值说明：17身份证，18护照，19港澳居民来往内地通行证，20台湾居民来往内地通行证，身份证外类型先咨询后再使用
-	AcctCertificateType consts.AcctCertificateType `json:"acctCertificateType"`
-	// 收款账户证件号，必传，长度32
-	AcctCertificateNo string `json:"acctCertificateNo"`
-	// 收款账户开户行号，必传，长度32，取值说明：参照FBI.N信息查询，仅支持对私结算账户
-	AcctOpenBankCode string `json:"acctOpenBankCode"`
-	// 收款账户开户行名称，必传，长度64，取值说明：参照FBI.N信息查询，仅支持对私结算账户
-	AcctOpenBankName string `json:"acctOpenBankName"`
-	// 收款账户清算行行号，必传，长度32，取值说明：参照FBI.N信息查询，仅支持对私结算账户
-	AcctClearBankCode string `json:"acctClearBankCode"`
-	// 接收方附件资料，可选，集合
-	AttachList []*ApplyBindAttachment `json:"attachList"`
-	// 提款类型，可选，长度32，取值说明：01：主动提款，03：交易自动结算，不填默认01
-	SettleType string `json:"settleType"`
-}
-
-// ApplyLedgerReceiverResponse 分账接收方创建响应结构体
-// 拉卡拉接口返回的分账接收方创建响应数据
-// 包含响应状态码、消息和业务数据
-type ApplyLedgerReceiverResponse struct {
-	// 响应状态码，000000表示成功
-	RetCode string `json:"retCode"`
-	// 响应消息
-	RetMsg string `json:"retMsg"`
-	// 响应业务数据，当retCode为000000时返回
-	RespData *ApplyLedgerReceiverRespData `json:"respData"`
-}
-
-// ApplyLedgerReceiverRespData 分账接收方创建响应业务数据结构体
-// 包含分账接收方创建返回的具体业务信息
-type ApplyLedgerReceiverRespData struct {
-	// 接口版本号(回传)
-	Version string `json:"version"`
-	// 订单编号(回传)
-	OrderNo string `json:"orderNo"`
-	// 申请机构代码(回传)
-	OrgCode string `json:"orgCode"`
-	// 接收方所属机构
-	OrgId string `json:"orgId"`
-	// 接收方所属机构名称
-	OrgName string `json:"orgName"`
-	// 接收方编号
-	ReceiverNo string `json:"receiverNo"`
-}
-
-// SuccessOrFail 判断分账接收方创建请求是否成功
-// 成功条件：响应码为000000
-// 返回值：true表示成功，false表示失败
-func (resp *ApplyLedgerReceiverResponse) SuccessOrFail() bool {
-	return resp.RetCode == "000000"
-}

model/balanceQuery.go

@@ -1,69 +0,0 @@
-package model
-
-import "github.com/black1552/lkl_sdk/consts"
-
-// BalanceQueryRequest 余额查询请求结构体
-// 用于向拉卡拉接口发送余额查询请求
-// 包含请求头信息和业务数据
-type BalanceQueryRequest struct {
-	// 请求业务数据
-	ReqData *BalanceQueryReqData `json:"req_data"`
-	// 接口版本号
-	Version string `json:"version"`
-	// 请求时间，格式为yyyyMMddHHmmss
-	ReqTime string `json:"req_time"`
-}
-
-// BalanceQueryReqData 余额查询请求业务数据结构体
-// 包含余额查询所需的具体业务参数
-// 用于查询账户的实时余额信息
-type BalanceQueryReqData struct {
-	// 机构号，必传，最大长度32
-	OrgNo string `json:"org_no"`
-	// 商户号或receiveNo或商户用户编号，必传，最大长度32
-	MerchantNo string `json:"merchant_no"`
-	// 账号，若该参数上送，则payType将无效，非必传，最大长度32
-	PayNo string `json:"pay_no"`
-	// 账号类型（01：收款账户，02：付款账户，03：分账商户账户，04：分账接收方账户，05：充值代付账户，06：结算代付账户）-未上送则默认01，非必传，最大长度32
-	PayType consts.PayType `json:"pay_type"`
-	// 账户标志（01:一般账户;03:虚户）-未上送则默认01，非必传，最大长度32
-	MgtFlag consts.MgtFlag `json:"mgt_flag"`
-}
-
-// BalanceQueryResponse 余额查询响应结构体
-// 拉卡拉接口返回的余额查询响应数据
-// 包含响应状态码、消息和业务数据
-type BalanceQueryResponse struct {
-	// 响应状态码，000000
-	Code string `json:"retCode"`
-	// 响应消息
-	Msg string `json:"retMsg"`
-	// 响应业务数据，当code为SACS0000时返回
-	RespData *BalanceQueryRespData `json:"respData"`
-}
-
-// BalanceQueryRespData 余额查询响应业务数据结构体
-// 包含余额查询返回的具体账户信息
-type BalanceQueryRespData struct {
-	// 账号，必传
-	PayNo string `json:"payNo"`
-	// 账户类型，必传
-	PayType string `json:"payType"`
-	// 账户状态，必传，取值说明：CLOSE销户，NORMAL正常，FREEZE冻结，STOPAY止付
-	AcctSt string `json:"acctSt"`
-	// 预付余额（单位元），必传
-	ForceBalance string `json:"forceBalance"`
-	// 上日余额（单位元）-该字段已废弃使用，必传
-	HisBalance string `json:"hisBalance"`
-	// 实时余额（单位元），必传
-	ReBalance string `json:"reBalance"`
-	// 当前可用余额（单位元），必传
-	CuBalance string `json:"cuBalance"`
-}
-
-// SuccessOrFail 判断余额查询请求是否成功
-// 成功条件：响应码为SACS0000
-// 返回值：true表示成功，false表示失败
-func (resp *BalanceQueryResponse) SuccessOrFail() bool {
-	return resp.Code == "000000"
-}

model/baseModel.go

@@ -1,7 +0,0 @@
-package model
-
-type BaseModel[T any] struct {
-	ReqTime string `json:"req_time"`
-	Version string `json:"version"`
-	ReqData T      `json:"req_data"`
-}

model/merValidate.go

@@ -1,75 +0,0 @@
-// Package model 提供数据模型定义
-package model
-
-// MerValidateRequest 商户进件校验请求
-// 接入方在入网前，对商户名称、法人信息、结算人信息做敏感词和黑名单、反洗钱的校验
-// 参考文档: https://o.lakala.com/#/home/document/detail?id=93
-
-type MerValidateRequest struct {
-	// ReqData 请求业务参数
-	ReqData *MerValidateRequestData `json:"reqData"`
-	// Ver 版本号
-	Ver string `json:"ver"`
-	// Timestamp 时间戳
-	Timestamp int64 `json:"timestamp"`
-	// ReqId 请求ID
-	ReqId string `json:"reqId"`
-}
-
-// MerValidateRequestData 商户进件校验请求业务参数
-
-type MerValidateRequestData struct {
-	// Version 接口版本号
-	Version string `json:"version"`
-	// OrderNo 订单编号（便于后续跟踪排查问题及核对报文）
-	// 14位年月日时（24小时制）分秒+8位的随机数（不重复）如：2021020112000012345678
-	OrderNo string `json:"orderNo"`
-	// OrgCode 机构代码
-	OrgCode string `json:"orgCode"`
-	// MerRegName 商户注册名称（可传）
-	MerRegName string `json:"merRegName"`
-	// MerBizName 商户经营名称（可传）
-	MerBizName string `json:"merBizName"`
-	// MerBlis 营业执照（可传）
-	MerBlis string `json:"merBlis"`
-	// LarIdcard 法人身份证号（可传）
-	LarIdcard string `json:"larIdcard"`
-	// AcctNo 结算账号（可传）
-	AcctNo string `json:"acctNo"`
-	// AcctIdcard 结算人证件号（可传）
-	AcctIdcard string `json:"acctIdcard"`
-}
-
-// MerValidateResponse 商户进件校验响应
-
-type MerValidateResponse struct {
-	// Appid 应用ID
-	Appid string `json:"appid"`
-	// CmdRetCode 全局返回码
-	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 返回消息
-	RetMsg string `json:"retMsg"`
-	// Timestamp 时间戳
-	Timestamp int64 `json:"timestamp"`
-	// Ver 版本号
-	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

@@ -1,111 +0,0 @@
-package model
-
-import (
-	"github.com/black1552/lkl_sdk/consts"
-)
-
-// MerchantApplyRequest 商户进件请求结构体
-
-type MerchantApplyRequest struct {
-	ReqId     string                `json:"reqId"`     // 请求时间，格式为yyyyMMddHHmmss，必填
-	Timestamp int64                 `json:"timestamp"` // 接口版本，固定值"1.0"，必填
-	Ver       string                `json:"ver"`       // 接口版本，固定值"1.0"，必填
-	ReqData   *MerchantApplyReqData `json:"reqData"`   // 请求业务参数，必填
-}
-
-// MerchantApplyReqData 商户进件请求业务数据结构体
-
-type MerchantApplyReqData struct {
-	Version           string                `json:"version"`           // 接口版本号，固定值"1.0"，必填
-	OrderNo           string                `json:"orderNo"`           // 订单编号，用于后续联调时查询及核对报文，必填，建议14位年月日时分秒+8位随机数
-	PosType           consts.PosType        `json:"posType"`           // POS类型，必填，按接入系统做控制，参见POS类型字典表
-	OrgCode           string                `json:"orgCode"`           // 机构代码，合作方在拉卡拉的标识，请联系业务员，必填
-	MerRegName        string                `json:"merRegName"`        // 商户注册名称，必填，长度不小于4个汉字，8~40字符，不可为纯数字
-	MerBizName        string                `json:"merBizName"`        // 商户经营名称，选填，为空时同商户注册名称，4~64字符，不可为纯数字
-	MerRegDistCode    consts.AddrCode       `json:"merRegDistCode"`    // 商户地区代码，必填，参见地区文档
-	MerRegAddr        string                `json:"merRegAddr"`        // 商户详细地址，必填，去除省、市、区后的详细地址，6-200字符
-	MccCode           consts.Mcc            `json:"mccCode"`           // 商户MCC编号，必填，银联商户类别代码
-	MerBlisName       string                `json:"merBlisName"`       // 营业执照名称，选填，小微商户可不传，其它必传
-	MerBlis           string                `json:"merBlis"`           // 营业执照号，选填，小微商户可不传，对公进件必传，且不可与法人证件相同
-	MerBlisStDt       string                `json:"merBlisStDt"`       // 营业执照开始日期，选填，格式yyyy-MM-dd，有营业执照时必传
-	MerBlisExpDt      string                `json:"merBlisExpDt"`      // 营业执照有效期，选填，格式yyyy-MM-dd，有营业执照时必传
-	MerBusiContent    consts.MerBusiContent `json:"merBusiContent"`    // 商户经营内容，必填，参见经营内容字典表
-	LarName           string                `json:"larName"`           // 商户法人姓名，必填
-	LarIdType         consts.AccIdType      `json:"larIdType"`         // 法人证件类型，必填，支持其他证件类型，见证件类型字典表
-	LarIdcard         string                `json:"larIdcard"`         // 法人身份证号码，必填
-	LarIdcardStDt     string                `json:"larIdcardStDt"`     // 法人身份证开始日期，必填，格式yyyy-MM-dd
-	LarIdcardExpDt    string                `json:"larIdcardExpDt"`    // 法人身份证有效期，必填，格式yyyy-MM-dd
-	MerContactMobile  string                `json:"merContactMobile"`  // 商户联系人手机号码，必填
-	MerContactName    string                `json:"merContactName"`    // 商户联系人姓名，必填
-	ShopName          string                `json:"shopName"`          // 网点名称，选填，不填取商户注册名称
-	ShopDistCode      string                `json:"shopDistCode"`      // 网点地址区划代码，选填，不填取商户地区代码
-	ShopAddr          string                `json:"shopAddr"`          // 网点详细地址，选填，不填取商户详细地址
-	ShopContactName   string                `json:"shopContactName"`   // 网点联系人名称，选填，不填取商户联系人姓名
-	ShopContactMobile string                `json:"shopContactMobile"` // 网点联系人手机号，选填，不填取商户联系人手机号码
-	OpenningBankCode  string                `json:"openningBankCode"`  // 结算账户开户行号，必填，可根据结算卡信息进行查询
-	OpenningBankName  string                `json:"openningBankName"`  // 结算账户开户行名称，必填，可根据结算卡信息进行查询
-	ClearingBankCode  string                `json:"clearingBankCode"`  // 结算账户清算行号，必填，可根据结算卡信息进行查询
-	AcctNo            string                `json:"acctNo"`            // 结算账户账号，必填
-	AcctName          string                `json:"acctName"`          // 结算账户名称，必填
-	AcctTypeCode      consts.AcctTypeCode   `json:"acctTypeCode"`      // 结算账户性质，必填，57为对公，58为对私
-	SettlePeriod      consts.SettlePeriod   `json:"settlePeriod"`      // 结算周期，必填，参见结算周期表
-	ClearDt           consts.ClearDt        `json:"clearDt"`           // 日切时间，选填，参见日切时间字典表，默认TWENTY_THREE
-	AcctIdType        consts.AccIdType      `json:"acctIdType"`        // 结算人证件类型，选填，为空时判断为同法人
-	AcctIdcard        string                `json:"acctIdcard"`        // 结算人证件号码，选填，为空时判断为同法人
-	AcctIdDt          string                `json:"acctIdDt"`          // 结算人证件有效期，选填，为空时判断为同法人
-	DevSerialNo       string                `json:"devSerialNo"`       // 终端设备序列号，选填
-	DevTypeName       string                `json:"devTypeName"`       // 设备型号，选填
-	TermVer           string                `json:"termVer"`           // 终端版本号，选填
-	SalesStaff        string                `json:"salesStaff"`        // 销售人员，选填
-	TermNum           string                `json:"termNum"`           // 终端数量，选填，1-5，最大5个终端
-	RetUrl            string                `json:"retUrl"`            // 回调地址，必填
-	FeeData           []*FeeData            `json:"feeData"`           // 费率信息集合，必填
-	FileData          []*FileData           `json:"fileData"`          // 附件集合，选填
-	ContractNo        string                `json:"contractNo"`        // 电子合同编号，选填，部分进件类型要求录入
-	FeeAssumeType     string                `json:"feeAssumeType"`     // 大额理财-手续费承担方，选填，大额理财进件时必传
-	AmountOfMonth     string                `json:"amountOfMonth"`     // 大额理财-最小月交易额，选填
-	ServiceFee        string                `json:"serviceFee"`        // 大额理财-收取服务费，选填
-}
-
-// FeeData 费率信息集合结构体
-
-type FeeData struct {
-	FeeRateTypeCode consts.FeeRateTypeCode `json:"feeRateTypeCode"` // 费率类型，必填，参见费率类型字典表
-	FeeRateTypeName string                 `json:"feeRateTypeName"` // 费率类型名称，必填，如银行卡借记卡
-	FeeRatePct      string                 `json:"feeRatePct"`      // 手续费费率(%)，必填，如0.6
-	FeeUpperAmtPcnt string                 `json:"feeUpperAmtPcnt"` // 单笔交易手续费封顶，选填，默认不封顶，单位（元）
-	FeeLowerAmtPcnt string                 `json:"feeLowerAmtPcnt"` // 单笔交易手续费保底，选填，默认无保底，单位（元）
-	FeeRateSdt      string                 `json:"feeRateSdt"`      // 手续费生效日期，选填，默认为进件日期
-}
-
-// FileData 附件集合结构体
-
-type FileData struct {
-	AttFileId string `json:"attFileId"` // 文件编号/附件上传后返回的编号，必填
-	AttType   consts.AcctTypeCode `json:"attType"`   // 附件类型，必填
-}
-
-// MerchantApplyResponse 商户进件响应结构体
-
-type MerchantApplyResponse struct {
-	RetCode    string                 `json:"retCode"`   // 响应码，成功为"0000"，其他为错误码
-	RetMsg     string                 `json:"retMsg"`    // 响应描述
-	Timestamp  int64                  `json:"timestamp"` // 响应描述
-	Md         string                 `json:"md"`
-	Ver        string                 `json:"ver"`        // 响应描述
-	ReqId      string                 `json:"reqId"`      // 响应描述
-	CmdRetCode string                 `json:"cmdRetCode"` // 响应描述
-	RespData   *MerchantApplyRespData `json:"respData"`   // 响应业务数据，成功时返回
-}
-
-// MerchantApplyRespData 商户进件响应业务数据结构体
-
-type MerchantApplyRespData struct {
-	OrgCode    string `json:"orgCode"`    // 机构代码
-	OrderNo    string `json:"orderNo"`    // 订单号
-	ContractId string `json:"contractId"` // 进件ID，用于后续查询进件结果
-}
-
-func (t *MerchantApplyResponse) SuccessOrFail() bool {
-	return t.RetCode == "000000"
-}

model/mergePreorder.go

@@ -1,124 +0,0 @@
-package model
-
-import (
-	"github.com/black1552/lkl_sdk/consts"
-	"github.com/gogf/gf/v2/os/gtime"
-)
-
-// MergePreorder 主扫合单交易请求结构体
-type MergePreorder struct {
-	ReqTime string                `json:"req_time"` // 请求时间，格式：YYYYMMDDHHMMSS
-	Version string                `json:"version"`  // 接口版本号，固定值"3.0"
-	ReqData *MergePreorderReqData `json:"req_data"` // 请求业务数据
-}
-
-// MergePreorderReqData 主扫合单交易请求业务数据
-type MergePreorderReqData struct {
-	MerchantNo        string             `json:"merchant_no"`         // 商户号，拉卡拉分配的商户号，String(32)，必填
-	TermNo            string             `json:"term_no"`             // 终端号，拉卡拉分配的业务终端号，String(32)，必填
-	OutTradeNo        string             `json:"out_trade_no"`        // 商户交易流水号，商户系统唯一，String(32)，必填
-	OutSplitInfo      []*OutSplitInfo    `json:"out_split_info"`      // 拆单信息，List，必填
-	AccountType       consts.AccountType `json:"account_type"`        // 钱包类型，微信：WECHAT 支付宝：ALIPAY 银联：UQRCODEPAY 京东钱包：JD，String(32)，必填
-	TransType         consts.TransType   `json:"trans_type"`          // 接入方式，41:NATIVE（扫码支付）(仅ALIPAY支持) 51:JSAPI（微信公众号支付，支付宝服务窗支付，银联JS支付，支付宝JS支付、拉卡拉钱包支付）71:微信小程序支付 81:支付宝H5支付（需特殊商户账户端支持），String(2)，必填
-	TotalAmount       string             `json:"total_amount"`        // 金额，单位分，整数型字符，String(12)，必填
-	LocationInfo      *LocationInfo      `json:"location_info"`       // 地址位置信息，Object，风控要求必送，必填
-	BusiMode          string             `json:"busi_mode"`           // 业务模式，ACQ-收单 PAY-付款不填，默认为"ACQ-收单"，String(8)，选填
-	Subject           string             `json:"subject"`             // 订单标题，用于简单描述订单或商品主题，传递给账户端（账户端控制，实际最多42个字节），String(42)，选填
-	NotifyUrl         string             `json:"notify_url"`          // 商户通知地址，如果上传，且 pay_order_no 不存在情况下，则按此地址通知商户，String(128)，选填
-	Remark            string             `json:"remark"`              // 备注，String(128)，选填
-	IdentityInfo      string             `json:"identity_info"`       // 实名支付信息，json字符串，如{"identityNo": "3200000000000000XX", "name": "张三"}，然后国密sm2加密，String(1024)，选填
-	AccBusiFields     *AccBusiFields     `json:"acc_busi_fields"`     // 账户端业务信息域，Object，选填
-	CompleteNotifyUrl string             `json:"complete_notify_url"` // 发货确认通知地址，发货类小程序确认收货后通知商户的地址，String(128)，选填
-}
-
-// OutSplitInfo 拆单信息
-type OutSplitInfo struct {
-	OutSubTradeNo string `json:"out_sub_trade_no"` // 外部子交易流水号，商户子交易流水号，商户号下唯一，String(32)，必填
-	MerchantNo    string `json:"merchant_no"`      // 商户号，拉卡拉分配的商户号，String(32)，必填
-	TermNo        string `json:"term_no"`          // 终端号，拉卡拉分配的业务终端号，String(32)，必填
-	Amount        string `json:"amount"`           // 金额，单位分，整数型字符，String(12)，必填
-	SettleType    string `json:"settle_type"`      // 结算类型（单台），"0"或者空，常规结算方式，String(4)，选填
-	SubRemark     string `json:"sub_remark"`       // 子备注，子单备注信息，String(64)，选填
-}
-
-// LocationInfo 地址位置信息
-type LocationInfo struct {
-	RequestIp   string `json:"request_ip"`   // 请求方IP地址，请求方的IP地址，存在必填，格式如36.45.36.95，String(64)，必填
-	BaseStation string `json:"base_station"` // 基站信息，客户端设备的基站信息（主扫时基站信息使用该字段），String(128)，选填
-	Location    string `json:"location"`     // 维度,经度，商户终端的地理位置，存在必填格式：纬度,经度，+表示北纬、东经，-表示南纬、西经，精度最长支持小数点后9位。举例:+37.123456789,121.123456789，String(32)，选填
-}
-
-// AccBusiFields 账户端业务信息域，微信主扫场景
-type AccBusiFields struct {
-	TimeoutExpress string         `json:"timeout_express"` // 预下单的订单的有效时间，以分钟为单位。如果在有效时间内没有完成付款，则在账户端该订单失效。如用户超时，则账户端完成失效处理，建议不超过15分钟。不传值则默认5分钟，String(2)，选填
-	SubAppId       string         `json:"sub_appid"`       // 子商户公众账号ID，sub_appid（即微信小程序支付-71、公众号支付-51、微信支付-61），此参数必传，只对微信支付生效；拉卡拉钱包情况下，该字段上送LAKALA的openid，String(32)，选填
-	UserId         string         `json:"user_id"`         // 用户标识，用户在子商户sub_appid下的唯一标识，sub_openid，（即微信小程序支付-71、公众号支付-51），此参数必传，只对微信支付有效，String(64)，选填
-	Detail         string         `json:"detail"`          // 商品详情，单品优惠功能字段，详见下文说明，String(1024)，选填
-	GoodsTag       string         `json:"goods_tag"`       // 订单优惠标记，微信平台配置的商品标记，用于优惠券或者满减使用，accountType为WECHAT时，可选填此字段，String(32)，选填
-	Attach         string         `json:"attach"`          // 附加域，附加数据，在查询API和支付通知中原样返回，该字段主要用于商户携带订单的自定义数据。商户定制字段，直接送到账户端，String(128)，选填
-	GoodsDetail    []*GoodsDetail `json:"goods_detail"`    // 商品详情列表，微信商品详情字段说明
-}
-
-// GoodsDetail 微信商品详情字段说明
-type GoodsDetail struct {
-	GoodsId      string `json:"goods_id"`       // 商品ID，由半角的大小写字母、数字、中划线、下划线中的一种或几种组成。如"商品编码"，必填
-	WxpayGoodsId string `json:"wxpay_goods_id"` // 微信支付定义的统一商品编号，String(32)，选填
-	GoodsName    string `json:"goods_name"`     // 商品的实际名称，String(256)，选填
-	Quantity     string `json:"quantity"`       // 用户购买的数量，String(12)，必填
-	Price        string `json:"price"`          // 单价，单位为：分。如果商户有优惠，需传输商户优惠后的单价，String(12)，必填
-}
-
-// NewMergePreorder 创建主扫合单交易请求
-func NewMergePreorder(param *MergePreorderReqData) *MergePreorder {
-	return &MergePreorder{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "3.0",
-		ReqData: param,
-	}
-}
-
-// MergePreorderResponse 主扫合单交易响应结构体
-type MergePreorderResponse struct {
-	Code     string                `json:"code"`      // 响应码，BBS00000表示成功
-	Msg      string                `json:"msg"`       // 响应信息，对响应码的文字描述
-	ReqData  MergePreorderRespData `json:"resp_data"` // 响应业务数据
-	RespTime string                `json:"resp_time"` // 响应时间
-}
-
-// MergePreorderRespData 主扫合单交易响应业务数据
-type MergePreorderRespData struct {
-	MerchantNo    string       `json:"merchant_no"`     // 商户号（待上线），拉卡拉分配的商户号（请求接口中商户号）
-	OutTradeNo    string       `json:"out_trade_no"`    // 商户请求流水号，请求报文中的商户请求流水号
-	TradeNo       string       `json:"trade_no"`        // 拉卡拉交易流水号
-	LogNo         string       `json:"log_no"`          // 拉卡拉对账单流水号
-	SplitInfo     []*SplitInfo `json:"split_info"`      // 拆单信息
-	AccRespFields interface{}  `json:"acc_resp_fields"` // 账户端返回信息域
-}
-
-// SplitInfo 拆单信息
-type SplitInfo struct {
-	SubTradeNo    string `json:"sub_trade_no"`     // 子单交易流水号
-	SubLogNo      string `json:"sub_log_no"`       // 子单对账单流水号
-	OutSubTradeNo string `json:"out_sub_trade_no"` // 外部子交易流水号，商户子交易流水号，商户号下唯一
-	MerchantNo    string `json:"merchant_no"`      // 商户号，拉卡拉分配的商户号
-	MerchantName  string `json:"merchant_name"`    // 商户名称
-	TermNo        string `json:"term_no"`          // 终端号，拉卡拉分配的业务终端号
-	Amount        string `json:"amount"`           // 金额，单位为：分。整数型字符
-}
-
-// WxAccRespFields 微信(71-小程序/微信(51-JSAPI)场景下账户端返回信息域
-type WxAccRespFields struct {
-	PrepayId  string `json:"prepay_id"`  // 预下单ID，预支付交易会话ID
-	PaySign   string `json:"pay_sign"`   // 支付签名信息
-	AppId     string `json:"app_id"`     // 小程序ID，商户注册具有支付权限的小程序成功后即可获得小程序ID
-	TimeStamp string `json:"time_stamp"` // 时间戳，当前的时间
-	NonceStr  string `json:"nonce_str"`  // 随机字符串
-	Package   string `json:"package"`    // 订单详情扩展字符串
-	SignType  string `json:"sign_type"`  // 签名方式，签名类型，支持RSA
-	SubMchId  string `json:"sub_mch_id"` // 子商户号，账户端子商户号
-}
-
-// SuccessOrFail 判断主扫合单交易是否成功
-func (m *MergePreorderResponse) SuccessOrFail() bool {
-	return m.Code == "BBS00000"
-}

model/mrchAuthStateQuery.go

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

model/orderSplitLedger.go

@@ -1,57 +0,0 @@
-package model
-
-import "github.com/black1552/lkl_sdk/consts"
-
-// OrderSplitLedgerRequest 订单分账请求结构体
-// 用于发起订单分账操作，支持向多个接收方进行分账
-// 拉卡拉SDK接口文档：订单分账接口
-
-type OrderSplitLedgerRequest struct {
-	ReqData *OrderSplitLedgerReqData `json:"req_data"` // 请求业务数据
-	Version string                   `json:"version"`  // 接口版本号
-	ReqTime string                   `json:"req_time"` // 请求时间，格式为yyyyMMddHHmmss
-}
-
-// OrderSplitLedgerReqData 订单分账请求业务数据结构体
-// 包含订单分账所需的详细业务参数
-
-type OrderSplitLedgerReqData struct {
-	MerchantNo    string                       `json:"merchant_no"`          // 商户号，必传，长度32
-	LogNo         string                       `json:"log_no"`               // 拉卡拉对账单流水号，必传，长度14，posp流水号，用于查询结算
-	LogDate       string                       `json:"log_date"`             // 交易日期，必传，长度8，posp日期，格式为yyyyMMdd，用于查询结算
-	OutSeparateNo string                       `json:"out_separate_no"`      // 商户分账指令流水号，必传，长度32，每个商户号下唯一，否则会校验失败
-	TotalAmt      string                       `json:"total_amt"`            // 分账总金额，必传，长度15，单位为分
-	LklOrgNo      string                       `json:"lkl_org_no"`           // 拉卡拉机构编号，条件必传，长度16
-	CalType       consts.CalType               `json:"cal_type"`             // 分账计算类型，条件必传，长度2，取值说明：0-按照指定金额，1-按照指定比例，默认0
-	NotifyUrl     string                       `json:"notify_url"`           // 回调地址，条件必传，长度128，分账、分账撤销或分账回退时，通过该地址通知商户最终处理结果，不传时不回调
-	RecvDatas     []*OrderSplitLedgerRecvDatas `json:"recv_datas,omitempty"` // 分账接收数据对象，条件必传，列表类型，分账接收方编号必须已创建
-}
-
-type OrderSplitLedgerRecvDatas struct {
-	RecvMerchantNo string `json:"recv_merchant_no"` // 接收方商户号，条件必传，长度32，分账接收方商户号，分给自己时使用，需和merchantNo一样，否则检查报错；分账接收方商户号和分账接收方只能填写一个
-	RecvNo         string `json:"recv_no"`          // 分账接收方编号，条件必传，长度32，分账接收方编号，分给他人时使用；分账接收方商户号和分账接收方只能填写一个
-	SeparateValue  string `json:"separate_value"`   // 分账数值，必传，长度32，calType为0时按照固定金额分账（单位：分），calType为1时按照比例分账（单位：百分比的小数值，如0.55表示55%）
-}
-
-// OrderSplitLedgerResponse 订单分账响应结构体
-// 包含订单分账操作的处理结果信息
-
-type OrderSplitLedgerResponse struct {
-	Msg      string `json:"msg"`       // 响应消息，描述响应结果
-	RespTime string `json:"resp_time"` // 响应时间，格式为yyyyMMddHHmmss
-	Code     string `json:"code"`      // 响应码，SACS0000表示成功
-	RespData struct {
-		SeparateNo    string `json:"separate_no"`     // 分账指令流水号，必传，长度32，分账系统生成唯一流水
-		OutSeparateNo string `json:"out_separate_no"` // 商户订单号，必传，长度32，请求报文中的商户外部订单号
-		Status        string `json:"status"`          // 分账状态，条件必传，长度16，取值说明：处理中-PROCESSING，已受理-ACCEPTED，成功-SUCCESS，失败-FAIL
-		LogNo         string `json:"log_no"`          // 拉卡拉对账单流水号，条件必传，长度14，请求透返
-		LogDate       string `json:"log_date"`        // 拉卡拉订单日期，条件必传，长度8，posp日期，格式为yyyyMMdd，用于查询结算
-		TotalAmt      string `json:"total_amt"`       // 分账总金额，条件必传，长度15，单位为分
-	} `json:"resp_data"` // 响应业务数据，当code为SACS0000时返回
-}
-
-// SuccessOrFail 判断分账请求是否成功
-// 返回true表示成功，false表示失败
-func (s *OrderSplitLedgerResponse) SuccessOrFail() bool {
-	return s.Code == "SACS0000"
-}

model/orderSplitLedgerFallback.go

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

model/preorder.go

@@ -1,80 +0,0 @@
-package model
-
-import (
-	"github.com/black1552/lkl_sdk/consts"
-	"github.com/gogf/gf/v2/os/gtime"
-)
-
-// Preorder 预下单请求结构体
-type Preorder struct {
-	ReqTime string           `json:"req_time"` // 请求时间，格式：YYYYMMDDHHMMSS
-	Version string           `json:"version"`  // 接口版本号，固定值"3.0"
-	ReqData *PreorderReqData `json:"req_data"` // 请求业务数据
-}
-
-// PreorderReqData 预下单请求业务数据
-type PreorderReqData struct {
-	MerchantNo   string             `json:"merchant_no"`  // 商户号，拉卡拉分配的商户号，String(32)
-	TermNo       string             `json:"term_no"`      // 终端号，拉卡拉分配的业务终端号，String(32)
-	OutTradeNo   string             `json:"out_trade_no"` // 商户交易流水号，商户系统唯一，对应数据库表中外请求流水号，String(32)
-	AccountType  consts.AccountType `json:"account_type"` // 钱包类型，微信：WECHAT 支付宝：ALIPAY 银联：UQRCODEPAY 翼支付：BESTPAY 苏宁易付宝：SUNING 拉卡拉支付账户：LKLACC 网联小钱包：NUCSPAY 京东钱包：JD，String(32)
-	TransType    consts.TransType   `json:"trans_type"`   // 接入方式，41:NATIVE（ALIPAY, 云闪付支持, 京东白条分期）51:JSAPI（微信公众号支付, 支付宝服务窗、JS支付, 翼支付JS支付, 拉卡拉钱包支付, 京东白条分期）71:微信小程序支付61:APP支付（微信APP支付），String(2)
-	TotalAmount  string             `json:"total_amount"` // 金额，单位分，整数型字符，String(12)
-	NotifyUrl    string             `json:"notify_url"`   // 商户通知地址，商户通知地址，如果上传，且 pay_order_no 不存在情况下，则按此地址通知商户，String(128)
-	SettleType   consts.SettleType  `json:"settle_type"`  // “0”或者空，常规结算方式，如需接拉卡拉分账通需传“1”，商户未开通分账之前切记不用上送此参数。
-	LocationInfo struct {
-		RequestIp string `json:"request_ip"` // 请求方IP地址，存在必填，格式如36.45.36.95，String(64)
-		Location  string `json:"location"`   // 纬度,经度，商户终端的地理位置，银联二维码交易必填，整体格式：纬度,经度，+表示北纬、东经，-表示南纬、西经。经度格式：1位正负号+3位整数+1位小数点+5位小数；纬度格式：1位正负号+2位整数+1位小数点+6位小数；举例：+31.221345,+121.12345，String(32)
-	} `json:"location_info"` // 地址位置信息，Object
-	Subject       string         `json:"subject"`         // 订单标题，用于简单描述订单或商品主题，传输给账户端（账户端控制，实际最多42个字节），微信支付必送，String(42)
-	AccBusiFields *AccBusiFields `json:"acc_busi_fields"` // 账户业务字段，Object
-}
-
-func NewPreorder(param *PreorderReqData) *Preorder {
-	return &Preorder{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "3.0",
-		ReqData: param,
-	}
-}
-
-// PreorderResponse 预下单响应结构体
-type PreorderResponse struct {
-	Code     string   `json:"code"`      // 响应码，BBS00000表示成功
-	Msg      string   `json:"msg"`       // 响应信息，对响应码的文字描述
-	ReqData  *ReqData `json:"resp_data"` // 响应业务数据
-	RespTime string   `json:"resp_time"` // 响应时间
-}
-
-// ReqData 响应业务数据
-type ReqData struct {
-	MerchantNo       string              `json:"merchant_no"`        // 商户号
-	OutTradeNo       string              `json:"out_trade_no"`       // 外部订单号（商户订单号）
-	TradeNo          string              `json:"trade_no"`           // 交易号，拉卡拉生成的订单号
-	LogNo            string              `json:"log_no"`             // 拉卡拉对账单流水号
-	SettleMerchantNo string              `json:"settle_merchant_no"` // 结算商户号
-	SettleTermNo     string              `json:"settle_term_no"`     // 结算终端号
-	AccRespFields    *WxPreorderResponse `json:"acc_resp_fields"`    // 支付通道返回的具体信息
-}
-
-// WxPreorderResponse 支付通道返回的具体信息
-type WxPreorderResponse struct {
-	Code        string `json:"code"`          // 返回码
-	CodeImage   string `json:"code_image"`    // 二维码图片Base64编码
-	PrepayId    string `json:"prepay_id"`     // 预支付ID
-	AppId       string `json:"app_id"`        // 应用ID
-	PaySign     string `json:"pay_sign"`      // 签名
-	TimeStamp   string `json:"time_stamp"`    // 时间戳
-	NonceStr    string `json:"nonce_str"`     // 随机字符串
-	Package     string `json:"package"`       // 订单详情扩展字符串
-	SignType    string `json:"sign_type"`     // 签名方式
-	FormData    string `json:"form_data"`     // 表单数据
-	RedirectUrl string `json:"redirect_url"`  // 重定向URL
-	BestPayInfo string `json:"best_pay_info"` // 翼支付信息
-	PartnerId   string `json:"partner_id"`    // 合作伙伴ID
-	SubMchId    string `json:"sub_mch_id"`    // 子商户ID
-}
-
-func (p *PreorderResponse) SuccessOrFail() bool {
-	return p.Code == "BBS00000"
-}

model/queryLedgerMer.go

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

model/queryMer.go

@@ -1,107 +0,0 @@
-// Package model 提供数据模型定义
-package model
-
-// QueryMerRequest 商户进件信息查询请求
-// 接入方通过开放平台查询进件信息，返回报文同进件审核完成主动通知报文
-// 参考文档: https://o.lakala.com/#/home/document/detail?id=102
-
-type QueryMerRequest struct {
-	// ReqData 请求业务参数
-	ReqData *QueryMerRequestData `json:"reqData"`
-	// Ver 版本号
-	Ver string `json:"ver"`
-	// Timestamp 时间戳
-	Timestamp int64 `json:"timestamp"`
-	// ReqId 请求ID
-	ReqId string `json:"reqId"`
-}
-
-// QueryMerRequestData 商户进件信息查询请求业务参数
-
-type QueryMerRequestData struct {
-	// Version 接口版本号
-	Version string `json:"version"`
-	// OrderNo 订单编号（便于后续跟踪排查问题及核对报文）
-	// 14位年月日时（24小时制）分秒+8位的随机数（不重复）如：2021020112000012345678
-	OrderNo string `json:"orderNo"`
-	// OrgCode 机构代码
-	OrgCode string `json:"orgCode"`
-	// ContractId 进件ID
-	ContractId string `json:"contractId"`
-}
-
-// QueryMerResponse 商户进件信息查询响应
-
-type QueryMerResponse struct {
-	// CmdRetCode 全局返回码
-	CmdRetCode string `json:"cmdRetCode"`
-	// ReqId 请求ID
-	ReqId string `json:"reqId"`
-	// RespData 响应业务参数
-	RespData *QueryMerResponseData `json:"respData"`
-	// RetCode 返回码
-	RetCode string `json:"retCode"`
-	// md 随机字符串
-	Md string `json:"md"`
-	// RetMsg 返回消息
-	RetMsg string `json:"retMsg"`
-	// Timestamp 时间戳
-	Timestamp int64 `json:"timestamp"`
-	// Ver 版本号
-	Ver string `json:"ver"`
-}
-
-// QueryMerResponseData 商户进件信息查询响应业务参数
-
-type QueryMerResponseData struct {
-	// OrgCode 机构代码
-	OrgCode string `json:"orgCode"`
-	// OrderNo 订单号
-	OrderNo string `json:"orderNo"`
-	// ContractId 进件ID
-	ContractId string `json:"contractId"`
-	// ContractStatus 进件状态
-	// 未提交：NO_COMMIT
-	// 已提交：COMMIT
-	// 提交失败：COMMIT_FAIL
-	// 转人工审核：MANUAL_AUDIT
-	// 审核中：REVIEW_ING
-	// 审核通过：WAIT_FOR_CONTACT
-	// 审核驳回：INNER_CHECK_REJECTED
-	ContractStatus string `json:"contractStatus"`
-	// ContractMemo 进件描述
-	// 进件审核通过，返回"审核通过"
-	// 进件审核驳回，返回具体的驳回理由
-	ContractMemo string `json:"contractMemo"`
-	// MerInnerNo 拉卡拉内部商户号（该属性审核通过才有）
-	MerInnerNo string `json:"merInnerNo"`
-	// MerCupNo 银联商户号（该属性审核通过才有）
-	MerCupNo string `json:"merCupNo"`
-	// TermDatas 终端列表信息（该属性审核通过并且是增商、增终进件才有）
-	TermDatas []*TermData `json:"termDatas"`
-}
-
-// TermData 终端数据信息
-
-type TermData struct {
-	// ShopId 网点编号
-	ShopId string `json:"shopId"`
-	// TermId 终端编号
-	TermId string `json:"termId"`
-	// TermNo 终端号
-	TermNo string `json:"termNo"`
-	// BusiTypeCode 业务代码（参考【业务类型字典表】文档）
-	BusiTypeCode string `json:"busiTypeCode"`
-	// BusiTypeName 业务名称
-	BusiTypeName string `json:"busiTypeName"`
-	// ProductName 产品名称
-	ProductName string `json:"productName"`
-	// ProductCode 产品代码
-	ProductCode string `json:"productCode"`
-	// DevSerialNo 终端设备序列号
-	DevSerialNo string `json:"devSerialNo"`
-}
-
-func (t *QueryMerResponse) SuccessOrFail() bool {
-	return t.RetCode == "000000"
-}

model/querySubMerInfo.go

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

model/reConfSubmit.go

@@ -1,61 +0,0 @@
-package model
-
-// ReConfSubmitRequest 进件复议提交请求
-// 接入方在进件被驳回后（由于系统自动校验无法通过），调用此接口提交进件，转人工审核
-// 参考文档: https://o.lakala.com/#/home/document/detail?id=94
-
-type ReConfSubmitRequest struct {
-	// ReqData 请求业务参数
-	ReqData *ReConfSubmitRequestData `json:"reqData"`
-	// Ver 版本号
-	Ver string `json:"ver"`
-	// Timestamp 时间戳
-	Timestamp int64 `json:"timestamp"`
-	// ReqId 请求ID
-	ReqId string `json:"reqId"`
-}
-
-// ReConfSubmitRequestData 进件复议提交请求业务参数
-
-type ReConfSubmitRequestData struct {
-	// Version 接口版本号
-	Version string `json:"version"`
-	// OrderNo 订单编号（便于后续跟踪排查问题及核对报文）
-	// 14位年月日时（24小时制）分秒+8位的随机数（不重复）如：2021020112000012345678
-	OrderNo string `json:"orderNo"`
-	// OrgCode 机构代码
-	OrgCode string `json:"orgCode"`
-	// ContractId 进件ID
-	ContractId string `json:"contractId"`
-}
-
-// ReConfSubmitResponse 进件复议提交响应
-
-type ReConfSubmitResponse struct {
-	// CmdRetCode 全局返回码
-	CmdRetCode string `json:"cmdRetCode"`
-	// ReqId 请求ID
-	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 时间戳
-	Timestamp int64 `json:"timestamp"`
-	// 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"
-}

model/refund.go

@@ -1,74 +0,0 @@
-package model
-
-import (
-	"github.com/black1552/lkl_sdk/consts"
-	"github.com/gogf/gf/v2/os/gtime"
-)
-
-// Refund 退款请求结构体
-type Refund struct {
-	ReqTime string         `json:"req_time"` // 请求时间，格式：YYYYMMDDHHMMSS
-	Version string         `json:"version"`  // 接口版本号，固定值"3.0"
-	ReqData *RefundReqData `json:"req_data"` // 请求业务数据
-}
-
-// RefundReqData 退款请求业务数据
-type RefundReqData struct {
-	MerchantNo    string               `json:"merchant_no"`     // 商户号，拉卡拉分配的商户号，String(32)，必填
-	TermNo        string               `json:"term_no"`         // 终端号，拉卡拉分配的业务终端号，String(32)，必填
-	OutTradeNo    string               `json:"out_trade_no"`    // 商户请求流水号，商户系统唯一，String(32)，必填
-	RefundAmount  string               `json:"refund_amount"`   // 退款金额，单位分，整数型字符，String(12)，必填
-	RefundAccMode consts.RefundAccMode `json:"refund_acc_mode"` // 退款账户模式，String(2)，必填，00-调用户余额 65-调商户余额 66-调终端余额 30-调账户
-	LocationInfo  struct {
-		RequestIp string `json:"request_ip"` // 请求方IP地址，请求方的IP地址，存在必填，格式如36.45.36.95，String(64)，必填
-	} `json:"location_info"` // 地址位置信息，Object，必填
-	NotifyUrl        string              `json:"notify_url"`          // 后台通知地址，交易结果通知地址，String(128)，选填
-	RefundAmtSts     consts.RefundAmtSts `json:"refund_amt_sts"`      // 退货资金状态 String(2) 00-为默认，01-为分账；分账交易退款必须填写
-	OriginLogNo      string              `json:"origin_log_no"`       // 拉卡拉对账单流水号，正常退款的拉卡拉对账单流水号，String(14)，选填
-	OriginOutTradeNo string              `json:"origin_out_trade_no"` // 原始交易商户流水号，String(32)，选填
-	OriginTradeNo    string              `json:"origin_trade_no"`     // 原交易拉卡拉交易订单号，String(32)，选填
-	RefundSplitMsg   string              `json:"refund_split_msg"`    // 退款分账状态，String(2)，选填，00-为默认，01-为分账；分账交易退款必须填写。需要退款上送该笔的分账状态，为分账时，是退分账前处理，还是退分账后处理
-}
-
-// NewRefund 创建退款请求
-func NewRefund(param *RefundReqData) *Refund {
-	return &Refund{
-		ReqTime: gtime.Now().Format("YmdHis"),
-		Version: "3.0",
-		ReqData: param,
-	}
-}
-
-// RefundResponse 退款响应结构体
-type RefundResponse struct {
-	Code     string         `json:"code"`      // 响应码，"000000"表示成功
-	Msg      string         `json:"msg"`       // 响应信息，对响应码的文字描述
-	RespData RefundRespData `json:"resp_data"` // 响应业务数据
-	RespTime string         `json:"resp_time"` // 响应时间
-}
-
-// RefundRespData 退款响应业务数据
-type RefundRespData struct {
-	TradeState       string `json:"trade_state"`         // 交易状态，String(15)，必填，INIT-初始化（需商户确认结果）；SUCCESS-交易成功；FAIL-交易失败；REFUND-交易退款中（需商户确认结果）；PROCESSING-交易处理中（需商户确认结果）；TIMEOUT-请求超时（需商户确认结果）；EXCEPTION-异常（失败）
-	RefundType       string `json:"refund_type"`         // 退款模式，String(20)，必填
-	MerchantNo       string `json:"merchant_no"`         // 商户号，拉卡拉分配的商户号，String(32)，必填
-	OutTradeNo       string `json:"out_trade_no"`        // 商户请求流水号，请求报文中的商户请求流水号，String(32)，必填
-	TradeNo          string `json:"trade_no"`            // 拉卡拉交易流水号，String(32)，必填
-	LogNo            string `json:"log_no"`              // 拉卡拉对账单流水号，String(14)，必填
-	AccType          string `json:"acc_type"`            // 账户类型，String(32)，必填
-	TotalAmount      string `json:"total_amount"`        // 交易金额，单位分，整数型字符，String(12)，必填
-	RefundAmount     string `json:"refund_amount"`       // 申请退款金额，单位分，整数型字符，String(12)，必填
-	PayedAmount      string `json:"payed_amount"`        // 实际退款金额，单位分，整数型字符，String(12)，必填
-	TradeTime        string `json:"trade_time"`          // 退款时间，实际退款时间，格式：yyyyMMddHHmmss，String(14)，选填
-	OriginLogNo      string `json:"origin_log_no"`       // 原拉卡拉对账单流水号，原交易的拉卡拉对账单流水号，String(14)，选填
-	OriginOutTradeNo string `json:"origin_out_trade_no"` // 原商户请求流水号，原交易中的商户请求流水号，String(32)，选填
-	OriginTradeNo    string `json:"origin_trade_no"`     // 原交易拉卡拉交易订单号，String(32)，选填
-	UpCouponInfo     string `json:"up_coupon_info"`      // 银联优惠券信息，目标字段，单位是银联侧返回的四部分内容：{"fundChannel": "BOC", "amount": "10"}，String(500)，选填
-	TanteInfo        string `json:"tante_info"`          // 淘方信息，目标字段，数据是淘方侧返回的四部分内容：{"fundChannel": "BOC", "amount": "10"}，String(32)，选填
-	ChannelRetDesc   string `json:"channel_ret_desc"`    // 渠道返回描述，String，必填，codeMsg: "R000000-成功", "R011122-渠道处理超时"
-}
-
-// SuccessOrFail 判断退款交易是否成功
-func (r *RefundResponse) SuccessOrFail() bool {
-	return r.Code == "000000"
-}

model/separate.go

@@ -1,45 +0,0 @@
-package model
-
-import "github.com/black1552/lkl_sdk/consts"
-
-type SeparateRequest struct {
-	ReqData *SeparateReqData `json:"req_data"` // 请求数据
-	Version string           `json:"version"`  // 版本号
-	ReqTime string           `json:"req_time"` // 请求时间
-}
-
-type SeparateReqData struct {
-	MerchantNo    string               `json:"merchant_no"`     // 商户号
-	LogDate       string               `json:"log_date"`        // 交易日期 yyyyMMdd，查清结算用
-	LogNo         string               `json:"log_no"`          // 拉卡拉对账单流水号
-	OutSeparateNo string               `json:"out_separate_no"` // 商户分账指令流水号
-	TotalAmt      string               `json:"total_amt"`       // 分账总金额 [单位：分]
-	LklOrgNo      string               `json:"lkl_org_no"`      // 拉卡拉机构编号 非必填
-	CalType       consts.CalType       `json:"cal_type"`        // 分账计算类型 0- 按照指定金额，1- 按照指定比例。默认 0 非必填
-	SeparateType  string               `json:"separate_type"`
-	NotifyUrl     string               `json:"notify_url"` // 回调地址 分账，分账撤销或分账回退时，是异步接口。通过该地址通知商户最终处理结果。不传时，不回调
-	RecvDatas     []*SeparateRecvDatas `json:"recv_datas"` // 分账接收数据对象 分账接收方编号必须已创建
-}
-type SeparateRecvDatas struct {
-	RecvMerchantNo string `json:"recv_merchant_no,omitempty"` // 接收方商户号 分账接收方商户号，分给自己时使用，需和merchantNo一样，否则检查报错；分账接收方商户号 和 分账接收方 只能填写一个。
-	SeparateValue  string `json:"separate_value"`             // 分账数值 calType为0时，按照固定金额分账，单位：分 calType为1时，按照比例分账，单位：百分比的小数值，比如0.55 （55%）
-	RecvNo         string `json:"recv_no,omitempty"`          // 分账接收方编号 分账接收方编号, 分给他人时使用；分账接收方商户号 和 分账接收方 只能填写一个。
-}
-
-type SeparateResponse struct {
-	Msg      string `json:"msg"`
-	RespTime string `json:"resp_time"`
-	Code     string `json:"code"`
-	RespData struct {
-		TotalAmt      string `json:"total_amt"`       // 分账总金额 单位：分
-		LogDate       string `json:"log_date"`        // 拉卡拉订单日期 posp日期，yyyyMMdd，查清结算用
-		SeparateNo    string `json:"separate_no"`     // 分账指令流水号 分账系统生成唯一流水
-		LogNo         string `json:"log_no"`          // 拉卡拉对账单流水号 请求透返
-		OutSeparateNo string `json:"out_separate_no"` // 商户订单号 请求报文中的商户外部订单号
-		Status        string `json:"status"`          // 分账状态 处理中：PROCESSING, 已受理：ACCEPTED, 成功：SUCCESS, 失败：FAIL
-	} `json:"resp_data"`
-}
-
-func (s *SeparateResponse) SuccessOrFail() bool {
-	return s.Code == "SACS0000"
-}

model/splitBalanceQuery.go

@@ -1,39 +0,0 @@
-package model
-
-// SplitBalanceRequest 可分账金额查询请求结构体
-// 用于查询指定交易的可分账金额信息
-// 拉卡拉SDK接口文档：可分账金额查询接口
-
-type SplitBalanceRequest struct {
-	ReqData *SplitBalanceReqData `json:"req_data"` // 请求业务数据
-	Version string               `json:"version"`   // 接口版本号
-	ReqTime string               `json:"req_time"`  // 请求时间，格式为yyyyMMddHHmmss
-}
-
-// SplitBalanceReqData 可分账金额查询请求业务数据结构体
-// 包含可分账金额查询所需的查询参数
-
-type SplitBalanceReqData struct {
-	MerchantNo string `json:"merchant_no"` // 商户号，必传，长度32
-	LogDate    string `json:"log_date"`    // 拉卡拉对账单交易日期，必传，长度8，格式为yyyyMMdd，用于查询结算
-	LogNo      string `json:"log_no"`      // 拉卡拉对账单流水号，必传，长度14，对应pos流水号，用于查询结算
-}
-// SplitBalanceResponse 可分账金额查询响应结构体
-// 包含可分账金额查询的结果信息
-
-type SplitBalanceResponse struct {
-	Msg      string `json:"msg"`       // 响应消息，描述响应结果
-	RespTime string `json:"resp_time"` // 响应时间，格式为yyyyMMddHHmmss
-	Code     string `json:"code"`      // 响应码，SACS0000表示成功
-	RespData struct {
-		MerchantNo       string `json:"merchant_no"`       // 商户号，请求返回
-		TotalSeparateAmt string `json:"total_separate_amt"` // 总分账金额，必传，长度15，单位为分
-		CanSeparateAmt   string `json:"can_separate_amt"`   // 可分账金额，必传，长度15，单位为分
-		LogDate          string `json:"log_date"`          // 拉卡拉对账单交易日期，必传，长度8，格式为yyyyMMdd
-		LogNo            string `json:"log_no"`            // 拉卡拉对账单流水号，必传，长度14，请求返回
-	} `json:"resp_data"` // 响应业务数据，当code为SACS0000时返回
-}
-
-func (s *SplitBalanceResponse) SuccessOrFail() bool {
-	return s.Code == "SACS0000"
-}

model/tradeQuery.go

@@ -1,73 +0,0 @@
-package model
-
-// TradeQuery 交易查询请求结构体
-type TradeQuery struct {
-	ReqTime    string             `json:"req_time"`     // 请求时间
-	Version    string             `json:"version"`      // API版本号
-	OutOrgCode string             `json:"out_org_code"` // 外部机构码
-	ReqData    *TradeQueryReqData `json:"req_data"`     // 请求数据
-}
-
-// TradeQueryReqData 交易查询请求数据结构体
-type TradeQueryReqData struct {
-	MerchantNo string `json:"merchant_no"`  // 商户号，必传
-	TermNo     string `json:"term_no"`      // 终端号，必传
-	OutTradeNo string `json:"out_trade_no"` // 商户交易流水号，条件必传，与trade_no必传其一
-}
-
-// TradeQueryResponse 交易查询响应结构体
-type TradeQueryResponse struct {
-	Msg      string `json:"msg"`       // 响应消息
-	RespTime string `json:"resp_time"` // 响应时间
-	Code     string `json:"code"`      // 响应码，000000表示成功
-	RespData struct {
-		MerchantNo    string `json:"merchant_no"`     // 商户号，必传
-		OutTradeNo    string `json:"out_trade_no"`    // 商户请求流水号，必传
-		TradeNo       string `json:"trade_no"`        // 拉卡拉商户订单号，必传
-		LogNo         string `json:"log_no"`          // 拉卡拉对账流水号，必传
-		TradeMainType string `json:"trade_main_type"` // 交易大类，条件必传（PREORDER-主扫，MICROPAY-被扫，REFUND-退款，CANCEL-撤销）
-		SplitAttr     string `json:"split_attr"`      // 拆单属性，条件必传（M-主单，S-子单）
-		SplitInfo     []struct {
-			SubTradeNo    string `json:"sub_trade_no"`     // 子单交易流水号，必传
-			SubLogNo      string `json:"sub_log_no"`       // 子单对账单单流水号，必传
-			OutSubTradeNo string `json:"out_sub_trade_no"` // 外部子交易流水号，必传
-			MerchantNo    string `json:"merchant_no"`      // 商户号，必传
-			MerchantName  string `json:"merchant_name"`    // 商户名称，必传
-			TermNo        string `json:"term_no"`          // 终端号，必传
-			Amount        string `json:"amount"`           // 金额，必传（单位分）
-		} `json:"split_info"` // 拆单信息，条件必传（如果查询订单是主单，则返回）
-		RefundSplitInfo []struct {
-			OutSubTradeNo string `json:"out_sub_trade_no"` // 外部子退款交易流水号，必传
-			MerchantNo    string `json:"merchant_no"`      // 商户号，必传
-			TermNo        string `json:"term_no"`          // 终端号，必传
-			RefundAmount  string `json:"refund_amount"`    // 申请退款金额，必传（单位分）
-			SubTradeNo    string `json:"sub_trade_no"`     // 拉卡分子交易流水号，条件必传
-			SubLogNo      string `json:"sub_log_no"`       // 对账单子流水号，条件必传
-			TradeState    string `json:"trade_state"`      // 子交易状态，条件必传（SUCCESS-交易成功 FAIL-交易失败）
-			ResultCode    string `json:"result_code"`      // 处理结果码，条件必传
-			ResultMsg     string `json:"result_msg"`       // 处理描述，条件必传
-		} `json:"refund_split_info"` // 合单退款拆单信息，条件必传（如果查询订单是退款主单，则返回）
-		AccTradeNo             string                 `json:"acc_trade_no"`              // 账户端交易订单号，必传
-		AccountType            string                 `json:"account_type"`              // 钱包类型，必传（微信: WECHAT 支付宝: ALIPAY 银联: UQRCODEPAY 翼支付: BESTPAY 苏宁支付: SUNING）
-		TradeState             string                 `json:"trade_state"`               // 交易状态，必传（INIT-初始化 CREATE-下单成功 SUCCESS-交易成功 FAIL-交易失败 DEAL-交易处理中 UNKNOWN-未知状态 CLOSE-订单关闭 PART_REFUND-部分退款 REFUND-全部退款）
-		TradeStateDesc         string                 `json:"trade_state_desc"`          // 交易状态描述，条件必传
-		TotalAmount            string                 `json:"total_amount"`              // 订单金额，必传（单位分）
-		PayerAmount            string                 `json:"payer_amount"`              // 付款人实付金额，条件必传（单位分）
-		AccSettleAmount        string                 `json:"acc_settle_amount"`         // 账户端结算金额，条件必传（单位分）
-		AccMdiscountAmount     string                 `json:"acc_mdiscount_amount"`      // 商户侧优惠金额，条件必传（单位分）
-		AccDiscountAmount      string                 `json:"acc_discount_amount"`       // 账户端优惠金额，条件必传（单位分）
-		AccOtherDiscountAmount string                 `json:"acc_other_discount_amount"` // 账户端其它优惠金额，条件必传（单位分）
-		TradeTime              string                 `json:"trade_time"`                // 交易完成时间，条件必传（yyyyMMddHHmmss）
-		UserId1                string                 `json:"user_id1"`                  // 用户标识1，条件必传（微信sub_open_id 支付宝buyer_login_id 买家支付账号）
-		UserId2                string                 `json:"user_id2"`                  // 用户标识2，条件必传（微信open_id 支付宝buyer_user_id 银user_id）
-		BankType               string                 `json:"bank_type"`                 // 付款银行，条件必传
-		CardType               string                 `json:"card_type"`                 // 银行卡类型，条件必传（00: 借记卡 01: 贷记卡 02: 微信零钱 03: 支付宝花呗 04: 支付宝其他 05: 数字货币 06: 拉卡拉支付账户 99: 未知）
-		AccActivityId          string                 `json:"acc_activity_id"`           // 活动ID，条件必传（在账户端商户后台配置的批次ID）
-		TradeReqDate           string                 `json:"trade_req_date"`            // 交易请求日期，必传（yyyyMMdd）
-		AccRespFields          map[string]interface{} `json:"acc_resp_fields"`           // 账户端返回信息域，条件必传
-	} `json:"resp_data"` // 响应数据
-}
-
-func (t *TradeQueryResponse) SuccessOrFail() bool {
-	return t.Code == "BBS00000"
-}

model/uploadFile.go

@@ -1,38 +0,0 @@
-package model
-
-import "github.com/black1552/lkl_sdk/consts"
-
-type UploadFileRequest struct {
-	ReqData   *UploadFileReqData `json:"reqData"`
-	Ver       string             `json:"ver"`
-	Timestamp string             `json:"timestamp"`
-	ReqId     string             `json:"reqId"`
-}
-
-type UploadFileReqData struct {
-	Version    string         `json:"version"`
-	OrderNo    string         `json:"orderNo"`
-	AttType    consts.AttType `json:"attType"`
-	AttExtName string         `json:"attExtName"`
-	AttContext string         `json:"attContext"`
-	OrgCode    string         `json:"orgCode"`
-}
-
-type UploadFileResponse struct {
-	CmdRetCode string `json:"cmdRetCode"`
-	ReqId      string `json:"reqId"`
-	RespData   struct {
-		AttType   string `json:"attType"`
-		OrderNo   string `json:"orderNo"`
-		OrgCode   string `json:"orgCode"`
-		AttFileId string `json:"attFileId"`
-	} `json:"respData"`
-	RetCode   string `json:"retCode"`
-	RetMsg    string `json:"retMsg"`
-	Timestamp int64  `json:"timestamp"`
-	Ver       string `json:"ver"`
-}
-
-func (u *UploadFileResponse) SuccessOrFail() bool {
-	return u.RetCode == "000000"
-}

model/withdraw.go

@@ -1,69 +0,0 @@
-package model
-
-import "github.com/black1552/lkl_sdk/consts"
-
-// WithdrawRequest 提现请求结构体
-// 用于向拉卡拉接口发送提现请求
-// 包含请求头信息和业务数据
-type WithdrawRequest struct {
-	// 请求业务数据
-	ReqData *WithdrawReqData `json:"req_data"`
-	// 接口版本号
-	Version string `json:"version"`
-	// 请求时间，格式为yyyyMMddHHmmss
-	ReqTime string `json:"req_time"`
-}
-
-// WithdrawReqData 提现请求业务数据结构体
-// 包含提现所需的具体业务参数
-// 用于申请账户资金提现
-type WithdrawReqData struct {
-	// bmcp机构号，必传，最大长度32
-	OrgNo string `json:"org_no"`
-	// 商户号，必传，最大长度32，822商户号，SR分账接收方编号
-	MerchantNo string `json:"merchant_no"`
-	// 提现金额（单位：元），必传，最大长度32
-	DrawAmt string `json:"draw_amt"`
-	// 通知地址，非必传，最大长度256
-	NotifyUrl string `json:"notify_url"`
-	// 商户订单号（商户系统唯一），非必传，最大长度256
-	MerOrderNo string `json:"mer_order_no"`
-	// 账号（若该参数上送，则payType将无效），非必传，最大长度32
-	PayNo string `json:"pay_no"`
-	// 账号类型（01：收款账户，04：分账接收方账户）未上送则默认01，必传，最大长度32，分账接收方提现时需填04
-	PayType consts.PayType `json:"pay_type"`
-	// 备注信息，非必传，最大长度64
-	Remark string `json:"remark"`
-	// 摘要，非必传，最大长度64
-	Summary string `json:"summary"`
-	// 结算银行ID，非必传，最大长度32
-	BankId string `json:"bank_id"`
-}
-
-// WithdrawResponse 提现响应结构体
-// 拉卡拉接口返回的提现响应数据
-// 包含响应状态码、消息和业务数据
-type WithdrawResponse struct {
-	// 响应状态码，000000表示成功
-	Code string `json:"code"`
-	// 响应消息
-	Msg string `json:"msg"`
-	// 响应业务数据，当code为000000时返回
-	RespData *WithdrawRespData `json:"resp_data"`
-}
-
-// WithdrawRespData 提现响应业务数据结构体
-// 包含提现返回的具体业务信息
-type WithdrawRespData struct {
-	// 提现流水号，必传
-	DrawJnl string `json:"draw_jnl"`
-	// 商户订单号，必传
-	MerOrderNo string `json:"mer_order_no"`
-}
-
-// SuccessOrFail 判断提现请求是否成功
-// 成功条件：响应码为000000
-// 返回值：true表示成功，false表示失败
-func (resp *WithdrawResponse) SuccessOrFail() bool {
-	return resp.Code == "000000"
-}

sdk.go

@@ -0,0 +1,20 @@
+package lklSDK
+
+import (
+	"context"
+
+	"github.com/black1552/lkl_sdk/basePay/labs"
+	"github.com/black1552/lkl_sdk/unifiedreturn"
+)
+
+type SDK struct {
+	labs          *labs.Labs
+	unifiedReturn *unifiedreturn.Server
+}
+
+func NewSDK(ctx context.Context, cfgJson string) *SDK {
+	return &SDK{
+		labs:          labs.NewLabs(ctx, cfgJson),
+		unifiedReturn: unifiedreturn.NewServer(ctx, cfgJson),
+	}
+}

unifiedreturn/mergerefund/api.go

@@ -0,0 +1,35 @@
+package mergerefund
+
+import (
+	"github.com/black1552/lkl_sdk/common"
+	"github.com/black1552/lkl_sdk/consts"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type MergeRefund struct {
+	client *common.Client[ResponseMergeRefund]
+}
+
+func NewMergeRefund(client *common.Client[ResponseMergeRefund]) *MergeRefund {
+	return &MergeRefund{
+		client: client,
+	}
+}
+func (t *MergeRefund) MergeRefund(req *RequestDataMergeRefund) (*ResponseMergeRefund, error) {
+	// 构建BaseModel请求
+	baseReq := RequestMergeRefund{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: req,
+	}
+	return t.client.DoRequest(consts.BASE_URL+consts.LKL_UNIFIED_RETURN_MERGE_REFUND_URL, baseReq)
+}
+func (t *MergeRefund) MergeRefundTest(req *RequestDataMergeRefund) (*ResponseMergeRefund, error) {
+	// 构建BaseModel请求
+	baseReq := RequestMergeRefund{
+		ReqTime: gtime.Now().Format("YmdHis"),
+		Version: "3.0",
+		ReqData: req,
+	}
+	return t.client.DoRequest(consts.BASE_TEST_URL+consts.LKL_UNIFIED_RETURN_MERGE_REFUND_URL, baseReq)
+}

unifiedreturn/refund/api.go

@@ -1,19 +1,19 @@
 package refund
 
 import (
+	"github.com/black1552/lkl_sdk/common"
 	"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 {
+type Refund struct {
-	client *common.Client[T]
+	client *common.Client[ResponseRefund]
 }
 
 // NewRefund 创建统一退货API实例
-func NewRefund[T any](client *common.Client[T]) *Refund[T] {
+func NewRefund(client *common.Client[ResponseRefund]) *Refund {
-	return &Refund[T]{
+	return &Refund{
 		client: client,
 	}
 }
@@ -21,7 +21,7 @@ func NewRefund[T any](client *common.Client[T]) *Refund[T] {
 // Refund 发起统一退货请求
 // request: 统一退货请求参数
 // 返回统一退货响应结果和错误信息
-func (api *Refund[T]) Refund(req *RequestDataRefund) (*T, error) {
+func (api *Refund) Refund(req *RequestDataRefund) (*ResponseRefund, error) {
 	// 构建请求参数
 	url := consts.BASE_URL + consts.LKL_UNIFIED_RETURN_REFUND_URL
 	// 构建BaseModel请求

unifiedreturn/refundquery/api.go

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