black1552/lkl_sdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

first commit

Browse Source
This commit is contained in:
maguodong
2025-10-09 15:56:47 +08:00
commit ccd273840a
32 changed files with 2020 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lklsdk/account.go
+60
View File
@@ -0,0 +1,60 @@
package lklsdk
import (
"time"
"github.com/black1552/lkl_sdk/consts"
"github.com/black1552/lkl_sdk/model"
)
// AccountService 账户服务
type AccountService[T any] struct {
client *Client[T]
}
// NewAccountService 创建账户服务实例
func NewAccountService[T any](client *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: time.Now().Format("20060102150405"),
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: time.Now().Format("20060102150405"),
Version: "3.0",
ReqData: req,
}
// 发送请求
respBody, err := a.client.doRequest(url, baseReq)
if err != nil {
return nil, err
}
return respBody, nil
}
lklsdk/client.go
+122
View File
@@ -0,0 +1,122 @@
package lklsdk
import (
"context"
"crypto"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/json"
"encoding/pem"
"fmt"
ran "math/rand"
"time"
"github.com/black1552/base-common/utils"
"github.com/gogf/gf/v2/os/gfile"
)
// Config 拉卡拉SDK配置
type Config struct {
AppID string `json:"app_id"`
TermNo string `json:"term_no"`
MerchantNo string `json:"merchant_no"`
SettleMerNo string `json:"settle_merchant_no"`
SettleTermNo string `json:"settle_term_no"`
AccountType string `json:"account_type"`
TransType string `json:"trans_type"`
Version string `json:"version"`
NotifyURL string `json:"notify_url"`
PublicKey string `json:"public_key"`
PrivateKey string `json:"private_key"`
SerialNo string `json:"serial_no"`
}
// Client 拉卡拉SDK客户端
type Client[T any] struct {
config *Config
response T
ctx context.Context
}
// NewClient 创建拉卡拉SDK客户端
func NewClient[T any](ctx context.Context, config *Config) *Client[T] {
return &Client[T]{
config: config,
ctx: ctx,
}
}
func (c *Client[T]) generateNonceStr() string {
const letterBytes = "abcdefghijklmnopqrstuvwxyz0123456789"
nonce := make([]byte, 12)
for i := range nonce {
nonce[i] = letterBytes[ran.Intn(len(letterBytes))]
}
return string(nonce)
}
// generateSign 生成签名
func (c *Client[T]) generateSign(request []byte) (string, error) {
// 生成随机字符串
nonceStr := c.generateNonceStr()
// 获取当前时间戳（秒）
timestamp := fmt.Sprintf("%d", time.Now().Unix())
// 构建待签名报文
signData := fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n", c.config.AppID, c.config.SerialNo, timestamp, nonceStr, string(request))
// 计算签名
hashed := sha256.Sum256([]byte(signData))
privateKey, err := c.loadPrivateKey()
if err != nil {
return "", err
}
signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hashed[:])
if err != nil {
return "", err
}
signatureBase64 := base64.StdEncoding.EncodeToString(signature)
// 构建Authorization头
authorization := fmt.Sprintf("LKLAPI-SHA256withRSA appid=\"%s\",serial_no=\"%s\",timestamp=\"%s\",nonce_str=\"%s\",signature=\"%s\"",
c.config.AppID, c.config.SerialNo, timestamp, nonceStr, signatureBase64)
return authorization, nil
}
func (c *Client[T]) loadPrivateKey() (*rsa.PrivateKey, error) {
block, _ := pem.Decode(gfile.GetBytes(c.config.PrivateKey))
if block == nil {
return nil, fmt.Errorf("无法解码私钥PEM数据")
}
// 解析PKCS#8格式私钥
privateKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
if err != nil {
return nil, err
}
return privateKey.(*rsa.PrivateKey), nil
}
// doRequest 发送HTTP请求
func (c *Client[T]) doRequest(url string, reqData interface{}) (*T, error) {
// 序列化为JSON
jsonData, err := json.Marshal(reqData)
if err != nil {
return nil, fmt.Errorf("序列化请求数据失败: %v", err)
}
auth, err := c.generateSign(jsonData)
if err != nil {
return nil, fmt.Errorf("生成签名失败: %v", err)
}
header := map[string]string{
"Authorization": auth,
"Content-Type": "application/json",
"Accept": "application/json",
}
// 设置其他必要的请求头
return utils.NewClient[T](jsonData, url, header).Post(c.ctx)
}
lklsdk/mergePre.go
+38
View File
@@ -0,0 +1,38 @@
package lklsdk
import (
"github.com/black1552/lkl_sdk/consts"
"github.com/black1552/lkl_sdk/model"
"github.com/gogf/gf/v2/os/gtime"
)
type MergePreService[T any] struct {
client *Client[T]
}
// NewMergePreService 创建拉卡拉主扫合单交易
func NewMergePreService[T any](client *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
+96
View File
@@ -0,0 +1,96 @@
package lklsdk
import (
"context"
"github.com/black1552/lkl_sdk/model"
)
// SDK 拉卡拉SDK主入口
type SDK[T any] struct {
Client *Client[T]
SplitLedger *SplitLedgerService[T]
Trade *TradeService[T]
Account *AccountService[T]
UploadFile *UploadFileService[T]
MergePre *MergePreService[T]
}
// NewSDK 创建拉卡拉SDK实例
func NewSDK[T any](ctx context.Context, config *Config) *SDK[T] {
client := NewClient[T](ctx, config)
return &SDK[T]{
Client: client,
SplitLedger: NewSplitLedgerService(client),
Trade: NewTradeService(client),
Account: NewAccountService(client),
UploadFile: NewUploadFileService(client),
MergePre: NewMergePreService(client),
}
}
// 以下为便捷方法，直接通过SDK调用各服务的主要功能
// 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)
}
// QueryLedgerMer 商户分账信息查询
func (s *SDK[T]) QueryLedgerMer(req *model.QueryLedgerMerReqData) (*T, error) {
return s.SplitLedger.QueryLedgerMer(req)
}
// ApplyLedgerReceiver 分账接收方创建申请
func (s *SDK[T]) ApplyLedgerReceiver(req *model.ApplyLedgerReceiverReqData) (*T, error) {
return s.SplitLedger.ApplyLedgerReceiver(req)
}
// ApplyBind 分账关系绑定申请
func (s *SDK[T]) ApplyBind(req *model.ApplyBindReqData) (*T, error) {
return s.SplitLedger.ApplyBind(req)
}
// QuerySplitBalance 可分账金额查询
func (s *SDK[T]) QuerySplitBalance(req *model.SplitBalanceReqData) (*T, error) {
return s.SplitLedger.QuerySplitBalance(req)
}
// OrderSplitLedger 订单分账
func (s *SDK[T]) OrderSplitLedger(req *model.OrderSplitLedgerReqData) (*T, error) {
return s.SplitLedger.OrderSplitLedger(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]) UploadFileQuery(req *model.UploadFileReqData) (*T, error) {
return s.UploadFile.UploadFileQuery(req)
}
// Withdraw 账户提现
func (s *SDK[T]) Withdraw(req *model.WithdrawReqData) (*T, error) {
return s.Account.Withdraw(req)
}
lklsdk/split_ledger.go
+97
View File
@@ -0,0 +1,97 @@
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"
)
// SplitLedgerService 分账服务
type SplitLedgerService[T any] struct {
client *Client[T]
}
// NewSplitLedgerService 创建分账服务实例
func NewSplitLedgerService[T any](client *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
}
// 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
}
// 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
}
lklsdk/split_ledger_more.go
+77
View File
@@ -0,0 +1,77 @@
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
}
// 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
}
// 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
}
lklsdk/trade.go
+74
View File
@@ -0,0 +1,74 @@
package lklsdk
import (
"time"
"github.com/black1552/lkl_sdk/consts"
"github.com/black1552/lkl_sdk/model"
)
// TradeService 交易服务
type TradeService[T any] struct {
client *Client[T]
}
// NewTradeService 创建交易服务实例
func NewTradeService[T any](client *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/uploadFile.go
+47
View File
@@ -0,0 +1,47 @@
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/util/gconv"
)
// UploadFileService 交易服务
type UploadFileService[T any] struct {
client *Client[T]
}
// NewUploadFileService 创建交易服务实例
func NewUploadFileService[T any](client *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
}