271 lines
7.0 KiB
Go
271 lines
7.0 KiB
Go
package yushan
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"crypto/aes"
|
||
"crypto/cipher"
|
||
"crypto/md5"
|
||
"crypto/rand"
|
||
"encoding/base64"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"net/http"
|
||
"strings"
|
||
"time"
|
||
|
||
"tyapi-server/internal/shared/external_logger"
|
||
|
||
"github.com/tidwall/gjson"
|
||
)
|
||
|
||
var (
|
||
ErrDatasource = errors.New("数据源异常")
|
||
ErrNotFound = errors.New("查询为空")
|
||
ErrSystem = errors.New("系统异常")
|
||
)
|
||
|
||
type YushanConfig struct {
|
||
URL string
|
||
ApiKey string
|
||
AcctID string
|
||
}
|
||
|
||
type YushanService struct {
|
||
config YushanConfig
|
||
logger *external_logger.ExternalServiceLogger
|
||
}
|
||
|
||
// NewYushanService 是一个构造函数，用于初始化 YushanService
|
||
func NewYushanService(url, apiKey, acctID string, logger *external_logger.ExternalServiceLogger) *YushanService {
|
||
return &YushanService{
|
||
config: YushanConfig{
|
||
URL: url,
|
||
ApiKey: apiKey,
|
||
AcctID: acctID,
|
||
},
|
||
logger: logger,
|
||
}
|
||
}
|
||
|
||
// CallAPI 调用羽山数据的 API
|
||
func (y *YushanService) CallAPI(ctx context.Context, code string, params map[string]interface{}) (respBytes []byte, err error) {
|
||
startTime := time.Now()
|
||
requestID := y.generateRequestID()
|
||
|
||
// 从ctx中获取transactionId
|
||
var transactionID string
|
||
if ctxTransactionID, ok := ctx.Value("transaction_id").(string); ok {
|
||
transactionID = ctxTransactionID
|
||
}
|
||
|
||
// 记录请求日志
|
||
if y.logger != nil {
|
||
y.logger.LogRequest(requestID, transactionID, code, y.config.URL, params)
|
||
}
|
||
|
||
// 获取当前时间戳
|
||
unixMilliseconds := time.Now().UnixNano() / int64(time.Millisecond)
|
||
|
||
// 生成请求序列号
|
||
requestSN, _ := y.GenerateRandomString()
|
||
|
||
// 构建请求数据
|
||
reqData := map[string]interface{}{
|
||
"prod_id": code,
|
||
"req_time": unixMilliseconds,
|
||
"request_sn": requestSN,
|
||
"req_data": params,
|
||
}
|
||
|
||
// 将请求数据转换为 JSON 字节数组
|
||
messageBytes, err := json.Marshal(reqData)
|
||
if err != nil {
|
||
err = errors.Join(ErrSystem, err)
|
||
if y.logger != nil {
|
||
y.logger.LogError(requestID, transactionID, code, err, params)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
// 获取 API 密钥
|
||
key, err := hex.DecodeString(y.config.ApiKey)
|
||
if err != nil {
|
||
err = errors.Join(ErrSystem, err)
|
||
if y.logger != nil {
|
||
y.logger.LogError(requestID, transactionID, code, err, params)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
// 使用 AES CBC 加密请求数据
|
||
cipherText := y.AES_CBC_Encrypt(messageBytes, key)
|
||
|
||
// 将加密后的数据编码为 Base64 字符串
|
||
content := base64.StdEncoding.EncodeToString(cipherText)
|
||
|
||
// 发起 HTTP 请求
|
||
client := &http.Client{
|
||
Timeout: 20 * time.Second,
|
||
}
|
||
req, err := http.NewRequestWithContext(ctx, "POST", y.config.URL, strings.NewReader(content))
|
||
if err != nil {
|
||
err = errors.Join(ErrSystem, err)
|
||
if y.logger != nil {
|
||
y.logger.LogError(requestID, transactionID, code, err, params)
|
||
}
|
||
return nil, err
|
||
}
|
||
req.Header.Set("Content-Type", "application/json")
|
||
req.Header.Set("ACCT_ID", y.config.AcctID)
|
||
|
||
// 执行请求
|
||
resp, err := client.Do(req)
|
||
if err != nil {
|
||
err = errors.Join(ErrSystem, err)
|
||
if y.logger != nil {
|
||
y.logger.LogError(requestID, transactionID, code, err, params)
|
||
}
|
||
return nil, err
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
// 读取响应体
|
||
body, err := io.ReadAll(resp.Body)
|
||
if err != nil {
|
||
if y.logger != nil {
|
||
y.logger.LogError(requestID, transactionID, code, err, params)
|
||
}
|
||
return nil, err
|
||
}
|
||
|
||
var respData []byte
|
||
|
||
if IsJSON(string(body)) {
|
||
respData = body
|
||
} else {
|
||
sDec, err := base64.StdEncoding.DecodeString(string(body))
|
||
if err != nil {
|
||
err = errors.Join(ErrSystem, err)
|
||
if y.logger != nil {
|
||
y.logger.LogError(requestID, transactionID, code, err, params)
|
||
}
|
||
return nil, err
|
||
}
|
||
respData = y.AES_CBC_Decrypt(sDec, key)
|
||
}
|
||
retCode := gjson.GetBytes(respData, "retcode").String()
|
||
|
||
// 记录响应日志
|
||
if y.logger != nil {
|
||
duration := time.Since(startTime)
|
||
y.logger.LogResponse(requestID, transactionID, code, resp.StatusCode, respData, duration)
|
||
}
|
||
|
||
if retCode == "100000" {
|
||
// retcode 为 100000，表示查询为空
|
||
return nil, ErrNotFound
|
||
} else if retCode == "000000" {
|
||
// retcode 为 000000，表示有数据，返回 retdata
|
||
retData := gjson.GetBytes(respData, "retdata")
|
||
if !retData.Exists() {
|
||
err = errors.Join(ErrDatasource, fmt.Errorf("羽山请求retdata为空"))
|
||
if y.logger != nil {
|
||
y.logger.LogError(requestID, transactionID, code, err, params)
|
||
}
|
||
return nil, err
|
||
}
|
||
return []byte(retData.Raw), nil
|
||
} else {
|
||
err = errors.Join(ErrDatasource, fmt.Errorf("羽山请求未知的状态码"))
|
||
if y.logger != nil {
|
||
y.logger.LogError(requestID, transactionID, code, err, params)
|
||
}
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
// generateRequestID 生成请求ID
|
||
func (y *YushanService) generateRequestID() string {
|
||
timestamp := time.Now().UnixNano()
|
||
hash := md5.Sum([]byte(fmt.Sprintf("%d_%s", timestamp, y.config.ApiKey)))
|
||
return fmt.Sprintf("yushan_%x", hash[:8])
|
||
}
|
||
|
||
// GenerateRandomString 生成一个32位的随机字符串订单号
|
||
func (y *YushanService) GenerateRandomString() (string, error) {
|
||
// 创建一个16字节的数组
|
||
bytes := make([]byte, 16)
|
||
// 读取随机字节到数组中
|
||
if _, err := rand.Read(bytes); err != nil {
|
||
return "", err
|
||
}
|
||
// 将字节数组编码为16进制字符串
|
||
return hex.EncodeToString(bytes), nil
|
||
}
|
||
|
||
// AEC加密（CBC模式）
|
||
func (y *YushanService) AES_CBC_Encrypt(plainText []byte, key []byte) []byte {
|
||
//指定加密算法，返回一个AES算法的Block接口对象
|
||
block, err := aes.NewCipher(key)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
//进行填充
|
||
plainText = Padding(plainText, block.BlockSize())
|
||
//指定初始向量vi,长度和block的块尺寸一致
|
||
iv := []byte("0000000000000000")
|
||
//指定分组模式，返回一个BlockMode接口对象
|
||
blockMode := cipher.NewCBCEncrypter(block, iv)
|
||
//加密连续数据库
|
||
cipherText := make([]byte, len(plainText))
|
||
blockMode.CryptBlocks(cipherText, plainText)
|
||
//返回base64密文
|
||
return cipherText
|
||
}
|
||
|
||
// AEC解密（CBC模式）
|
||
func (y *YushanService) AES_CBC_Decrypt(cipherText []byte, key []byte) []byte {
|
||
//指定解密算法，返回一个AES算法的Block接口对象
|
||
block, err := aes.NewCipher(key)
|
||
if err != nil {
|
||
panic(err)
|
||
}
|
||
//指定初始化向量IV,和加密的一致
|
||
iv := []byte("0000000000000000")
|
||
//指定分组模式，返回一个BlockMode接口对象
|
||
blockMode := cipher.NewCBCDecrypter(block, iv)
|
||
//解密
|
||
plainText := make([]byte, len(cipherText))
|
||
blockMode.CryptBlocks(plainText, cipherText)
|
||
//删除填充
|
||
plainText = UnPadding(plainText)
|
||
return plainText
|
||
} // 对明文进行填充
|
||
func Padding(plainText []byte, blockSize int) []byte {
|
||
//计算要填充的长度
|
||
n := blockSize - len(plainText)%blockSize
|
||
//对原来的明文填充n个n
|
||
temp := bytes.Repeat([]byte{byte(n)}, n)
|
||
plainText = append(plainText, temp...)
|
||
return plainText
|
||
}
|
||
|
||
// 对密文删除填充
|
||
func UnPadding(cipherText []byte) []byte {
|
||
//取出密文最后一个字节end
|
||
end := cipherText[len(cipherText)-1]
|
||
//删除填充
|
||
cipherText = cipherText[:len(cipherText)-int(end)]
|
||
return cipherText
|
||
}
|
||
|
||
// 判断字符串是否为 JSON 格式
|
||
func IsJSON(s string) bool {
|
||
var js interface{}
|
||
return json.Unmarshal([]byte(s), &js) == nil
|
||
}
|