新增二维码功能模块：qrcode.go;

为http请求添加超时
fix env
2025-11-03 15:27:12 +08:00 · 2025-10-26 01:30:17 +08:00 · 2025-10-16 13:29:25 +08:00 · 2025-10-14 14:48:44 +08:00 · 2025-10-13 13:10:01 +08:00 · 2025-10-13 11:59:49 +08:00
54 changed files with 3627 additions and 556 deletions
--- a/README.md
+++ b/README.md
@ -1,7 +1,513 @@
-# 私有仓库：core 设置
+# BSM-SDK Core
+
+BSM-SDK Core 是一个企业级后端开发工具包的核心模块，提供了微服务架构、配置管理、加密解密、缓存、数据库访问、中间件等基础功能。
+
+## 私有仓库设置
+
+```bash
+go env -w GOPRIVATE=git.apinb.com/*
+go env -w GONOPROXY=git.apinb.com/*
+go env -w GOINSECURE=git.apinb.com/*
+go env -w GONOSUMDB=git.apinb.com/*
 ```
-go env -w  GOPRIVATE=git.apinb.com/*
-go env -w  GONOPROXY=git.apinb.com/*
-go env -w  GOINSECURE=git.apinb.com/*
-go env -w  GONOSUMDB=git.apinb.com/*
+
+## 核心功能模块
+
+### 1. 服务管理 (service)
+
+#### 服务启动与注册
+- **Service**: 核心服务结构，支持 gRPC 服务启动和 etcd 注册
+- **New()**: 创建服务实例
+- **Start()**: 启动服务，支持 etcd 注册和 HTTP 网关
+- **Stop()**: 优雅停止服务
+- **Use()**: 执行初始化函数
+
+#### 服务发现
+- **FoundGrpcMethods()**: 自动发现 gRPC 方法
+- **RegisterService()**: 注册服务到 etcd
+- **ServiceRegister**: 服务注册器，支持租约管理
+
+#### 元数据解析
+- **ParseMetaCtx()**: 解析 gRPC 上下文中的元数据
+- **ParseOptions**: 解析选项，支持角色验证和私有IP检查
+
+### 2. 配置管理 (conf)
+
+#### 配置加载
+- **New()**: 加载配置文件，支持环境变量替换
+- **NotNil()**: 验证必需配置项
+- **PrintInfo()**: 打印配置信息
+- **CheckPort()**: 检查端口配置
+
+#### 配置类型
+- **MicroServiceConf**: 微服务配置
+- **GatewayConf**: 网关配置
+- **DBConf**: 数据库配置
+
+### 3. 加密与解密 (crypto)
+
+#### AES 加密
+- **AESGCMEncrypt/AESGCMDecrypt**: GCM 模式加密解密
+- **Encrypt/Decrypt**: CBC 模式加密解密
+- **AesEncryptECB/AesDecryptECB**: ECB 模式加密解密
+- **AesKeyCheck()**: 密钥环境变量检测
+
+#### RSA 加密
+- **EncryptWithPublicKey()**: 公钥加密
+- **Decrypt()**: 私钥解密
+
+#### 通用加密
+- **AesEncryptCBC/AesDecryptCBC**: 通用 CBC 加密解密
+- **PKCS7Padding/PKCS7UnPadding**: PKCS7 填充
+
+### 4. 数据库支持 (database)
+
+#### 数据库连接
+- **NewDatabase()**: 创建数据库连接，支持 MySQL 和 PostgreSQL
+- **NewMysql()**: MySQL 连接
+- **NewPostgres()**: PostgreSQL 连接
+
+#### 数据库类型
+- **SqlOptions**: 数据库连接选项
+- **Std_IICUDS**: 标准数据库模型（ID、Identity、Created、Updated、Deleted、Status）
+- **Std_ICUD**: 标准数据库模型（ID、Created、Updated、Deleted）
+- **Std_Passport**: 护照模型
+- **Std_Owner**: 所有者模型
+
+### 5. 缓存支持 (cache)
+
+#### Redis 缓存
+- **RedisClient**: Redis 客户端封装
+- **New()**: 创建 Redis 连接
+- **Hash()**: 哈希分片计算
+
+#### 内存缓存
+- 支持内存缓存操作
+
+### 6. 消息队列 (queue)
+
+#### NATS 消息队列
+- **Nats**: NATS 客户端封装
+- **NewNats()**: 创建 NATS 连接
+- **Subscribe()**: 订阅消息
+- **Producer()**: 发布消息
+
+### 7. 中间件 (middleware)
+
+#### JWT 认证
+- **JwtAuth()**: JWT 认证中间件
+- **ParseAuth()**: 解析认证信息
+
+#### CORS 支持
+- **Cors()**: CORS 中间件
+
+#### 运行模式
+- **Mode()**: 设置 Gin 运行模式
+
+### 8. 工具类 (utils)
+
+#### 网络工具 (net.go) ✨ 新增超时功能
+完整的网络工具集，所有HTTP请求都支持超时控制。
+
+**IP地址工具：**
+- **IsPublicIP(ipString)**: 判断是否为公网IP
+  - 识别私有网段（10.x.x.x、172.16-31.x.x、192.168.x.x）
+  - 识别回环地址和链路本地地址
+  - 性能：62.55 ns/op，零内存分配
+  
+- **GetLocationIP()**: 获取本机第一个有效IPv4地址
+  - 自动跳过回环和链路本地地址
+  - 返回 "127.0.0.1" 如果找不到
+  
+- **LocalIPv4s()**: 获取本机所有IPv4地址列表
+  - 返回所有非回环IPv4地址
+  - 自动过滤链路本地地址
+  
+- **GetOutBoundIP()**: 获取外网IP地址
+
+**HTTP请求工具（带超时保护）：**
+- **HttpGet(url, timeout...)**: HTTP GET请求
+  - 默认超时：30秒
+  - 支持自定义超时
+  - Context超时控制
+  - 示例：`body, _ := HttpGet("https://api.com", 5*time.Second)`
+  
+- **HttpPost(url, headers, data, timeout...)**: HTTP POST请求
+  - 默认超时：30秒
+  - 自动设置Content-Type和Request-Id
+  - 检查HTTP状态码
+  - 示例：`body, _ := HttpPost(url, headers, data, 10*time.Second)`
+  
+- **HttpPostJSON(url, headers, data)**: HTTP POST JSON请求
+  - 自动JSON序列化
+  - 继承HttpPost所有特性
+  - 示例：`body, _ := HttpPostJSON(url, map[string]any{"key": "value"})`
+  
+- **HttpRequest(request, timeout...)**: 执行自定义HTTP请求
+  - 支持任何HTTP方法
+  - 完全自定义请求
+  
+- **DownloadFile(url, savePath, progressCallback, timeout...)**: 文件下载
+  - 默认超时：5分钟
+  - 实时进度回调
+  - 文件权限：0644
+  - 缓冲区大小：32KB
+  - 示例：
+    ```go
+    progress := func(total, downloaded int64) {
+        percent := float64(downloaded) / float64(total) * 100
+        fmt.Printf("下载: %.2f%%\n", percent)
+    }
+    err := DownloadFile(url, "file.zip", progress, 10*time.Minute)
+    ```
+
+**配置常量：**
+- `DefaultHTTPTimeout`: 30秒（HTTP请求默认超时）
+- `DefaultDownloadTimeout`: 5分钟（下载默认超时）
+- `DefaultBufferSize`: 32KB（默认缓冲区）
+
+#### 二维码生成 (qrcode.go) 🎨 全新功能
+完整的二维码生成工具，支持多种输出格式和自定义配置。
+
+**基础生成：**
+- **GenerateQRCode(content, filename, size...)**: 生成二维码文件
+  - 默认尺寸：256x256
+  - 支持自定义尺寸（21-8192像素）
+  - 中级纠错（15%容错）
+  - 示例：`GenerateQRCode("https://example.com", "qr.png", 512)`
+  
+- **GenerateQRCodeBytes(content, size...)**: 生成字节数组
+  - PNG格式
+  - 适合HTTP响应、数据库存储
+  - 性能：~1.5ms/次
+  - 示例：`bytes, _ := GenerateQRCodeBytes("内容", 300)`
+  
+- **GenerateQRCodeBase64(content, size...)**: 生成Base64编码
+  - 便于JSON传输
+  - 适合数据库文本字段
+  - 示例：`base64Str, _ := GenerateQRCodeBase64("内容")`
+  
+- **GenerateQRCodeDataURL(content, size...)**: 生成Data URL
+  - 可直接用于HTML <img>标签
+  - 包含完整图片数据
+  - 示例：`dataURL, _ := GenerateQRCodeDataURL("内容")`
+
+**高级功能：**
+- **GenerateQRCodeWithConfig(content, config)**: 自定义配置生成
+  - 自定义尺寸、颜色、纠错级别
+  - 示例：
+    ```go
+    config := &QRCodeConfig{
+        Size: 512,
+        ErrorLevel: QRCodeErrorLevelHigh,
+        ForegroundColor: color.RGBA{255, 0, 0, 255}, // 红色
+        BackgroundColor: color.White,
+    }
+    bytes, _ := GenerateQRCodeWithConfig("内容", config)
+    ```
+  
+- **GenerateQRCodeWithLogo(content, logoPath, size...)**: 带Logo二维码
+  - Logo占据中心1/5区域
+  - 高级纠错（30%容错）
+  - 建议尺寸>=512
+  - 示例：`bytes, _ := GenerateQRCodeWithLogo("内容", "logo.png", 512)`
+  
+- **BatchGenerateQRCode(items, size...)**: 批量生成
+  - 一次生成多个二维码
+  - 返回失败列表
+  - 示例：
+    ```go
+    items := map[string]string{
+        "产品A": "qr_a.png",
+        "产品B": "qr_b.png",
+    }
+    failed, _ := BatchGenerateQRCode(items, 300)
+    ```
+
+**纠错级别：**
+- `QRCodeErrorLevelLow`: 低级纠错（~7%容错）
+- `QRCodeErrorLevelMedium`: 中级纠错（~15%容错，默认）
+- `QRCodeErrorLevelQuartile`: 较高级纠错（~25%容错）
+- `QRCodeErrorLevelHigh`: 高级纠错（~30%容错，适合Logo）
+
+**实用场景：**
+- URL分享、名片（vCard）、WiFi连接
+- 支付码、位置信息、文本分享
+- 产品标签、会员卡、门票优惠券
+
+**性能指标：**
+- 生成速度：1.5-2.2 ms/次
+- 内存占用：~984 KB/次
+- 并发安全：所有函数都是并发安全的
+
+#### 数据类型转换
+- **String2Int/String2Int64**: 字符串转整数
+- **String2Float64/String2Float32**: 字符串转浮点数
+- **Int2String/Int642String**: 整数转字符串
+- **Float64ToString/Float32ToString**: 浮点数转字符串
+- **AnyToString()**: 任意类型转字符串
+
+#### 时间处理
+- **Time2String()**: 时间转字符串
+- **String2Time()**: 字符串转时间
+
+#### 身份标识
+- **UUID()**: 生成 UUID
+- **ULID()**: 生成 ULID
+
+#### 文件操作
+- **PathExists()**: 检查路径是否存在
+- **CreateDir()**: 创建目录
+- **GetRunPath()**: 获取运行路径
+- **GetCurrentPath()**: 获取当前路径
+
+#### JSON 处理
+- **JsonEscape()**: JSON 转义
+
+### 9. 错误处理 (errcode)
+
+#### 标准错误码
+- **Header 错误**: 101-104
+- **标准错误**: 110-121
+- **JWT 错误**: 131-139
+- **模型错误**: 151-157
+- **gRPC 错误**: 171-186
+
+#### 错误创建
+- **NewError()**: 创建标准错误
+- **ErrFatal()**: 创建致命错误
+- **ErrNotFound()**: 创建未找到错误
+
+### 10. 响应处理 (infra)
+
+#### 统一响应
+- **Reply**: 统一响应结构
+- **Success()**: 成功响应
+- **Error()**: 错误响应，支持 gRPC 状态码转换
+
+### 11. 日志打印 (printer)
+
+#### 彩色日志
+- **Info()**: 信息日志（白色）
+- **Warn()**: 警告日志（橙色）
+- **Success()**: 成功日志（绿色）
+- **Error()**: 错误日志（红色）
+- **Json()**: JSON 格式化输出
+
+### 12. 环境管理 (env)
+
+#### 运行时环境
+- **RuntimeEnv**: 运行时环境配置
+- **NewEnv()**: 初始化环境
+- **GetEnvDefault()**: 获取环境变量默认值
+
+### 13. 变量管理 (vars)
+
+#### 全局变量
+- **ServiceKey**: 服务键
+- **HostName**: 主机名
+- **VERSION**: 版本号
+- **BUILD_TIME**: 构建时间
+- **GO_VERSION**: Go 版本
+
+### 14. 第三方集成 (third)
+
+#### 微信集成
+- 支持微信相关功能
+
+### 15. 许可证管理 (licence)
+
+#### 许可证验证
+- 支持许可证文件验证
+
+
+### 配置环境变量
+
+```bash
+export BSM_Workspace=def
+export BSM_JwtSecretKey=your_secret_key
+export BSM_RuntimeMode=dev
+export BSM_Prefix=/usr/local/bsm
 ```
+
+### 安全建议
+
+- 使用强密钥进行加密
+- 定期更新 JWT 密钥
+- 配置适当的数据库连接池
+- 使用 HTTPS 进行通信
+- 定期检查许可证有效性
+
+## 🚀 快速开始
+
+### 网络工具示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+    "git.apinb.com/bsm-sdk/core/utils"
+)
+
+func main() {
+    // 1. 获取本机IP
+    localIP := utils.GetLocationIP()
+    fmt.Printf("本机IP: %s\n", localIP)
+    
+    // 2. HTTP GET请求（带超时）
+    body, err := utils.HttpGet("https://api.example.com/data", 5*time.Second)
+    if err != nil {
+        fmt.Printf("请求失败: %v\n", err)
+        return
+    }
+    fmt.Printf("响应: %s\n", string(body))
+    
+    // 3. POST JSON数据
+    headers := map[string]string{"Authorization": "Bearer token"}
+    data := map[string]any{"name": "张三", "age": 25}
+    body, err = utils.HttpPostJSON("https://api.example.com/users", headers, data)
+    
+    // 4. 下载文件（带进度）
+    progress := func(total, downloaded int64) {
+        if total > 0 {
+            percent := float64(downloaded) / float64(total) * 100
+            fmt.Printf("\r下载进度: %.2f%%", percent)
+        }
+    }
+    err = utils.DownloadFile(
+        "https://example.com/file.zip",
+        "./download/file.zip",
+        progress,
+        10*time.Minute,
+    )
+}
+```
+
+### 二维码生成示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "image/color"
+    "git.apinb.com/bsm-sdk/core/utils"
+)
+
+func main() {
+    // 1. 基础二维码
+    err := utils.GenerateQRCode("https://example.com", "qrcode.png")
+    
+    // 2. 自定义尺寸
+    err = utils.GenerateQRCode("内容", "qrcode_large.png", 512)
+    
+    // 3. 生成Base64（用于API响应）
+    base64Str, _ := utils.GenerateQRCodeBase64("订单号：20231103001")
+    fmt.Printf("Base64: %s\n", base64Str)
+    
+    // 4. 自定义颜色
+    config := &utils.QRCodeConfig{
+        Size: 512,
+        ErrorLevel: utils.QRCodeErrorLevelHigh,
+        ForegroundColor: color.RGBA{255, 0, 0, 255}, // 红色
+        BackgroundColor: color.White,
+    }
+    bytes, _ := utils.GenerateQRCodeWithConfig("内容", config)
+    utils.SaveQRCodeBytes(bytes, "red_qrcode.png")
+    
+    // 5. 批量生成
+    items := map[string]string{
+        "产品A": "qr_a.png",
+        "产品B": "qr_b.png",
+        "产品C": "qr_c.png",
+    }
+    failed, err := utils.BatchGenerateQRCode(items, 300)
+    if err != nil {
+        fmt.Printf("部分失败: %v\n", failed)
+    }
+    
+    // 6. 名片二维码（vCard）
+    vcard := `BEGIN:VCARD
+VERSION:3.0
+FN:张三
+TEL:+86-138-0000-0000
+EMAIL:zhangsan@example.com
+ORG:某某公司
+END:VCARD`
+    utils.GenerateQRCode(vcard, "namecard.png", 400)
+    
+    // 7. WiFi连接二维码
+    wifiInfo := "WIFI:T:WPA;S:MyWiFi;P:password123;;"
+    utils.GenerateQRCode(wifiInfo, "wifi_qr.png", 300)
+}
+```
+
+## 📝 使用建议
+
+### 1. 配置管理
+```go
+// 推荐使用环境变量进行配置
+conf.New("your-service", &config)
+```
+
+### 2. 错误处理
+```go
+// 使用统一的错误码
+if err != nil {
+    return errcode.ErrInternal
+}
+
+// 网络请求错误处理
+body, err := utils.HttpGet(url, 5*time.Second)
+if err != nil {
+    // 判断是否为超时错误
+    if errors.Is(err, context.DeadlineExceeded) {
+        fmt.Println("请求超时")
+    }
+    return err
+}
+```
+
+### 3. 缓存使用
+```go
+// 使用统一的缓存键前缀
+key := redisClient.BuildKey("user", userID)
+```
+
+### 4. 数据库连接
+```go
+// 使用连接池优化
+db, err := database.NewDatabase("mysql", dsn, options)
+```
+
+### 5. 二维码生成最佳实践
+```go
+// 内容较长时增大尺寸
+if len(content) > 100 {
+    size = 512
+} else {
+    size = 256
+}
+
+// 添加Logo时使用高级纠错
+config := &utils.QRCodeConfig{
+    Size: 512,
+    ErrorLevel: utils.QRCodeErrorLevelHigh, // 重要！
+    ForegroundColor: color.Black,
+    BackgroundColor: color.White,
+}
+```
+
+## 许可证
+
+本项目采用私有许可证，请确保已获得相应的使用授权。
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request 来改进本项目。
+
+## 联系方式
+
+如有问题，请联系开发团队。
--- a/cache/mapsync/map_float.go
+++ b/cache/mapsync/map_float.go
@ -0,0 +1,64 @@
+package mapsync
+
+import (
+	"sync"
+)
+
+var (
+	// sync map
+	MapFloat *mapFloat
+)
+
+// lock
+type mapFloat struct {
+	sync.RWMutex
+	Data map[string]float64
+}
+
+func NewMapFloat() *mapFloat {
+	return &mapFloat{
+		Data: make(map[string]float64),
+	}
+}
+func (c *mapFloat) Set(key string, val float64) {
+	c.Lock()
+	defer c.Unlock()
+	c.Data[key] = val
+}
+
+func (c *mapFloat) Get(key string) float64 {
+	c.RLock()
+	defer c.RUnlock()
+
+	vals, ok := c.Data[key]
+	if !ok {
+		return 0
+	}
+
+	return vals
+}
+
+func (c *mapFloat) Del(key string) {
+	c.Lock()
+	defer c.Unlock()
+
+	delete(c.Data, key)
+}
+
+func (c *mapFloat) Keys() (keys []string) {
+	c.RLock()
+	defer c.RUnlock()
+
+	for k, _ := range c.Data {
+		keys = append(keys, k)
+	}
+
+	return
+}
+
+func (c *mapFloat) All() map[string]float64 {
+	c.RLock()
+	defer c.RUnlock()
+
+	return c.Data
+}
--- a/cache/mapsync/map_int.go
+++ b/cache/mapsync/map_int.go
@ -0,0 +1,64 @@
+package mapsync
+
+import (
+	"sync"
+)
+
+var (
+	// sync map
+	MapInt *mapInt
+)
+
+// lock
+type mapInt struct {
+	sync.RWMutex
+	Data map[string]int
+}
+
+func NewMapInt() *mapInt {
+	return &mapInt{
+		Data: make(map[string]int),
+	}
+}
+
+func (c *mapInt) Set(key string, val int) {
+	c.Lock()
+	defer c.Unlock()
+	c.Data[key] = val
+}
+
+func (c *mapInt) Get(key string) int {
+	c.RLock()
+	defer c.RUnlock()
+
+	vals, ok := c.Data[key]
+	if !ok {
+		return 0
+	}
+
+	return vals
+}
+
+func (c *mapInt) Del(key string) {
+	c.Lock()
+	defer c.Unlock()
+
+	delete(c.Data, key)
+}
+
+func (c *mapInt) All() map[string]int {
+	c.RLock()
+	defer c.RUnlock()
+
+	return c.Data
+}
+func (c *mapInt) Keys() (keys []string) {
+	c.RLock()
+	defer c.RUnlock()
+
+	for k, _ := range c.Data {
+		keys = append(keys, k)
+	}
+
+	return
+}
--- a/cache/mapsync/map_string.go
+++ b/cache/mapsync/map_string.go
@ -0,0 +1,64 @@
+package mapsync
+
+import (
+	"sync"
+)
+
+var (
+	// sync map
+	MapString *mapString
+)
+
+// lock
+type mapString struct {
+	sync.RWMutex
+	Data map[string]string
+}
+
+func NewMapString() *mapString {
+	return &mapString{
+		Data: make(map[string]string),
+	}
+}
+
+func (c *mapString) Set(key, val string) {
+	c.Lock()
+	defer c.Unlock()
+	c.Data[key] = val
+}
+func (c *mapString) Get(key string) string {
+	c.RLock()
+	defer c.RUnlock()
+
+	vals, ok := c.Data[key]
+	if !ok {
+		return ""
+	}
+
+	return vals
+}
+
+func (c *mapString) Del(key string) {
+	c.Lock()
+	defer c.Unlock()
+
+	delete(c.Data, key)
+}
+
+func (c *mapString) Keys() (keys []string) {
+	c.RLock()
+	defer c.RUnlock()
+
+	for k, _ := range c.Data {
+		keys = append(keys, k)
+	}
+
+	return
+}
+
+func (c *mapString) All() map[string]string {
+	c.RLock()
+	defer c.RUnlock()
+
+	return c.Data
+}
--- a/cache/mem/mem.go
+++ b/cache/mem/mem.go
@ -1,14 +0,0 @@
-package mem
-
-import (
-	"git.apinb.com/bsm-sdk/core/vars"
-	"github.com/FishGoddess/cachego"
-)
-
-func New() cachego.Cache {
-	return cachego.NewCache(
-		cachego.WithGC(vars.MemGcDuration),
-		cachego.WithShardings(vars.MemShardings),
-		cachego.WithLFU(vars.MemLRUMaxNumber),
-	)
-}
--- a/cache/redis/cache.go
+++ b/cache/redis/cache.go
@ -0,0 +1,90 @@
+// Package redis 提供Redis缓存操作功能
+// 包括缓存设置、获取、删除等基本操作
+package redis
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"git.apinb.com/bsm-sdk/core/errcode"
+	"git.apinb.com/bsm-sdk/core/vars"
+)
+
+// BuildKey 构建缓存键
+// prefix: 键前缀
+// params: 键参数
+// 返回: 完整的缓存键
+func (c *RedisClient) BuildKey(prefix string, params ...interface{}) string {
+	key := vars.CacheKeyPrefix + prefix
+	for _, param := range params {
+		key += fmt.Sprintf(":%v", param)
+	}
+	return key
+}
+
+// Get 获取缓存
+// key: 缓存键
+// result: 存储结果的指针
+// 返回: 错误信息
+func (c *RedisClient) Get(key string, result interface{}) error {
+	if c.Client == nil {
+		return errcode.ErrRedis
+	}
+
+	data, err := c.Client.Get(c.Ctx, key).Result()
+	if err != nil {
+		return errcode.NewError(500, err.Error())
+	}
+
+	return json.Unmarshal([]byte(data), result)
+}
+
+// Set 设置缓存
+// key: 缓存键
+// value: 缓存值
+// ttl: 过期时间
+// 返回: 错误信息
+func (c *RedisClient) Set(key string, value interface{}, ttl time.Duration) error {
+	if c.Client == nil {
+		return errcode.ErrRedis
+	}
+
+	data, err := json.Marshal(value)
+	if err != nil {
+		return errcode.NewError(500, err.Error())
+	}
+
+	return c.Client.Set(c.Ctx, key, data, ttl).Err()
+}
+
+// Delete 删除缓存
+// key: 缓存键
+// 返回: 错误信息
+func (c *RedisClient) Delete(key string) error {
+	if c.Client == nil {
+		return errcode.ErrRedis
+	}
+
+	return c.Client.Del(c.Ctx, key).Err()
+}
+
+// ClearAllCache 清除所有缓存
+// 返回: 错误信息
+func (c *RedisClient) ClearAllCache() error {
+	if c.Client == nil {
+		return errcode.ErrRedis
+	}
+
+	pattern := vars.CacheKeyPrefix + "*"
+	keys, err := c.Client.Keys(c.Ctx, pattern).Result()
+	if err != nil {
+		return errcode.NewError(500, err.Error())
+	}
+
+	if len(keys) > 0 {
+		return c.Client.Del(c.Ctx, keys...).Err()
+	}
+
+	return nil
+}
--- a/cache/redis/redis.go
+++ b/cache/redis/redis.go
@ -20,6 +20,7 @@ type RedisClient struct {
 	DB     int
 	Client *cacheRedis.Client
 	Ctx    context.Context
+	memory map[string]any
 }

 func New(dsn string, hashRadix string) *RedisClient {
@ -54,6 +55,7 @@ func New(dsn string, hashRadix string) *RedisClient {
 		DB:     db,
 		Client: client,
 		Ctx:    context.Background(),
+		memory: make(map[string]any),
 	}
 }

--- a/conf/new.go
+++ b/conf/new.go
@ -1,3 +1,5 @@
+// Package conf 提供配置管理功能
+// 支持YAML配置文件加载、环境变量替换、配置验证等
 package conf

 import (
@ -11,12 +13,15 @@ import (
 	"math/rand/v2"

 	"git.apinb.com/bsm-sdk/core/env"
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/utils"
 	"git.apinb.com/bsm-sdk/core/vars"
 	yaml "gopkg.in/yaml.v3"
 )

+// New 加载配置文件
+// srvKey: 服务键名
+// cfg: 配置结构体指针
 func New(srvKey string, cfg any) {
 	env.NewEnv()

@ -26,12 +31,18 @@ func New(srvKey string, cfg any) {
 	// 获取主机名
 	vars.HostName, _ = os.Hostname()

-	// 构造配置文件路径,输出配置文件信息
+	// 构造配置文件路径，输出配置文件信息
 	cfp := fmt.Sprintf("%s_%s.yaml", strings.ToLower(srvKey), env.Runtime.Mode)
 	cfp = filepath.Join(env.Runtime.Prefix, "etc", cfp)

-	print.Info("[BSM - %s] Config File: %s", srvKey, cfp)
-	print.Info("[BSM - %s] Check Configure ...", vars.ServiceKey)
+	// 配置文件不存在则读取Workspace配置文件
+	if !utils.PathExists(cfp) {
+		cfp = fmt.Sprintf("workspace_%s_%s.yaml", strings.ToLower(env.Runtime.Workspace), env.Runtime.Mode)
+		cfp = filepath.Join(env.Runtime.Prefix, "etc", cfp)
+	}
+
+	printer.Info("[BSM - %s] Config File: %s", srvKey, cfp)
+	printer.Info("[BSM - %s] Check Configure ...", vars.ServiceKey)

 	// 读取配置文件内容
 	yamlFile, err := os.ReadFile(cfp)
@ -39,18 +50,23 @@ func New(srvKey string, cfg any) {
 		log.Fatalf("ERROR: %v", err)
 	}

-	// 检查配置文件中是否存在Service和Port字段
-	if !strings.Contains(string(yamlFile), "Service:") {
+	// 替换环境变量
+	yamlString := os.ExpandEnv(string(yamlFile))
+
+	// 检查配置文件中是否存在Service字段
+	if !strings.Contains(yamlString, "Service:") {
 		log.Fatalln("ERROR: Service Not Nil", cfp)
 	}

-	// 解析YAML
-	err = yaml.Unmarshal(yamlFile, cfg)
+	// 解析YAML到配置结构体
+	err = yaml.Unmarshal([]byte(yamlString), cfg)
 	if err != nil {
 		log.Fatalf("ERROR: %v", err)
 	}
 }

+// NotNil 验证必需配置项不为空
+// values: 需要验证的配置值列表
 func NotNil(values ...string) {
 	for _, value := range values {
 		if strings.TrimSpace(value) == "" {
@ -59,12 +75,17 @@ func NotNil(values ...string) {
 	}
 }

+// PrintInfo 打印配置信息
+// addr: 服务地址
 func PrintInfo(addr string) {
-	print.Success("[BSM - %s] Config Check Success.", vars.ServiceKey)
-	print.Info("[BSM - %s] Service Name: %s", vars.ServiceKey, vars.ServiceKey)
-	print.Info("[BSM - %s] Runtime Mode: %s", vars.ServiceKey, env.Runtime.Mode)
+	printer.Success("[BSM - %s] Config Check Success.", vars.ServiceKey)
+	printer.Info("[BSM - %s] Service Name: %s", vars.ServiceKey, vars.ServiceKey)
+	printer.Info("[BSM - %s] Runtime Mode: %s", vars.ServiceKey, env.Runtime.Mode)
 }

+// CheckPort 检查端口配置，如果为空则生成随机端口
+// port: 端口字符串
+// 返回: 有效的端口字符串
 func CheckPort(port string) string {
 	if port == "" {
 		r := rand.New(rand.NewPCG(1000, uint64(time.Now().UnixNano())))
@ -74,9 +95,28 @@ func CheckPort(port string) string {
 	return port
 }

+// CheckIP 检查IP配置，如果为空则获取本机IP
+// ip: IP地址字符串
+// 返回: 有效的IP地址字符串
 func CheckIP(ip string) string {
 	if ip == "" {
 		return utils.GetLocationIP()
 	}
 	return ip
 }
+
+// 初始化Logger配置
+func InitLoggerConf(cfg *LogConf) *LogConf {
+	if cfg == nil {
+		return &LogConf{
+			Name:     strings.ToLower(vars.ServiceKey),
+			Level:    vars.LogLevel(vars.DEBUG),
+			Dir:      "./logs/",
+			Endpoint: "",
+			Console:  true,
+			File:     true,
+			Remote:   false,
+		}
+	}
+	return cfg
+}
--- a/conf/types.go
+++ b/conf/types.go
@ -1,14 +1,16 @@
 package conf

+import "git.apinb.com/bsm-sdk/core/vars"
+
 type Base struct {
-	Service        string `yaml:"Service"`   // 服务名称
-	Port           string `yaml:"Port"`      // 服务监听端口,0为自动随机端口
-	Cache          string `yaml:"Cache"`     // REDIS缓存
-	SecretKey      string `yaml:"SecretKey"` // 服务秘钥
-	BindIP         string `yaml:"BindIP"`    // 绑定IP
-	Addr           string `yaml:"Addr"`
-	OnMicroService bool   `yaml:"OnMicroService"`
-	LoginUrl       string `yaml:"LoginUrl"`
+	Service        string   `yaml:"Service"`   // 服务名称
+	Port           string   `yaml:"Port"`      // 服务监听端口,0为自动随机端口
+	Cache          string   `yaml:"Cache"`     // REDIS缓存
+	SecretKey      string   `yaml:"SecretKey"` // 服务秘钥
+	BindIP         string   `yaml:"BindIP"`    // 绑定IP
+	Addr           string   `yaml:"Addr"`
+	Log            *LogConf `yaml:"Log"` // 日志配置
+	OnMicroService bool     `yaml:"OnMicroService"`
 }

 type DBConf struct {
@ -70,3 +72,24 @@ type TlsConf struct {
 	CertFile string // 证书文件路径
 	KeyFile  string // 密钥文件路径
 }
+
+type WebSocketConf struct {
+	ReadBufferSize   int    `yaml:"ReadBufferSize"`
+	WriteBufferSize  int    `yaml:"WriteBufferSize"`
+	CheckOrigin      bool   `yaml:"CheckOrigin"`
+	PingPeriod       string `yaml:"PingPeriod"`
+	PongWait         string `yaml:"PongWait"`
+	WriteWait        string `yaml:"WriteWait"`
+	MaxMessageSize   int64  `yaml:"MaxMessageSize"`
+	HandshakeTimeout string `yaml:"HandshakeTimeout"`
+}
+
+type LogConf struct {
+	Name     string        `yaml:"Name"`
+	Level    vars.LogLevel `yaml:"Level"`
+	Dir      string        `yaml:"Dir"`
+	Endpoint string        `yaml:"Endpoint"`
+	Console  bool          `yaml:"Console"`
+	File     bool          `yaml:"File"`
+	Remote   bool          `yaml:"Remote"`
+}
--- a/crypto/aes/aes.go
+++ b/crypto/aes/aes.go
@ -1,13 +1,73 @@
+// Package aes 提供AES加密解密功能
+// 支持GCM、CBC、ECB等多种加密模式
 package aes

 import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
+	"crypto/rand"
 	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"os"
 )

-// AES加密
+// =================== GCM模式 ======================
+// AESGCMEncrypt AES GCM模式加密
+// plaintext: 明文数据
+// key: 加密密钥
+// 返回: 十六进制编码的密文字符串
+func AESGCMEncrypt(plaintext, key []byte) (string, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", err
+	}
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
+		return "", err
+	}
+	ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
+	return hex.EncodeToString(ciphertext), nil
+}
+
+// AESGCMDecrypt AES GCM模式解密
+// ciphertext: 十六进制编码的密文字符串
+// key: 解密密钥
+// 返回: 解密后的明文数据
+func AESGCMDecrypt(ciphertext string, key []byte) ([]byte, error) {
+	data, err := hex.DecodeString(ciphertext)
+	if err != nil {
+		return nil, err
+	}
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, err
+	}
+	nonceSize := gcm.NonceSize()
+	if len(data) < nonceSize {
+		return nil, errors.New("密文无效")
+	}
+	nonce, cipherbyte := data[:nonceSize], data[nonceSize:]
+	return gcm.Open(nil, nonce, cipherbyte, nil)
+}
+
+// =================== CBC模式 ======================
+// Encrypt AES CBC模式加密
+// key: Base64编码的密钥
+// iv: Base64编码的初始化向量
+// data: 要加密的数据
+// 返回: Base64编码的密文
 func Encrypt(key string, iv string, data string) string {
 	if len(data) == 0 {
 		return ""
@ -24,7 +84,11 @@ func Encrypt(key string, iv string, data string) string {
 	return data
 }

-// AES解密
+// Decrypt AES CBC模式解密
+// key: Base64编码的密钥
+// iv: Base64编码的初始化向量
+// data: Base64编码的密文
+// 返回: 解密后的明文
 func Decrypt(key string, iv string, data string) string {
 	if len(data) == 0 {
 		return ""
@ -43,11 +107,19 @@ func Decrypt(key string, iv string, data string) string {
 	return data
 }

+// _PKCS5Padding PKCS5填充
+// cipherText: 需要填充的数据
+// blockSize: 块大小
+// 返回: 填充后的数据
 func _PKCS5Padding(cipherText []byte, blockSize int) []byte {
 	padding := blockSize - len(cipherText)%blockSize
 	padText := bytes.Repeat([]byte{byte(padding)}, padding)
 	return append(cipherText, padText...)
 }
+
+// _PKCS5UnPadding PKCS5去填充
+// origData: 需要去填充的数据
+// 返回: 去填充后的数据
 func _PKCS5UnPadding(origData []byte) []byte {
 	length := len(origData)
 	unpadding := int(origData[length-1])
@ -57,7 +129,11 @@ func _PKCS5UnPadding(origData []byte) []byte {
 	return origData[:(length - unpadding)]
 }

-// =================== ECB ======================
+// =================== ECB模式 ======================
+// AesEncryptECB AES ECB模式加密
+// origData: 原始数据
+// key: 加密密钥
+// 返回: Base64编码的密文
 func AesEncryptECB(origData []byte, key []byte) (data string) {
 	cipher, _ := aes.NewCipher(generateKey(key))
 	length := (len(origData) + aes.BlockSize) / aes.BlockSize
@ -76,11 +152,16 @@ func AesEncryptECB(origData []byte, key []byte) (data string) {
 	data = base64.StdEncoding.EncodeToString(encrypted)
 	return data
 }
+
+// AesDecryptECB AES ECB模式解密
+// encrypted: Base64编码的密文
+// key: 解密密钥
+// 返回: 解密后的明文数据
 func AesDecryptECB(encrypted string, key []byte) (decrypted []byte) {
 	decodedCiphertext, _ := base64.StdEncoding.DecodeString(encrypted)
 	cipher, _ := aes.NewCipher(generateKey(key))
 	decrypted = make([]byte, len(decodedCiphertext))
-	//
+	// 分组分块解密
 	for bs, be := 0, cipher.BlockSize(); bs < len(decodedCiphertext); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
 		cipher.Decrypt(decrypted[bs:be], decodedCiphertext[bs:be])
 	}
@ -92,6 +173,10 @@ func AesDecryptECB(encrypted string, key []byte) (decrypted []byte) {

 	return decrypted[:trim]
 }
+
+// generateKey 生成标准长度的密钥
+// key: 原始密钥
+// 返回: 16字节的标准密钥
 func generateKey(key []byte) (genKey []byte) {
 	genKey = make([]byte, 16)
 	copy(genKey, key)
@ -102,3 +187,28 @@ func generateKey(key []byte) (genKey []byte) {
 	}
 	return genKey
 }
+
+// AesKeyCheck 检查AES密钥环境变量
+// key: 环境变量名
+// 返回: 十六进制编码的密钥字符串
+func AesKeyCheck(key string) (string, error) {
+	// 从环境变量获取密钥
+	keyHex := os.Getenv(key)
+	if keyHex == "" {
+		// 使用入参作为变量名，避免硬编码误导
+		fmt.Printf("环境变量 %s 未设置\n", key)
+		return "", errors.New("密钥环境变量未设置")
+	}
+	// 解码十六进制字符串的密钥
+	byteKey, err := hex.DecodeString(keyHex)
+	if err != nil {
+		fmt.Printf("密钥解码失败: %v\n", err)
+		return "", errors.New("密钥解码失败")
+	}
+	// 检查密钥长度
+	if len(byteKey) != 16 && len(byteKey) != 24 && len(byteKey) != 32 {
+		fmt.Printf("无效的密钥长度: %d 字节 (需要16,24或32字节)\n", len(byteKey))
+		return "", errors.New("无效的密钥长度,需要16,24或32字节")
+	}
+	return keyHex, nil
+}
--- a/crypto/encipher/encipher.go
+++ b/crypto/encipher/encipher.go
@ -28,9 +28,9 @@ func New(secret string) {

 func GenerateTokenAes(id uint, identity, client, role string, owner any, extend map[string]string) (string, error) {
 	if !(JwtSecretLen == 16 || JwtSecretLen == 24 || JwtSecretLen == 32) {
-		return "", errcode.ErrJWTSecretKey
+		return "", errcode.ErrTokenSecretKey
 	}
-	expireTime := time.Now().Add(vars.JwtExpireDay)
+	expireTime := time.Now().Add(vars.JwtExpire)
 	claims := types.JwtClaims{
 		ID:        id,
 		Identity:  identity,
@ -43,7 +43,7 @@ func GenerateTokenAes(id uint, identity, client, role string, owner any, extend

 	byte, err := json.Marshal(claims)
 	if err != nil {
-		return "", errcode.ErrJWTJsonEncode
+		return "", errcode.ErrTokenJsonEncode
 	}

 	token, err := AesEncryptCBC(byte)
@ -59,7 +59,7 @@ func AesEncryptCBC(plan []byte) (string, error) {
 	// NewCipher该函数限制了输入k的长度必须为16, 24或者32
 	block, err := aes.NewCipher(JwtSecret)
 	if err != nil {
-		return "", errcode.ErrJWTSecretKey
+		return "", errcode.ErrTokenSecretKey
 	}
 	// 获取秘钥块的长度
 	blockSize := block.BlockSize()
@ -76,17 +76,17 @@ func AesEncryptCBC(plan []byte) (string, error) {

 func AesDecryptCBC(cryted string) (b []byte, err error) {
 	if (JwtSecretLen == 16 || JwtSecretLen == 24 || JwtSecretLen == 32) == false {
-		return nil, errcode.ErrJWTSecretKey
+		return nil, errcode.ErrTokenSecretKey
 	}
 	// 转成字节数组
 	crytedByte, err := base64.StdEncoding.DecodeString(cryted)
 	if err != nil {
-		return nil, errcode.ErrJWTBase64Decode
+		return nil, errcode.ErrTokenBase64Decode
 	}
 	// 分组秘钥
 	block, err := aes.NewCipher(JwtSecret)
 	if err != nil {
-		return nil, errcode.ErrJWTSecretKey
+		return nil, errcode.ErrTokenSecretKey
 	}
 	// 获取秘钥块的长度
 	blockSize := block.BlockSize()
@ -99,36 +99,46 @@ func AesDecryptCBC(cryted string) (b []byte, err error) {
 	// 去补全码
 	orig = PKCS7UnPadding(orig, blockSize)
 	if orig == nil {
-		return nil, errcode.ErrJWTAuthParseFail
+		return nil, errcode.ErrTokenAuthParseFail
 	}
 	return orig, nil
 }

+// PKCS7Padding 使用PKCS7填充法对明文进行填充
 func PKCS7Padding(ciphertext []byte, blocksize int) []byte {
 	padding := blocksize - len(ciphertext)%blocksize
 	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
 	return append(ciphertext, padtext...)
 }

-// 去码
+// PKCS7UnPadding 去除PKCS7填充
 // bug:runtime error: slice bounds out of range [:-22]
 func PKCS7UnPadding(origData []byte, blocksize int) []byte {
+	// 检查块大小是否有效
 	if blocksize <= 0 {
 		return nil
 	}
+
+	// 检查原始数据是否为空
 	if origData == nil || len(origData) == 0 {
 		return nil
 	}
+
+	// 检查数据长度是否为块大小的整数倍
 	if len(origData)%blocksize != 0 {
 		return nil
 	}

 	length := len(origData)
+	// 获取填充字节数
 	unpadding := int(origData[length-1])

+	// 检查去填充后数据长度是否有效
 	if length-unpadding <= 0 {
 		return nil
 	}
+
+	// 返回去除填充后的数据
 	return origData[:(length - unpadding)]
 }

@ -142,12 +152,12 @@ func ParseTokenAes(token string) (*types.JwtClaims, error) {
 	var ac *types.JwtClaims
 	err = json.Unmarshal(data, &ac)
 	if err != nil {
-		return nil, errcode.ErrJWTAuthParseFail
+		return nil, errcode.ErrTokenAuthParseFail
 	}

 	expireTime := time.Now().Unix()
 	if expireTime > ac.ExpiresAt {
-		return nil, errcode.ErrJWTAuthExpire
+		return nil, errcode.ErrTokenAuthExpire
 	}

 	return ac, nil
--- a/crypto/token/jwt.go
+++ b/crypto/token/jwt.go
@ -0,0 +1,98 @@
+package token
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"strings"
+	"time"
+
+	"git.apinb.com/bsm-sdk/core/errcode"
+	"git.apinb.com/bsm-sdk/core/vars"
+	"github.com/golang-jwt/jwt/v5"
+)
+
+type Claims struct {
+	ID                   uint              `json:"id"`
+	Identity             string            `json:"identity"`
+	Extend               map[string]string `json:"extend"`
+	Client               string            `json:"client"`
+	Owner                any               `json:"owner"`
+	Role                 string            `json:"role"`
+	jwt.RegisteredClaims                   // v5版本新加的方法
+}
+
+type tokenJwt struct {
+	SecretKey string
+}
+
+func New(secretKey string) *tokenJwt {
+	return &tokenJwt{SecretKey: secretKey}
+}
+
+// 生成JWT
+func (t *tokenJwt) GenerateJwt(id uint, identity, client, role string, owner any, extend map[string]string) (string, error) {
+	keyLen := len(t.SecretKey)
+	if !(keyLen == 16 || keyLen == 24 || keyLen == 32) {
+		return "", errcode.ErrTokenSecretKey
+	}
+
+	now := time.Now()
+
+	claims := Claims{
+		ID:       id,
+		Identity: identity,
+		Client:   client,
+		Extend:   extend,
+		Owner:    owner,
+		Role:     role,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(now.Add(vars.JwtExpire)), // 过期时间24小时
+			IssuedAt:  jwt.NewNumericDate(now),                     // 签发时间
+			NotBefore: jwt.NewNumericDate(now),                     // 生效时间
+		},
+	}
+	// 使用HS256签名算法
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	s, err := token.SignedString([]byte(t.SecretKey))
+	if err != nil {
+		return "", errcode.String(errcode.ErrTokenGenerate, err.Error())
+	}
+	return s, nil
+}
+
+// 解析JWT
+func (t *tokenJwt) ParseJwt(tokenstring string) (*Claims, error) {
+	token, err := jwt.ParseWithClaims(tokenstring, &Claims{}, func(token *jwt.Token) (interface{}, error) {
+		return []byte(t.SecretKey), nil
+	})
+	if claims, ok := token.Claims.(*Claims); ok && token.Valid {
+		return claims, nil
+	} else {
+		return nil, errcode.String(errcode.ErrTokenParse, err.Error())
+	}
+}
+
+// 验证JWT是否过期
+func (t *tokenJwt) IsExpired(tokenstring string) (bool, error) {
+	// 分割JWT的三个部分
+	parts := strings.Split(tokenstring, ".")
+	if len(parts) != 3 {
+		return true, errcode.ErrTokenDataInvalid
+	}
+
+	// 解码Payload部分
+	payload, err := base64.RawURLEncoding.DecodeString(parts[1])
+	if err != nil {
+		return true, errcode.String(errcode.ErrTokenBase64Decode, err.Error())
+	}
+
+	// 解析JSON
+	var claims jwt.RegisteredClaims
+	if err := json.Unmarshal(payload, &claims); err != nil {
+		return true, errcode.String(errcode.ErrTokenJsonDecode, err.Error())
+	}
+
+	// 检查过期时间
+	currentTime := time.Now().Unix()
+	return claims.ExpiresAt.Unix() < currentTime, nil
+}
--- a/database/elastic/elasticsearch.go
+++ b/database/elastic/elasticsearch.go
@ -9,9 +9,9 @@ import (
 	"time"

 	"git.apinb.com/bsm-sdk/core/vars"
-	"github.com/elastic/go-elasticsearch/v8"
-	"github.com/elastic/go-elasticsearch/v8/esapi"
-	"github.com/elastic/go-elasticsearch/v8/esutil"
+	"github.com/elastic/go-elasticsearch/v9"
+	"github.com/elastic/go-elasticsearch/v9/esapi"
+	"github.com/elastic/go-elasticsearch/v9/esutil"
 )

 type ES struct {
--- a/database/new.go
+++ b/database/new.go
@ -0,0 +1,145 @@
+// Package database 提供数据库连接和管理功能
+// 支持MySQL和PostgreSQL数据库，包含连接池管理和自动迁移
+package database
+
+import (
+	"fmt"
+	"strings"
+
+	"git.apinb.com/bsm-sdk/core/database/sql"
+	"git.apinb.com/bsm-sdk/core/types"
+	"git.apinb.com/bsm-sdk/core/vars"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+)
+
+var (
+	// MigrateTables 存储需要在数据库初始化时自动迁移的表
+	MigrateTables []any
+)
+
+// NewDatabase 根据提供的驱动类型创建新的数据库连接
+// 支持MySQL和PostgreSQL数据库
+// driver: 数据库驱动类型 ("mysql" 或 "postgres")
+// dsn: 数据源名称数组
+// options: 数据库连接选项
+// 返回: GORM数据库实例
+func NewDatabase(driver string, dsn []string, options *types.SqlOptions) (db *gorm.DB, err error) {
+	driver = strings.ToLower(driver)
+	switch driver {
+	case "mysql":
+		db, err = NewMysql(dsn, options)
+	case "postgres":
+		db, err = NewPostgres(dsn, options)
+	default:
+		return nil, fmt.Errorf("unsupported database driver: %s", driver)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	// 自动迁移表结构
+	if len(MigrateTables) > 0 {
+		err = db.AutoMigrate(MigrateTables...)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return db, nil
+}
+
+// NewMysql 创建MySQL数据库服务
+// dsn: 数据源名称数组
+// options: 数据库连接选项
+// 返回: GORM数据库实例
+func NewMysql(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err error) {
+	// 设置连接默认值
+	if options == nil {
+		options = &types.SqlOptions{
+			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
+			MaxOpenConns:    vars.SqlOptionMaxOpenConns,
+			ConnMaxLifetime: vars.SqlOptionConnMaxLifetime,
+			LogStdout:       false,
+			Debug:           true,
+		}
+	}
+
+	gormDb, err = gorm.Open(mysql.Open(dsn[0]), &gorm.Config{
+		SkipDefaultTransaction: true,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if options.Debug {
+		gormDb = gormDb.Debug()
+	}
+
+	// 获取通用数据库对象 sql.DB，然后使用其提供的功能
+	sqlDB, err := gormDb.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量
+	sqlDB.SetMaxIdleConns(options.MaxIdleConns)
+	// SetMaxOpenConns 设置打开数据库连接的最大数量
+	sqlDB.SetMaxOpenConns(options.MaxOpenConns)
+	// SetConnMaxLifetime 设置了连接可复用的最大时间
+	sqlDB.SetConnMaxLifetime(options.ConnMaxLifetime)
+
+	return gormDb, nil
+}
+
+// NewPostgres 创建PostgreSQL数据库服务
+// dsn: 数据源名称数组
+// options: 数据库连接选项
+// 返回: GORM数据库实例
+func NewPostgres(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err error) {
+	// 设置连接默认值
+	if options == nil {
+		options = &types.SqlOptions{
+			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
+			MaxOpenConns:    vars.SqlOptionMaxOpenConns,
+			ConnMaxLifetime: vars.SqlOptionConnMaxLifetime,
+			LogStdout:       false,
+			Debug:           true,
+		}
+	}
+
+	gormDb, err = sql.NewPostgreSql(dsn[0], options)
+	if err != nil {
+		return nil, err
+	}
+
+	if options.Debug {
+		gormDb = gormDb.Debug()
+	}
+
+	// 获取通用数据库对象 sql.DB，然后使用其提供的功能
+	sqlDB, err := gormDb.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量
+	sqlDB.SetMaxIdleConns(options.MaxIdleConns)
+	// SetMaxOpenConns 设置打开数据库连接的最大数量
+	sqlDB.SetMaxOpenConns(options.MaxOpenConns)
+	// SetConnMaxLifetime 设置了连接可复用的最大时间
+	sqlDB.SetConnMaxLifetime(options.ConnMaxLifetime)
+
+	return gormDb, nil
+}
+
+// AppendMigrate 调用此函数后，会在数据库初始化时自动迁移表结构
+//
+// - table: 需要自动迁移的表
+func AppendMigrate(table any) {
+	if MigrateTables == nil {
+		MigrateTables = make([]any, 0)
+	}
+	MigrateTables = append(MigrateTables, table)
+}
--- a/database/sql/postgresql.go
+++ b/database/sql/postgresql.go
@ -12,7 +12,7 @@ func SetOptions(options *types.SqlOptions) *types.SqlOptions {
 	if options == nil {
 		options = &types.SqlOptions{
 			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
-			MaxOpenConns:    vars.SqlOptionMaxIdleConns,
+			MaxOpenConns:    vars.SqlOptionMaxOpenConns,
 			ConnMaxLifetime: vars.SqlOptionConnMaxLifetime,
 			LogStdout:       false,
 			Debug:           false,
@ -30,7 +30,7 @@ func NewPostgreSql(dsn string, options *types.SqlOptions) (*gorm.DB, error) {
 	if options == nil {
 		options = &types.SqlOptions{
 			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
-			MaxOpenConns:    vars.SqlOptionMaxIdleConns,
+			MaxOpenConns:    vars.SqlOptionMaxOpenConns,
 			ConnMaxLifetime: vars.SqlOptionConnMaxLifetime,
 			LogStdout:       false,
 			Debug:           true,
@ -56,7 +56,11 @@ func NewPostgreSql(dsn string, options *types.SqlOptions) (*gorm.DB, error) {
 	}

 	// 获取通用数据库对象 sql.DB ，然后使用其提供的功能
-	sqlDB, _ := gormDb.DB()
+	sqlDB, err := gormDb.DB()
+	if err != nil {
+		return nil, err
+	}
+	
 	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量。
 	sqlDB.SetMaxIdleConns(options.MaxIdleConns)
 	// SetMaxOpenConns 设置打开数据库连接的最大数量。
@ -65,4 +69,4 @@ func NewPostgreSql(dsn string, options *types.SqlOptions) (*gorm.DB, error) {
 	sqlDB.SetConnMaxLifetime(options.ConnMaxLifetime)

 	return gormDb, nil
-}
+}
--- a/env/env.go
+++ b/env/env.go
@ -15,7 +15,7 @@ var Runtime *types.RuntimeEnv = nil
 func NewEnv() *types.RuntimeEnv {
 	if Runtime == nil {
 		Runtime = &types.RuntimeEnv{
-			Workspace:    GetEnvDefault("BSM_Workspace", "def"),
+			Workspace:    GetEnvDefault("BSM_Workspace", "default"),
 			JwtSecretKey: GetEnvDefault("BSM_JwtSecretKey", "Cblocksmesh2022C"),
 			Mode:         strings.ToLower(GetEnvDefault("BSM_RuntimeMode", "dev")),
 			LicencePath:  strings.ToLower(GetEnvDefault("BSM_Licence", "")),
--- a/errcode/errcode.go
+++ b/errcode/errcode.go
@ -1,3 +1,5 @@
+// Package errcode 提供统一的错误码管理
+// 定义了系统中所有可能的错误类型和对应的错误码
 package errcode

 import (
@ -5,78 +7,108 @@ import (
 	"google.golang.org/grpc/status"
 )

-// header error code ,start:100
+// HTTP请求头相关错误码，起始码:1000
 var (
-	ErrHeaderRequestId     = NewError(101, "Header Request-Id Not Found")
-	ErrHeaderAuthorization = NewError(102, "Header Authorization Not Found")
-	ErrHeaderSecretKey     = NewError(103, "Header Secret-Key Not Found")
-	ErrHeaderMustParams    = NewError(104, "Header Must Params")
+	AllErrors              = make(map[int]string)
+	ErrHeaderRequestId     = NewError(1001, "Header Request-Id Not Found")    // 请求ID头缺失
+	ErrHeaderAuthorization = NewError(1002, "Header Authorization Not Found") // 授权头缺失
+	ErrHeaderSecretKey     = NewError(1003, "Header Secret-Key Not Found")    // 密钥头缺失
+	ErrHeaderMustParams    = NewError(1004, "Header Must Params")             // 必需参数头缺失
 )

-// standard error code ,start:110
+// 标准业务错误码，起始码:1100
 var (
-	ErrEmpty         = NewError(110, "Data Is Empty")
-	ErrRequestParse  = NewError(111, "Request Parse Fail")
-	ErrRequestMust   = NewError(112, "Request Params Required")
-	ErrPermission    = NewError(113, "Permission Denied")
-	ErrJsonUnmarshal = NewError(114, "Json Unmarshal Fail")
-	ErrJsonMarshal   = NewError(115, "Json Marshal Fail")
-	ErrInternal      = NewError(116, "Internal Server Error")
+	ErrEmpty           = NewError(1101, "Data Is Empty")           // 数据为空
+	ErrRequestParse    = NewError(1102, "Request Parse Fail")      // 请求解析失败
+	ErrRequestMust     = NewError(1103, "Request Params Required") // 请求参数必需
+	ErrPermission      = NewError(1104, "Permission Denied")       // 权限不足
+	ErrJsonUnmarshal   = NewError(1105, "Json Unmarshal Fail")     // JSON反序列化失败
+	ErrJsonMarshal     = NewError(1106, "Json Marshal Fail")       // JSON序列化失败
+	ErrInternal        = NewError(1107, "Internal Server Error")   // 内部服务器错误
+	ErrPassword        = NewError(1108, "Password Incorrect")      // 密码错误
+	ErrAccountDisabled = NewError(1110, "Account Disabled")        // 账户已禁用
+	ErrDisabled        = NewError(1111, "Status Disabled")         // 状态已禁用
+	ErrRecordNotFound  = NewError(1112, "Record Not Found")        // 记录未找到
 )

-// jwt error code ,start:130
+// Token认证相关错误码，起始码:1300
 var (
-	ErrJWTAuthNotFound     = NewError(131, "JWT Authorization Not Found")
-	ErrJWTBase64Decode     = NewError(132, "JWT Authorization Base64 Decode Error")
-	ErrJWTAuthParseFail    = NewError(133, "JWT Authorization Fail")
-	ErrJWTAuthKeyId        = NewError(134, "JWT Key:Id Incorrect")
-	ErrJWTAuthKeyIdentity  = NewError(135, "JWT Key:Identity Incorrect")
-	ErrJWTAuthTokenChanged = NewError(136, "JWT Authorization Changed")
-	ErrJWTAuthExpire       = NewError(137, "JWT Authorization Expire")
-	ErrJWTJsonDecode       = NewError(138, "JWT Authorization JSON Decode Error")
-	ErrJWTJsonEncode       = NewError(139, "JWT Authorization JSON Encode Error")
-	ErrJWTSecretKey        = NewError(139, "JWT SecretKey Error")
+	ErrTokenAuthNotFound      = NewError(1301, "Token Authorization Not Found")           // Token授权未找到
+	ErrTokenDataInvalid       = NewError(1302, "Token Authorization Data Invalid")        // Token授权数据无效
+	ErrTokenBase64Decode      = NewError(1303, "Token Authorization Base64 Decode Error") // Token Base64解码错误
+	ErrTokenAuthParseFail     = NewError(1304, "Token Authorization Fail")                // Token授权解析失败
+	ErrTokenAuthKeyId         = NewError(1305, "Token Key:Id Incorrect")                  // Token密钥ID错误
+	ErrTokenAuthKeyIdentity   = NewError(1306, "Token Key:Identity Incorrect")            // Token密钥身份错误
+	ErrTokenAuthTokenChanged  = NewError(1307, "Token Authorization Changed")             // Token授权已变更
+	ErrTokenAuthExpire        = NewError(1308, "Token Authorization Expire")              // Token授权已过期
+	ErrTokenJsonDecode        = NewError(1309, "Token Authorization JSON Decode Error")   // Token JSON解码错误
+	ErrTokenJsonEncode        = NewError(1310, "Token Authorization JSON Encode Error")   // Token JSON编码错误
+	ErrTokenSecretKey         = NewError(1311, "Token SecretKey Error")                   // Token密钥错误
+	ErrTokenSecretKeyNotFound = NewError(1312, "Token SecretKey Not Found")               // Token密钥未找到
+	ErrTokenGenerate          = NewError(1313, "Generate Token Fail")                     // 生成令牌失败
+	ErrTokenParse             = NewError(1314, "Parse Token Fail")                        // 解析令牌失败
 )

-// model error code ,start:150
+// 基础设施相关错误码，起始码:1500
 var (
-	ErrDB    = NewError(151, "DB Fatal Error")
-	ErrRedis = NewError(152, "Redis Fatal Error")
-	ErrMq    = NewError(153, "MQ Fatal Error")
-	ErrOss   = NewError(154, "OSS Fatal Error")
-	ErrRpc   = NewError(155, "RPC Fatal Error")
-	ErrApm   = NewError(156, "APM Fatal Error")
-	ErrEtcd  = NewError(157, "Etcd Fatal Error")
+	ErrDB    = NewError(1501, "DB Fatal Error")    // 数据库致命错误
+	ErrRedis = NewError(1502, "Redis Fatal Error") // Redis致命错误
+	ErrMq    = NewError(1503, "MQ Fatal Error")    // 消息队列致命错误
+	ErrOss   = NewError(1504, "OSS Fatal Error")   // 对象存储致命错误
+	ErrRpc   = NewError(1505, "RPC Fatal Error")   // RPC致命错误
+	ErrApm   = NewError(1506, "APM Fatal Error")   // 应用性能监控致命错误
+	ErrEtcd  = NewError(1507, "Etcd Fatal Error")  // Etcd致命错误
 )

-// google grpc error status.
+// Google gRPC标准错误状态码，起始码:1700
 var (
-	OK                    = NewError(171, "OK")
-	ErrCanceled           = NewError(172, "Canceled")
-	ErrUnknown            = NewError(173, "Unknown")
-	ErrInvalidArgument    = NewError(174, "Invalid Argument")
-	ErrDeadlineExceeded   = NewError(175, "Deadline Exceeded")
-	ErrAlreadyExists      = NewError(176, "Already Exists")
-	ErrPermissionDenied   = NewError(177, "Permission Denied")
-	ErrResourceExhausted  = NewError(178, "Resource Exhausted")
-	ErrFailedPrecondition = NewError(179, "Failed Precondition")
-	ErrAborted            = NewError(181, "Aborted")
-	ErrOutOfRange         = NewError(182, "Out Of Range")
-	ErrUnimplemented      = NewError(183, "Unimplemented")
-	ErrUnavailable        = NewError(184, "Unavailable")
-	ErrDataLoss           = NewError(185, "Data Loss")
-	ErrUnauthenticated    = NewError(186, "Unauthenticated")
+	OK                    = NewError(0, "OK")                     // 成功
+	ErrAccountNotFound    = ErrNotFound(404, "Account")           // 账户未找到
+	ErrCanceled           = NewError(1702, "Canceled")            // 操作已取消
+	ErrUnknown            = NewError(1703, "Unknown")             // 未知错误
+	ErrInvalidArgument    = NewError(1704, "Invalid Argument")    // 无效参数
+	ErrDeadlineExceeded   = NewError(1705, "Deadline Exceeded")   // 超时
+	ErrAlreadyExists      = NewError(1706, "Already Exists")      // 已存在
+	ErrPermissionDenied   = NewError(1707, "Permission Denied")   // 权限拒绝
+	ErrResourceExhausted  = NewError(1708, "Resource Exhausted")  // 资源耗尽
+	ErrFailedPrecondition = NewError(1709, "Failed Precondition") // 前置条件失败
+	ErrAborted            = NewError(1710, "Aborted")             // 操作中止
+	ErrOutOfRange         = NewError(1711, "Out Of Range")        // 超出范围
+	ErrUnimplemented      = NewError(1712, "Unimplemented")       // 未实现
+	ErrUnavailable        = NewError(1713, "Unavailable")         // 不可用
+	ErrDataLoss           = NewError(1714, "Data Loss")           // 数据丢失
+	ErrUnauthenticated    = NewError(1715, "Unauthenticated")     // 未认证
 )

+// NewError 创建新的错误实例
+// code: 错误码
+// msg: 错误消息
 func NewError(code int, msg string) error {
+	AllErrors[code] = msg
 	return status.New(codes.Code(code), msg).Err()
 }

-// custom error,status code:500
+// ErrFatal 创建致命错误，状态码:500
+// code: 错误码
+// msg: 错误消息
 func ErrFatal(code int, msg string) error {
+	AllErrors[code] = msg
 	return status.New(codes.Code(code), msg).Err()
 }

+// ErrNotFound 创建未找到错误
+// code: 错误码
+// msg: 错误消息，会自动转换为大写
 func ErrNotFound(code int, msg string) error {
+	AllErrors[code] = msg
 	return status.New(codes.Code(code), msg).Err()
 }
+
+// IsErr 检查错误是否与指定的错误匹配
+func IsErr(err, target error) bool {
+	return status.Code(err) == status.Code(target)
+}
+
+func String(err error, msg string) error {
+	return status.New(status.Code(err), err.Error()+", "+msg).Err()
+}
--- a/go.mod
+++ b/go.mod
@ -1,83 +1,92 @@
 module git.apinb.com/bsm-sdk/core

-go 1.24
+go 1.25.1

 require (
-	github.com/FishGoddess/cachego v0.6.1
-	github.com/elastic/go-elasticsearch/v8 v8.17.1
+	github.com/allegro/bigcache/v3 v3.1.0
+	github.com/elastic/go-elasticsearch/v9 v9.2.0
+	github.com/gin-contrib/cors v1.7.6
+	github.com/gin-gonic/gin v1.11.0
+	github.com/golang-jwt/jwt/v5 v5.3.0
 	github.com/google/uuid v1.6.0
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3
-	github.com/nats-io/nats.go v1.39.0
-	github.com/oklog/ulid/v2 v2.1.0
-	github.com/redis/go-redis/v9 v9.7.0
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3
+	github.com/nats-io/nats.go v1.47.0
+	github.com/oklog/ulid/v2 v2.1.1
+	github.com/redis/go-redis/v9 v9.16.0
 	github.com/shirou/gopsutil v3.21.11+incompatible
-	go.etcd.io/etcd/client/v3 v3.5.18
+	go.etcd.io/etcd/client/pkg/v3 v3.6.5
+	go.etcd.io/etcd/client/v3 v3.6.5
+	google.golang.org/grpc v1.76.0
 	gopkg.in/yaml.v3 v3.0.1
-	gorm.io/driver/postgres v1.5.11
-	gorm.io/gorm v1.25.12
-)
-
-require (
-	github.com/bytedance/sonic v1.13.2 // indirect
-	github.com/bytedance/sonic/loader v0.2.4 // indirect
-	github.com/cloudwego/base64x v0.1.5 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
-	github.com/gin-contrib/sse v1.0.0 // indirect
-	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.25.0 // indirect
-	github.com/goccy/go-json v0.10.5 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.9 // indirect
-	github.com/leodido/go-urn v1.4.0 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
-	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/ugorji/go/codec v1.2.12 // indirect
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	golang.org/x/arch v0.14.0 // indirect
+	gorm.io/driver/mysql v1.6.0
+	gorm.io/driver/postgres v1.6.0
+	gorm.io/gorm v1.31.1
 )

 require (
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/bytedance/sonic v1.14.0 // indirect
+	github.com/bytedance/sonic/loader v0.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cloudwego/base64x v0.1.6 // indirect
 	github.com/coreos/go-semver v0.3.1 // indirect
 	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/elastic/elastic-transport-go/v8 v8.6.1 // indirect
-	github.com/gin-gonic/gin v1.10.0
-	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/elastic/elastic-transport-go/v8 v8.7.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.9 // indirect
+	github.com/gin-contrib/sse v1.1.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.27.0 // indirect
+	github.com/go-sql-driver/mysql v1.8.1 // indirect
+	github.com/goccy/go-json v0.10.5 // indirect
+	github.com/goccy/go-yaml v1.18.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
-	github.com/jackc/pgx/v5 v5.7.2 // indirect
+	github.com/jackc/pgx/v5 v5.6.0 // indirect
 	github.com/jackc/puddle/v2 v2.2.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/klauspost/compress v1.17.11 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/nats-io/nkeys v0.4.10 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/nats-io/nkeys v0.4.11 // indirect
 	github.com/nats-io/nuid v1.0.1 // indirect
-	github.com/tklauser/go-sysconf v0.3.14 // indirect
-	github.com/tklauser/numcpus v0.9.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/quic-go/qpack v0.5.1 // indirect
+	github.com/quic-go/quic-go v0.54.0 // indirect
+	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e // indirect
+	github.com/tklauser/go-sysconf v0.3.15 // indirect
+	github.com/tklauser/numcpus v0.10.0 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.3.0 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
-	go.etcd.io/etcd/api/v3 v3.5.18 // indirect
-	go.etcd.io/etcd/client/pkg/v3 v3.5.18 // indirect
-	go.opentelemetry.io/otel v1.34.0 // indirect
-	go.opentelemetry.io/otel/metric v1.34.0 // indirect
-	go.opentelemetry.io/otel/trace v1.34.0 // indirect
+	go.etcd.io/etcd/api/v3 v3.6.5 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel v1.37.0 // indirect
+	go.opentelemetry.io/otel/metric v1.37.0 // indirect
+	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.uber.org/mock v0.5.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.27.0 // indirect
-	golang.org/x/crypto v0.33.0 // indirect
-	golang.org/x/net v0.35.0 // indirect
-	golang.org/x/sync v0.11.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
-	golang.org/x/text v0.22.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20250303144028-a0af3efb3deb // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250303144028-a0af3efb3deb // indirect
-	google.golang.org/grpc v1.70.0
-	google.golang.org/protobuf v1.36.5 // indirect
+	golang.org/x/arch v0.20.0 // indirect
+	golang.org/x/crypto v0.41.0 // indirect
+	golang.org/x/mod v0.27.0 // indirect
+	golang.org/x/net v0.43.0 // indirect
+	golang.org/x/sync v0.17.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/text v0.29.0 // indirect
+	golang.org/x/tools v0.36.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 // indirect
+	google.golang.org/protobuf v1.36.10 // indirect
 )
--- a/go.sum
+++ b/go.sum
@ -1,19 +1,19 @@
-github.com/FishGoddess/cachego v0.6.1 h1:mbytec3loqw5dcO177LyRGyStKG0AngP5g2GR3SzSh0=
-github.com/FishGoddess/cachego v0.6.1/go.mod h1:VLSMwWRlRPazjGYer8pq+4aDrIe1Otj3Yy9HAb0eo3c=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/allegro/bigcache/v3 v3.1.0 h1:H2Vp8VOvxcrB91o86fUSVJFqeuz8kpyyB02eH3bSzwk=
+github.com/allegro/bigcache/v3 v3.1.0/go.mod h1:aPyh7jEvrog9zAwx5N7+JUQX5dZTSGpxF1LAR4dr35I=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
-github.com/bytedance/sonic v1.13.2 h1:8/H1FempDZqC4VqjptGo14QQlJx8VdZJegxs6wwfqpQ=
-github.com/bytedance/sonic v1.13.2/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
-github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/bytedance/sonic/loader v0.2.4 h1:ZWCw4stuXUsn1/+zQDqeE7JKP+QO47tz7QCNan80NzY=
-github.com/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/bytedance/sonic v1.14.0 h1:/OfKt8HFw0kh2rj8N0F6C/qPGRESq0BbaNZgcNXXzQQ=
+github.com/bytedance/sonic v1.14.0/go.mod h1:WoEbx8WTcFJfzCe0hbmyTGrfjt8PzNEBdxlNUO24NhA=
+github.com/bytedance/sonic/loader v0.3.0 h1:dskwH8edlzNMctoruo8FPTJDF3vLtDT0sXZwvZJyqeA=
+github.com/bytedance/sonic/loader v0.3.0/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cloudwego/base64x v0.1.5 h1:XPciSp1xaq2VCSt6lF0phncD4koWyULpl5bUxbfCyP4=
-github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
-github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
+github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
 github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4=
 github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec=
 github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
@ -23,37 +23,44 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/elastic/elastic-transport-go/v8 v8.6.1 h1:h2jQRqH6eLGiBSN4eZbQnJLtL4bC5b4lfVFRjw2R4e4=
-github.com/elastic/elastic-transport-go/v8 v8.6.1/go.mod h1:YLHer5cj0csTzNFXoNQ8qhtGY1GTvSqPnKWKaqQE3Hk=
-github.com/elastic/go-elasticsearch/v8 v8.17.1 h1:bOXChDoCMB4TIwwGqKd031U8OXssmWLT3UrAr9EGs3Q=
-github.com/elastic/go-elasticsearch/v8 v8.17.1/go.mod h1:MVJCtL+gJJ7x5jFeUmA20O7rvipX8GcQmo5iBcmaJn4=
-github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
-github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
-github.com/gin-contrib/sse v1.0.0 h1:y3bT1mUWUxDpW4JLQg/HnTqV4rozuW4tC9eFKTxYI9E=
-github.com/gin-contrib/sse v1.0.0/go.mod h1:zNuFdwarAygJBht0NTKiSi3jRf6RbqeILZ9Sp6Slhe0=
-github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
-github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/elastic/elastic-transport-go/v8 v8.7.0 h1:OgTneVuXP2uip4BA658Xi6Hfw+PeIOod2rY3GVMGoVE=
+github.com/elastic/elastic-transport-go/v8 v8.7.0/go.mod h1:YLHer5cj0csTzNFXoNQ8qhtGY1GTvSqPnKWKaqQE3Hk=
+github.com/elastic/go-elasticsearch/v9 v9.2.0 h1:COeL/g20+ixnUbffe4Wfbu88emrHjAq/LhVfmrjqRQs=
+github.com/elastic/go-elasticsearch/v9 v9.2.0/go.mod h1:2PB5YQPpY5tWbF65MRqzEXA31PZOdXCkloQSOZtU14I=
+github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
+github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
+github.com/gin-contrib/cors v1.7.6 h1:3gQ8GMzs1Ylpf70y8bMw4fVpycXIeX1ZemuSQIsnQQY=
+github.com/gin-contrib/cors v1.7.6/go.mod h1:Ulcl+xN4jel9t1Ry8vqph23a60FwH9xVLd+3ykmTjOk=
+github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
+github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
+github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk=
+github.com/gin-gonic/gin v1.11.0/go.mod h1:+iq/FyxlGzII0KHiBGjuNn4UNENUlKbGlNmc+W50Dls=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
-github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
-github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
-github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.25.0 h1:5Dh7cjvzR7BRZadnsVOzPhWsrwUr0nmsZJxEAnFLNO8=
-github.com/go-playground/validator/v10 v10.25.0/go.mod h1:GGzBIJMuE98Ic/kJsBXbz1x/7cByt++cQ+YOuDM5wus=
+github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
+github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
+github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
 github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
 github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
+github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
@ -61,14 +68,14 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 h1:5ZPtiqj0JL5oKWmcsq4VMaAW5ukBEgSGXEN89zeH1Jo=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3/go.mod h1:ndYquD05frm2vACXE1nsccT4oJzjhw2arTS2cpUD1PI=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI=
-github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
+github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
+github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
 github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
 github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
@ -79,12 +86,10 @@ github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnr
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
-github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
-github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=
-github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
-github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
+github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@ -98,129 +103,141 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/nats-io/nats.go v1.39.0 h1:2/yg2JQjiYYKLwDuBzV0FbB2sIV+eFNkEevlRi4n9lI=
-github.com/nats-io/nats.go v1.39.0/go.mod h1:MgRb8oOdigA6cYpEPhXJuRVH6UE/V4jblJ2jQ27IXYM=
-github.com/nats-io/nkeys v0.4.10 h1:glmRrpCmYLHByYcePvnTBEAwawwapjCPMjy2huw20wc=
-github.com/nats-io/nkeys v0.4.10/go.mod h1:OjRrnIKnWBFl+s4YK5ChQfvHP2fxqZexrKJoVVyWB3U=
+github.com/nats-io/nats.go v1.47.0 h1:YQdADw6J/UfGUd2Oy6tn4Hq6YHxCaJrVKayxxFqYrgM=
+github.com/nats-io/nats.go v1.47.0/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g=
+github.com/nats-io/nkeys v0.4.11 h1:q44qGV008kYd9W1b1nEBkNzvnWxtRSQ7A8BoqRrcfa0=
+github.com/nats-io/nkeys v0.4.11/go.mod h1:szDimtgmfOi9n25JpfIdGw12tZFYXqhGxjhVxsatHVE=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
-github.com/oklog/ulid/v2 v2.1.0 h1:+9lhoxAP56we25tyYETBBY1YLA2SaoLvUFgrP2miPJU=
-github.com/oklog/ulid/v2 v2.1.0/go.mod h1:rcEKHmBBKfef9DhnvX7y1HZBYxjXb0cP5ExxNsTT1QQ=
+github.com/oklog/ulid/v2 v2.1.1 h1:suPZ4ARWLOJLegGFiZZ1dFAkqzhMjL3J1TzI+5wHz8s=
+github.com/oklog/ulid/v2 v2.1.1/go.mod h1:rcEKHmBBKfef9DhnvX7y1HZBYxjXb0cP5ExxNsTT1QQ=
 github.com/pborman/getopt v0.0.0-20170112200414-7148bc3a4c30/go.mod h1:85jBQOZwpVEaDAr341tbn15RS4fCAsIst0qp7i8ex1o=
-github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
-github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/redis/go-redis/v9 v9.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E=
-github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw=
-github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
+github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
+github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg=
+github.com/quic-go/quic-go v0.54.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
+github.com/redis/go-redis/v9 v9.16.0 h1:OotgqgLSRCmzfqChbQyG1PHC3tLNR89DG4jdOERSEP4=
+github.com/redis/go-redis/v9 v9.16.0/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e h1:MRM5ITcdelLK2j1vwZ3Je0FKVCfqOLp5zO6trqMLYs0=
+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e/go.mod h1:XV66xRDqSt+GTGFMVlhk3ULuV0y9ZmzeVGR4mloJI3M=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=
-github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY=
-github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo=
-github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
+github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
+github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
+github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
-github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
-github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
+github.com/ugorji/go/codec v1.3.0/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
 github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.etcd.io/etcd/api/v3 v3.5.18 h1:Q4oDAKnmwqTo5lafvB+afbgCDF7E35E4EYV2g+FNGhs=
-go.etcd.io/etcd/api/v3 v3.5.18/go.mod h1:uY03Ob2H50077J7Qq0DeehjM/A9S8PhVfbQ1mSaMopU=
-go.etcd.io/etcd/client/pkg/v3 v3.5.18 h1:mZPOYw4h8rTk7TeJ5+3udUkfVGBqc+GCjOJYd68QgNM=
-go.etcd.io/etcd/client/pkg/v3 v3.5.18/go.mod h1:BxVf2o5wXG9ZJV+/Cu7QNUiJYk4A29sAhoI5tIRsCu4=
-go.etcd.io/etcd/client/v3 v3.5.18 h1:nvvYmNHGumkDjZhTHgVU36A9pykGa2K4lAJ0yY7hcXA=
-go.etcd.io/etcd/client/v3 v3.5.18/go.mod h1:kmemwOsPU9broExyhYsBxX4spCTDX3yLgPMWtpBXG6E=
+go.etcd.io/etcd/api/v3 v3.6.5 h1:pMMc42276sgR1j1raO/Qv3QI9Af/AuyQUW6CBAWuntA=
+go.etcd.io/etcd/api/v3 v3.6.5/go.mod h1:ob0/oWA/UQQlT1BmaEkWQzI0sJ1M0Et0mMpaABxguOQ=
+go.etcd.io/etcd/client/pkg/v3 v3.6.5 h1:Duz9fAzIZFhYWgRjp/FgNq2gO1jId9Yae/rLn3RrBP8=
+go.etcd.io/etcd/client/pkg/v3 v3.6.5/go.mod h1:8Wx3eGRPiy0qOFMZT/hfvdos+DjEaPxdIDiCDUv/FQk=
+go.etcd.io/etcd/client/v3 v3.6.5 h1:yRwZNFBx/35VKHTcLDeO7XVLbCBFbPi+XV4OC3QJf2U=
+go.etcd.io/etcd/client/v3 v3.6.5/go.mod h1:ZqwG/7TAFZ0BJ0jXRPoJjKQJtbFo/9NIY8uoFFKcCyo=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
-go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
-go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
-go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
-go.opentelemetry.io/otel/sdk v1.32.0 h1:RNxepc9vK59A8XsgZQouW8ue8Gkb4jpWtJm9ge5lEG4=
-go.opentelemetry.io/otel/sdk v1.32.0/go.mod h1:LqgegDBjKMmb2GC6/PrTnteJG39I8/vJCAP9LlJXEjU=
-go.opentelemetry.io/otel/sdk/metric v1.32.0 h1:rZvFnvmvawYb0alrYkjraqJq0Z4ZUJAiyYCU9snn1CU=
-go.opentelemetry.io/otel/sdk/metric v1.32.0/go.mod h1:PWeZlq0zt9YkYAp3gjKZ0eicRYvOh1Gd+X99x6GHpCQ=
-go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
-go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
+go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
+go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
+go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
+go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
+go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
+go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
+go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
+go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
+go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
+go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
+go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
 go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
-golang.org/x/arch v0.14.0 h1:z9JUEZWr8x4rR0OU6c4/4t6E6jOZ8/QBS2bBYBm4tx4=
-golang.org/x/arch v0.14.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/arch v0.20.0 h1:dx1zTU0MAE98U+TQ8BLl7XsJbgze2WnNKF/8tGp/Q6c=
+golang.org/x/arch v0.20.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
+golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
+golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
+golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
-golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
+golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto/googleapis/api v0.0.0-20250303144028-a0af3efb3deb h1:p31xT4yrYrSM/G4Sn2+TNUkVhFCbG9y8itM2S6Th950=
-google.golang.org/genproto/googleapis/api v0.0.0-20250303144028-a0af3efb3deb/go.mod h1:jbe3Bkdp+Dh2IrslsFCklNhweNTBgSYanP1UXhJDhKg=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250303144028-a0af3efb3deb h1:TLPQVbx1GJ8VKZxz52VAxl1EBgKXXbTiU9Fc5fZeLn4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250303144028-a0af3efb3deb/go.mod h1:LuRYeWDFV6WOn90g357N17oMCaxpgCnbi/44qJvDn2I=
-google.golang.org/grpc v1.70.0 h1:pWFv03aZoHzlRKHWicjsZytKAiYCtNS0dHbXnIdq7jQ=
-google.golang.org/grpc v1.70.0/go.mod h1:ofIJqVKDXx/JiXrwr2IG4/zwdH9txy3IlF40RmcJSQw=
-google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
-google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
+google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4 h1:8XJ4pajGwOlasW+L13MnEGA8W4115jJySQtVfS2/IBU=
+google.golang.org/genproto/googleapis/api v0.0.0-20250929231259-57b25ae835d4/go.mod h1:NnuHhy+bxcg30o7FnVAZbXsPHUDQ9qKWAQKCD7VxFtk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 h1:i8QOKZfYg6AbGVZzUAY3LrNWCKF8O6zFisU9Wl9RER4=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4/go.mod h1:HSkG/KdJWusxU1F6CNrwNDjBMgisKxGnc5dAZfT0mjQ=
+google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A=
+google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gorm.io/driver/postgres v1.5.11 h1:ubBVAfbKEUld/twyKZ0IYn9rSQh448EdelLYk9Mv314=
-gorm.io/driver/postgres v1.5.11/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI=
-gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
-gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=
-nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+gorm.io/driver/mysql v1.6.0 h1:eNbLmNTpPpTOVZi8MMxCi2aaIm0ZpInbORNXDwyLGvg=
+gorm.io/driver/mysql v1.6.0/go.mod h1:D/oCC2GWK3M/dqoLxnOlaNKmXz8WNTfcS9y5ovaSqKo=
+gorm.io/driver/postgres v1.6.0 h1:2dxzU8xJ+ivvqTRph34QX+WrRaJlmfyPqXmoGVjMBa4=
+gorm.io/driver/postgres v1.6.0/go.mod h1:vUw0mrGgrTK+uPHEhAdV4sfFELrByKVGnaVRkXDhtWo=
+gorm.io/gorm v1.31.1 h1:7CA8FTFz/gRfgqgpeKIBcervUn3xSyPUmr6B2WXJ7kg=
+gorm.io/gorm v1.31.1/go.mod h1:XyQVbO2k6YkOis7C2437jSit3SsDK72s7n7rsSHd+Gs=
--- a/infra/logs.go
+++ b/infra/logs.go
@ -0,0 +1,37 @@
+package infra
+
+import (
+	"encoding/json"
+
+	"git.apinb.com/bsm-sdk/core/utils"
+)
+
+type LogItem struct {
+	OpID   uint   `json:"op_id"`
+	OpName string `json:"op_name"`
+	OpType string `json:"op_type"`
+	Text   string `json:"text"`
+	Code   string `json:"code"`
+	Level  uint   `json:"level"`
+	Ip     string `json:"ip"`
+	Module string `json:"module"`
+	Encry  bool   `json:"encry"`
+}
+
+var (
+	Type_Login    string = "login"
+	Type_Logout   string = "logout"
+	Type_Register string = "register"
+	Type_Update   string = "update"
+	Type_Delete   string = "delete"
+	Type_Query    string = "query"
+	Type_Other    string = "other"
+	Type_Create   string = "create"
+)
+
+func PushLog(endpoint string, data []*LogItem) {
+	jsonBytes, _ := json.Marshal(data)
+
+	go utils.HttpPost(endpoint, nil, jsonBytes)
+
+}
--- a/infra/response.go
+++ b/infra/response.go
@ -1,37 +1,53 @@
+// Package infra 提供基础设施功能
+// 包括统一响应处理、健康检查、日志等
 package infra

 import (
+	"time"
+
 	"github.com/gin-gonic/gin"
 	"google.golang.org/grpc/status"
 )

 var Response Reply

+// Reply 统一响应结构体
 type Reply struct {
-	Code int    `json:"code"`
-	Msg  string `json:"msg"`
-	Data any    `json:"data"`
+	Code    int32  `json:"code"`    // 响应码
+	Message string `json:"message"` // 响应消息
+	Details any    `json:"details"` // 响应数据
+	Timeseq int64  `json:"timeseq"` // 时间戳序列
 }

+// Success 返回成功响应
+// ctx: Gin上下文
+// data: 响应数据
 func (reply *Reply) Success(ctx *gin.Context, data any) {
-	reply.Code = 200
-	reply.Data = data
-	reply.Msg = ""
+	reply.Code = 0
+	reply.Details = data
+	reply.Message = ""
+	reply.Timeseq = time.Now().UnixMilli()
 	if data == nil {
-		reply.Data = ""
+		reply.Details = ""
 	}
 	ctx.JSON(200, reply)
 }
+
+// Error 返回错误响应
+// ctx: Gin上下文
+// err: 错误对象
 func (reply *Reply) Error(ctx *gin.Context, err error) {
 	reply.Code = 500
-	reply.Data = ""
-	// Status code defaults to 500
+	reply.Details = ""
+	// 默认状态码为500
 	e, ok := status.FromError(err)
 	if ok {
-		reply.Code = int(e.Code())
+		reply.Code = int32(e.Code())
+		reply.Message = e.Message()
+	} else {
+		reply.Message = err.Error()
 	}
-	reply.Msg = e.Message()

-	// Send error
+	// 发送错误响应
 	ctx.JSON(200, reply)
 }
--- a/infra/service.go
+++ b/infra/service.go
@ -5,7 +5,7 @@ import (
 	"log"
 	"time"

-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/utils"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
@ -37,10 +37,10 @@ func (s *service) Register(cli *clientv3.Client, serviceName string, port string
 		return err
 	}

-	print.Info("[BSM Register] Service Key: %s", key)
-	print.Info("[BSM Register] Service Val: %s", serviceAddr)
+	printer.Info("[BSM Register] Service Key: %s", key)
+	printer.Info("[BSM Register] Service Val: %s", serviceAddr)

-	print.Success("[BSM Register] Service Register Complete.")
+	printer.Success("[BSM Register] Service Register Complete.")

 	go func() {
 		for keepAliveResp := range keepAliveChan {
--- a/licence/licence.go
+++ b/licence/licence.go
@ -58,8 +58,8 @@ var (

 // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 const (
-	signKey     = "8E853B589944FF7A56BEF02AAA51D6F4"
-	LICENCE_KEY = "TRAIN_LICENCE_KEY"
+	signKey     = "1F36659EC27CFFF849E068EA80B1A4CA"
+	LICENCE_KEY = "BLOCKS_KEY"
 )

 // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@ -69,13 +69,13 @@ func init() {
 }

 func WatchCheckLicence(licPath, licName string) {
-	for {
+	utils.SetInterval(func() {
 		if CheckLicence(licPath, licName) == false {
 			log.Println("授权文件失效，请重新部署授权文件:", licPath)
 			os.Exit(99)
 		}
-		time.Sleep(time.Hour * 1)
-	}
+
+	}, time.Hour*1)
 }

 // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--- a/logger/logger.go
+++ b/logger/logger.go
@ -0,0 +1,422 @@
+package logger
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"git.apinb.com/bsm-sdk/core/conf"
+	"git.apinb.com/bsm-sdk/core/utils"
+	"git.apinb.com/bsm-sdk/core/vars"
+)
+
+// Logger 日志器结构
+type Logger struct {
+	level       vars.LogLevel
+	infoLogger  *log.Logger
+	warnLogger  *log.Logger
+	errorLogger *log.Logger
+	fatalLogger *log.Logger
+	debugLogger *log.Logger
+
+	fileWriter    io.Writer
+	consoleWriter io.Writer
+
+	mu          sync.RWMutex
+	name        string
+	logDir      string
+	currentDate string
+	onRemote    bool
+	endpoint    string
+}
+
+var (
+	globalLogger *Logger
+	once         sync.Once
+)
+
+// 初始化Logger配置
+func New(cfg *conf.LogConf) {
+	if cfg == nil {
+		cfg = &conf.LogConf{
+			Name:     strings.ToLower(vars.ServiceKey),
+			Level:    vars.LogLevel(vars.DEBUG),
+			Dir:      "./logs/",
+			Endpoint: "",
+			Console:  true,
+			File:     true,
+			Remote:   false,
+		}
+	}
+
+	InitLogger(cfg)
+}
+
+// InitLogger 初始化全局日志器
+func InitLogger(cfg *conf.LogConf) error {
+	var err error
+	once.Do(func() {
+		globalLogger, err = NewLogger(cfg)
+	})
+	return err
+}
+
+// NewLogger 创建新的日志器
+func NewLogger(cfg *conf.LogConf) (*Logger, error) {
+	// 确保日志目录存在
+	if err := os.MkdirAll(cfg.Dir, 0755); err != nil {
+		return nil, fmt.Errorf("创建日志目录失败: %v", err)
+	}
+
+	// 控制台输出
+	consoleWriter := os.Stdout
+
+	// 文件输出
+	fileWriter, err := createLogFile(cfg.Dir, cfg.Name)
+	if err != nil {
+		return nil, fmt.Errorf("创建日志文件失败: %v", err)
+	}
+
+	// 创建多输出写入器
+	multiWriter := io.MultiWriter(consoleWriter, fileWriter)
+
+	logger := &Logger{
+		level:         cfg.Level,
+		fileWriter:    fileWriter,
+		consoleWriter: consoleWriter,
+		logDir:        cfg.Dir,
+		name:          strings.ToLower(cfg.Name),
+		currentDate:   time.Now().Format("2006-01-02"),
+		onRemote:      cfg.Remote,
+		endpoint:      cfg.Endpoint,
+	}
+
+	// 创建不同级别的日志器
+	logger.infoLogger = log.New(multiWriter, "[INFO] ", log.LstdFlags)
+	logger.warnLogger = log.New(multiWriter, "[WARN] ", log.LstdFlags)
+	logger.errorLogger = log.New(multiWriter, "[ERROR] ", log.LstdFlags)
+	logger.fatalLogger = log.New(multiWriter, "[FATAL] ", log.LstdFlags)
+	logger.debugLogger = log.New(multiWriter, "[DEBUG] ", log.LstdFlags)
+
+	return logger, nil
+}
+
+// createLogFile 创建日志文件
+func createLogFile(logDir, name string) (io.Writer, error) {
+	filename := fmt.Sprintf("%s_%s.log", name, time.Now().Format("2006-01-02"))
+	filepath := filepath.Join(logDir, filename)
+
+	file, err := os.OpenFile(filepath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	if err != nil {
+		return nil, err
+	}
+
+	return file, nil
+}
+
+// checkAndRotateLog 检查并轮转日志文件
+func (l *Logger) checkAndRotateLog() error {
+	today := time.Now().Format("2006-01-02")
+	if l.currentDate != today {
+		l.mu.Lock()
+		defer l.mu.Unlock()
+
+		if l.currentDate != today {
+			// 关闭旧文件
+			if closer, ok := l.fileWriter.(io.Closer); ok {
+				closer.Close()
+			}
+
+			// 创建新文件
+			newFileWriter, err := createLogFile(l.logDir, l.name)
+			if err != nil {
+				return err
+			}
+
+			l.fileWriter = newFileWriter
+			l.currentDate = today
+
+			// 重新创建多输出写入器
+			multiWriter := io.MultiWriter(l.consoleWriter, l.fileWriter)
+
+			l.infoLogger = log.New(multiWriter, "[INFO] ", log.LstdFlags)
+			l.warnLogger = log.New(multiWriter, "[WARN] ", log.LstdFlags)
+			l.errorLogger = log.New(multiWriter, "[ERROR] ", log.LstdFlags)
+			l.fatalLogger = log.New(multiWriter, "[FATAL] ", log.LstdFlags)
+			l.debugLogger = log.New(multiWriter, "[DEBUG] ", log.LstdFlags)
+		}
+	}
+	return nil
+}
+
+func (l *Logger) sendToRemote(level, name, out string) {
+	if l.endpoint == "" {
+		return
+	}
+	data := map[string]interface{}{
+		"level": level,
+		"name":  name,
+		"out":   out,
+	}
+	jsonBytes, _ := json.Marshal(data)
+	utils.HttpPost(l.endpoint, nil, jsonBytes)
+}
+
+// Debug 输出调试信息
+func (l *Logger) Debug(v ...interface{}) {
+	if l.level <= vars.DEBUG {
+		l.checkAndRotateLog()
+		out := fmt.Sprint(v...)
+		if l.onRemote {
+			go l.sendToRemote("DEBUG", l.name, out)
+		}
+		l.debugLogger.Output(2, out)
+	}
+}
+
+// Debugf 格式化输出调试信息
+func (l *Logger) Debugf(format string, v ...interface{}) {
+	if l.level <= vars.DEBUG {
+		l.checkAndRotateLog()
+		out := fmt.Sprintf(format, v...)
+		if l.onRemote {
+			go l.sendToRemote("DEBUG", l.name, out)
+		}
+		l.debugLogger.Output(2, out)
+	}
+}
+
+// Info 输出信息
+func (l *Logger) Info(v ...interface{}) {
+	if l.level <= vars.INFO {
+		l.checkAndRotateLog()
+		out := fmt.Sprint(v...)
+		if l.onRemote {
+			go l.sendToRemote("INFO", l.name, out)
+		}
+		l.infoLogger.Output(2, out)
+	}
+}
+
+// Infof 格式化输出信息
+func (l *Logger) Infof(format string, v ...interface{}) {
+	if l.level <= vars.INFO {
+		l.checkAndRotateLog()
+		out := fmt.Sprintf(format, v...)
+		if l.onRemote {
+			go l.sendToRemote("INFO", l.name, out)
+		}
+		l.infoLogger.Output(2, out)
+	}
+}
+
+// Warn 输出警告
+func (l *Logger) Warn(v ...interface{}) {
+	if l.level <= vars.WARN {
+		l.checkAndRotateLog()
+		out := fmt.Sprint(v...)
+		if l.onRemote {
+			go l.sendToRemote("WARN", l.name, out)
+		}
+		l.warnLogger.Output(2, out)
+	}
+}
+
+// Warnf 格式化输出警告
+func (l *Logger) Warnf(format string, v ...interface{}) {
+	if l.level <= vars.WARN {
+		l.checkAndRotateLog()
+		out := fmt.Sprintf(format, v...)
+		if l.onRemote {
+			go l.sendToRemote("WARN", l.name, out)
+		}
+		l.warnLogger.Output(2, out)
+	}
+}
+
+// Error 输出错误
+func (l *Logger) Error(v ...interface{}) {
+	if l.level <= vars.ERROR {
+		l.checkAndRotateLog()
+		out := fmt.Sprint(v...)
+		if l.onRemote {
+			go l.sendToRemote("ERROR", l.name, out)
+		}
+		l.errorLogger.Output(2, out)
+	}
+}
+
+// Errorf 格式化输出错误
+func (l *Logger) Errorf(format string, v ...interface{}) {
+	if l.level <= vars.ERROR {
+		l.checkAndRotateLog()
+		out := fmt.Sprintf(format, v...)
+		if l.onRemote {
+			go l.sendToRemote("ERROR", l.name, out)
+		}
+		l.errorLogger.Output(2, out)
+	}
+}
+
+// Fatal 输出致命错误并退出程序
+func (l *Logger) Fatal(v ...interface{}) {
+	l.checkAndRotateLog()
+	out := fmt.Sprint(v...)
+	if l.onRemote {
+		go l.sendToRemote("FATAL", l.name, out)
+	}
+	l.fatalLogger.Output(2, out)
+	os.Exit(1)
+}
+
+// Fatalf 格式化输出致命错误并退出程序
+func (l *Logger) Fatalf(format string, v ...interface{}) {
+	l.checkAndRotateLog()
+	out := fmt.Sprintf(format, v...)
+	if l.onRemote {
+		go l.sendToRemote("FATAL", l.name, out)
+	}
+	l.fatalLogger.Output(2, out)
+	os.Exit(1)
+}
+
+// Print 输出信息（兼容标准log包）
+func (l *Logger) Print(v ...interface{}) {
+	l.Info(v...)
+}
+
+// Printf 格式化输出信息（兼容标准log包）
+func (l *Logger) Printf(format string, v ...interface{}) {
+	l.Infof(format, v...)
+}
+
+// Println 输出信息并换行（兼容标准log包）
+func (l *Logger) Println(v ...interface{}) {
+	l.Info(v...)
+}
+
+// SetLevel 设置日志级别
+func (l *Logger) SetLevel(level vars.LogLevel) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.level = level
+}
+
+// GetLevel 获取日志级别
+func (l *Logger) GetLevel() vars.LogLevel {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	return l.level
+}
+
+// Close 关闭日志器
+func (l *Logger) Close() error {
+	if closer, ok := l.fileWriter.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+// 全局日志函数（兼容标准log包）
+
+// Debug 全局调试日志
+func Debug(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Debug(v...)
+	}
+}
+
+// Debugf 全局调试日志
+func Debugf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Debugf(format, v...)
+	}
+}
+
+// Info 全局信息日志
+func Info(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Info(v...)
+	}
+}
+
+// Infof 全局信息日志
+func Infof(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Infof(format, v...)
+	}
+}
+
+// Warn 全局警告日志
+func Warn(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Warn(v...)
+	}
+}
+
+// Warnf 全局警告日志
+func Warnf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Warnf(format, v...)
+	}
+}
+
+// Error 全局错误日志
+func Error(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Error(v...)
+	}
+}
+
+// Errorf 全局错误日志
+func Errorf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Errorf(format, v...)
+	}
+}
+
+// Fatal 全局致命错误日志
+func Fatal(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Fatal(v...)
+	}
+}
+
+// Fatalf 全局致命错误日志
+func Fatalf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Fatalf(format, v...)
+	}
+}
+
+// Print 全局打印日志（兼容标准log包）
+func Print(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Print(v...)
+	}
+}
+
+// Printf 全局打印日志（兼容标准log包）
+func Printf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Printf(format, v...)
+	}
+}
+
+// Println 全局打印日志（兼容标准log包）
+func Println(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Println(v...)
+	}
+}
+
+// GetLogger 获取全局日志器实例
+func GetLogger() *Logger {
+	return globalLogger
+}
--- a/middleware/cors.go
+++ b/middleware/cors.go
@ -0,0 +1,18 @@
+package middleware
+
+import (
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+)
+
+func Cors() gin.HandlerFunc {
+	return cors.New(cors.Config{
+		AllowAllOrigins: true,
+		AllowHeaders: []string{
+			"Origin", "Content-Length", "Content-Type", "Workspace", "Request-Id", "Authorization", "Token",
+		},
+		AllowMethods: []string{
+			"GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS",
+		},
+	})
+}
--- a/middleware/jwt.go
+++ b/middleware/jwt.go
@ -1,43 +1,56 @@
+// Package middleware 提供HTTP中间件功能
+// 包括JWT认证、CORS、运行模式等中间件
 package middleware

 import (
 	"encoding/json"
-	"fmt"
 	"log"
 	"net/http"

-	"git.apinb.com/bsm-sdk/core/cache/redis"
-	"git.apinb.com/bsm-sdk/core/crypto/encipher"
+	"git.apinb.com/bsm-sdk/core/crypto/token"
+	"git.apinb.com/bsm-sdk/core/env"
 	"git.apinb.com/bsm-sdk/core/errcode"
 	"git.apinb.com/bsm-sdk/core/types"
 	"github.com/gin-gonic/gin"
 )

-func JwtAuth(redis *redis.RedisClient) gin.HandlerFunc {
+// JwtAuth JWT认证中间件
+// time_verify: 是否验证token过期时间
+// 返回: Gin中间件函数
+func JwtAuth(time_verify bool) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		// 从请求头中获取 Authorization
 		authHeader := c.GetHeader("Authorization")
 		if authHeader == "" {
-			log.Println("获取token异常:", "Authorization header is required")
+			log.Printf("获取token异常:%v\n", "Authorization header is required")
 			c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header is required"})
 			c.Abort()
 			return
 		}
-		// 提取Token
-		claims, err := encipher.ParseTokenAes(authHeader)
-		if err != nil || claims == nil {
-			log.Println("提取token异常:", "Token is required")
-			c.JSON(http.StatusUnauthorized, gin.H{"error": "Token is required"})
-			c.Abort()
-			return
+
+		// 检测是否需要验证token时间
+		if time_verify {
+			// 判断时间claims.ExpiresAt
+			isExpire, err := token.New(env.Runtime.JwtSecretKey).IsExpired(authHeader)
+			if err != nil {
+				log.Println("token解析异常:", err)
+				c.JSON(http.StatusUnauthorized, gin.H{"error": "Token is required"})
+				c.Abort()
+				return
+			}
+			if isExpire {
+				log.Println("token过期，请重新获取:", "Token has expired")
+				c.JSON(http.StatusUnauthorized, gin.H{"error": "Token has expired"})
+				c.Abort()
+				return
+			}
 		}

-		// 从redis 获取token,判断当前redis 是否为空
-		tokenKey := fmt.Sprintf("%d-%s-%s", claims.ID, claims.Role, "token")
-		redisToken := redis.Client.Get(redis.Ctx, tokenKey)
-		if redisToken.Val() == "" {
-			log.Println("redis异常", "Token status unauthorized")
-			c.JSON(http.StatusUnauthorized, gin.H{"error": "Token status unauthorized"})
+		// 提取Token
+		claims, err := token.New(env.Runtime.JwtSecretKey).ParseJwt(authHeader)
+		if err != nil || claims == nil {
+			log.Printf("提取token异常:%v\n", err)
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Token is required"})
 			c.Abort()
 			return
 		}
@ -49,12 +62,14 @@ func JwtAuth(redis *redis.RedisClient) gin.HandlerFunc {
 	}
 }

-// 获取上下文用户登录信息
+// ParseAuth 获取上下文用户登录信息
+// c: Gin上下文
+// 返回: JWT声明信息
 func ParseAuth(c *gin.Context) (*types.JwtClaims, error) {
 	claims, ok := c.Get("Auth")
 	if !ok {
-		log.Printf("获取登录信息异常: %v", errcode.ErrJWTAuthNotFound)
-		return nil, errcode.ErrJWTAuthNotFound
+		log.Printf("获取登录信息异常: %v", errcode.ErrTokenAuthNotFound)
+		return nil, errcode.ErrTokenAuthNotFound
 	}

 	json_claims, err := json.Marshal(claims)
--- a/middleware/mode.go
+++ b/middleware/mode.go
@ -0,0 +1,16 @@
+package middleware
+
+import (
+	"git.apinb.com/bsm-sdk/core/env"
+	"git.apinb.com/bsm-sdk/core/vars"
+	"github.com/gin-gonic/gin"
+)
+
+func Mode(app *gin.Engine) {
+	// 设置gin模式
+	if env.Runtime.Mode == vars.RUN_MODE_PROD {
+		gin.SetMode(gin.ReleaseMode)
+	} else {
+		gin.SetMode(gin.DebugMode)
+	}
+}
--- a/oplog/new.go
+++ b/oplog/new.go
@ -1,14 +0,0 @@
-package oplog
-
-import (
-	"encoding/json"
-
-	"git.apinb.com/bsm-sdk/core/utils"
-)
-
-func New(endpoint string, data []*LogItem) {
-	jsonBytes, _ := json.Marshal(data)
-
-	go utils.HttpPost(endpoint, nil, jsonBytes)
-
-}
--- a/oplog/types.go
+++ b/oplog/types.go
@ -1,18 +0,0 @@
-package oplog
-
-type LogItem struct {
-	OpID   uint   `json:"op_id"`
-	OpName string `json:"op_name"`
-	OpType string `json:"op_type"`
-	Text   string `json:"text"`
-}
-
-var (
-	Type_Login    string = "login"
-	Type_Logout   string = "logout"
-	Type_Register string = "register"
-	Type_Update   string = "update"
-	Type_Delete   string = "delete"
-	Type_Query    string = "query"
-	Type_Other    string = "other"
-)
--- a/printer/print.go
+++ b/printer/print.go
@ -1,6 +1,8 @@
-package print
+package printer

 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"log"
 	"os"
@ -36,3 +38,11 @@ func Error(format string, a ...interface{}) {
 	message := fmt.Sprintf("\033[31m[Error] "+format+"\033[0m\n", a...)
 	logger.Print(message)
 }
+
+func Json(v any) {
+	jsonBy, _ := json.Marshal(v)
+	var out bytes.Buffer
+	json.Indent(&out, jsonBy, "", "\t")
+	out.WriteTo(os.Stdout)
+	fmt.Printf("\n")
+}
--- a/service/address.go
+++ b/service/address.go
@ -0,0 +1,204 @@
+package service
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+	"strings"
+
+	"git.apinb.com/bsm-sdk/core/utils"
+)
+
+type NetworkAddress struct {
+	Protocol string // tcp, tcp4, tcp6, unix, unixpacket
+	Host     string // IP 地址或主机名
+	Port     string // 端口号
+	Path     string // Unix socket 路径
+	Raw      string // 原始字符串
+}
+
+// 解析网络地址字符串
+// "tcp://0.0.0.0:1212",
+//
+//	"tcp4://127.0.0.1:8080",
+//	"tcp6://[::1]:8080",
+//	"unix:///data/app/passport.sock",
+//	"unixpacket:///tmp/mysql.sock",
+//	":8080",                    // 传统格式
+//	"/tmp/server.sock",         // 传统Unix格式
+//	"invalid://address",        // 错误格式
+func ParseNetworkAddress(addr string) (*NetworkAddress, error) {
+	// 如果包含 ://，按 URL 解析
+	if strings.Contains(addr, "://") {
+		return parseURLStyle(addr)
+	}
+
+	// 否则按传统格式解析
+	return parseTraditionalStyle(addr)
+}
+
+// 解析 tcp://0.0.0.0:1212 或 unix:///path/to/socket 格式
+func parseURLStyle(addr string) (*NetworkAddress, error) {
+	u, err := url.Parse(addr)
+	if err != nil {
+		return nil, fmt.Errorf("解析URL失败: %w", err)
+	}
+
+	result := &NetworkAddress{
+		Protocol: u.Scheme,
+		Raw:      addr,
+	}
+
+	switch u.Scheme {
+	case "tcp", "tcp4", "tcp6":
+		return parseTCPURL(u, result)
+	case "unix", "unixpacket":
+		return parseUnixURL(u, result)
+	default:
+		return nil, fmt.Errorf("不支持的协议: %s", u.Scheme)
+	}
+}
+
+// 解析 TCP 类型的 URL
+func parseTCPURL(u *url.URL, result *NetworkAddress) (*NetworkAddress, error) {
+	host, port, err := net.SplitHostPort(u.Host)
+	if err != nil {
+		// 如果没有端口，尝试添加默认端口
+		if strings.Contains(err.Error(), "missing port") {
+			host = u.Host
+			port = "0" // 默认端口
+		} else {
+			return nil, fmt.Errorf("解析TCP地址失败: %w", err)
+		}
+	}
+
+	result.Host = host
+	result.Port = port
+
+	// 根据主机地址确定具体的协议类型
+	if result.Protocol == "tcp" {
+		result.Protocol = determineTCPProtocol(host)
+	}
+
+	return result, nil
+}
+
+// 解析 Unix socket 类型的 URL
+func parseUnixURL(u *url.URL, result *NetworkAddress) (*NetworkAddress, error) {
+	// Unix socket 路径在 URL 的 Path 字段
+	if u.Path == "" {
+		return nil, fmt.Errorf("Unix socket 路径不能为空")
+	}
+
+	result.Path = u.Path
+
+	// 如果协议是 unix，但路径表明需要数据包传输，可以自动升级
+	if result.Protocol == "unix" && strings.Contains(u.Path, "packet") {
+		result.Protocol = "unixpacket"
+	}
+
+	return result, nil
+}
+
+// 根据主机地址确定 TCP 协议类型
+func determineTCPProtocol(host string) string {
+	if host == "" {
+		return "tcp" // 默认
+	}
+
+	// 解析 IP 地址
+	ip := net.ParseIP(host)
+	if ip != nil {
+		if ip.To4() != nil {
+			return "tcp4"
+		}
+		return "tcp6"
+	}
+
+	// 如果是特殊地址
+	switch host {
+	case "0.0.0.0", "127.0.0.1", "localhost":
+		return "tcp4"
+	case "::", "::1":
+		return "tcp6"
+	default:
+		return "tcp" // 默认支持双栈
+	}
+}
+
+// 解析传统格式如 ":8080", "127.0.0.1:8080", "/tmp/socket"
+func parseTraditionalStyle(addr string) (*NetworkAddress, error) {
+	// 检查是否是 Unix socket（包含路径分隔符）
+	if strings.Contains(addr, "/") || strings.HasPrefix(addr, "@/") {
+		return &NetworkAddress{Protocol: "unix", Path: addr}, nil
+	}
+
+	// 否则按 TCP 地址解析
+	host, port, err := net.SplitHostPort(addr)
+	if err == nil {
+		return &NetworkAddress{Protocol: "tcp", Host: host, Port: port}, nil
+	}
+
+	// 检查是否是端口号
+	if ok := utils.IsNumber(addr); ok {
+		return &NetworkAddress{Protocol: "tcp", Host: "0.0.0.0", Port: addr}, nil
+	}
+
+	return nil, fmt.Errorf("解析地址失败: %w", err)
+
+}
+
+// 获取网络类型用于 net.Dial 或 net.Listen
+func (na *NetworkAddress) Network() string {
+	return na.Protocol
+}
+
+// 获取地址字符串用于 net.Dial 或 net.Listen
+func (na *NetworkAddress) Address() string {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		if na.Port == "" {
+			return na.Host
+		}
+		return net.JoinHostPort(na.Host, na.Port)
+	case "unix", "unixpacket":
+		return na.Path
+	default:
+		return na.Raw
+	}
+}
+
+// 格式化输出
+func (na *NetworkAddress) String() string {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		return fmt.Sprintf("%s://%s", na.Protocol, net.JoinHostPort(na.Host, na.Port))
+	case "unix", "unixpacket":
+		return fmt.Sprintf("%s://%s", na.Protocol, na.Path)
+	default:
+		return na.Raw
+	}
+}
+
+// 验证地址是否有效
+func (na *NetworkAddress) Validate() error {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		if na.Host == "" && na.Port == "" {
+			return fmt.Errorf("TCP地址需要主机和端口")
+		}
+		// 验证端口
+		if na.Port != "" {
+			if _, err := net.LookupPort("tcp", na.Port); err != nil {
+				return fmt.Errorf("无效的端口: %s", na.Port)
+			}
+		}
+	case "unix", "unixpacket":
+		if na.Path == "" {
+			return fmt.Errorf("Unix socket路径不能为空")
+		}
+	default:
+		return fmt.Errorf("不支持的协议: %s", na.Protocol)
+	}
+	return nil
+}
--- a/service/cmd.go
+++ b/service/cmd.go
@ -1,4 +1,4 @@
-package cmd
+package service

 import (
 	"fmt"
--- a/service/meta.go
+++ b/service/meta.go
@ -3,9 +3,9 @@ package service
 import (
 	"context"

-	"git.apinb.com/bsm-sdk/core/crypto/encipher"
+	"git.apinb.com/bsm-sdk/core/crypto/token"
+	"git.apinb.com/bsm-sdk/core/env"
 	"git.apinb.com/bsm-sdk/core/errcode"
-	"git.apinb.com/bsm-sdk/core/types"
 	"git.apinb.com/bsm-sdk/core/utils"
 	"google.golang.org/grpc/metadata"
 )
@ -16,19 +16,19 @@ type ParseOptions struct {
 	MustPrivateAllow bool   // 是否只允许私有IP访问
 }

-func ParseMetaCtx(ctx context.Context, opts *ParseOptions) (*types.JwtClaims, error) {
+func ParseMetaCtx(ctx context.Context, opts *ParseOptions) (*token.Claims, error) {
 	// 解析metada中的信息并验证
 	md, ok := metadata.FromIncomingContext(ctx)
 	if !ok {
-		return nil, errcode.ErrJWTAuthNotFound
+		return nil, errcode.ErrTokenAuthNotFound
 	}

 	var Authorizations []string = md.Get("authorization")
 	if len(Authorizations) == 0 || Authorizations[0] == "" {
-		return nil, errcode.ErrJWTAuthNotFound
+		return nil, errcode.ErrTokenAuthNotFound
 	}

-	claims, err := encipher.ParseTokenAes(Authorizations[0])
+	claims, err := token.New(env.Runtime.JwtSecretKey).ParseJwt(Authorizations[0])
 	if err != nil {
 		return nil, err
 	}
@ -48,7 +48,7 @@ func ParseMetaCtx(ctx context.Context, opts *ParseOptions) (*types.JwtClaims, er

 }

-func checkRole(claims *types.JwtClaims, roleKey, roleValue string) bool {
+func checkRole(claims *token.Claims, roleKey, roleValue string) bool {
 	if roleValue == "" {
 		return true
 	}
--- a/service/register.go
+++ b/service/register.go
@ -5,7 +5,7 @@ import (
 	"strings"
 	"time"

-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/vars"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
@ -94,7 +94,11 @@ func (s *ServiceRegister) Close() error {

 func (s *ServiceRegister) SetAnonymous(key string, urls []string) {
 	// remove reppeat, clear service all anonymous uri.
-	anonymous, _ := s.cli.Get(context.Background(), key)
+	anonymous, err := s.cli.Get(context.Background(), key)
+	if err != nil {
+		printer.Error("[BSM Register] Get Anonymous Fail: %v", err)
+		return
+	}

 	var as []string
 	if len(anonymous.Kvs) > 0 {
@ -106,12 +110,12 @@ func (s *ServiceRegister) SetAnonymous(key string, urls []string) {
 	newAnonymous := strings.Join(as, ",")

 	// put anonymous to etcd
-	_, err := s.cli.Put(context.Background(), key, newAnonymous)
+	_, err = s.cli.Put(context.Background(), key, newAnonymous)

 	if err != nil {
-		print.Error("[BSM Register] Anonymous Fail.")
+		printer.Error("[BSM Register] Anonymous Fail.")
 	} else {
-		print.Info("[BSM Register] Anonymous: %s", newAnonymous)
+		printer.Info("[BSM Register] Anonymous: %s", newAnonymous)
 	}

 }
--- a/service/service.go
+++ b/service/service.go
@ -1,3 +1,5 @@
+// Package service 提供微服务管理功能
+// 包括服务启动、注册、网关代理等核心功能
 package service

 import (
@ -14,56 +16,66 @@ import (

 	"git.apinb.com/bsm-sdk/core/conf"
 	"git.apinb.com/bsm-sdk/core/env"
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/vars"
 	clientv3 "go.etcd.io/etcd/client/v3"
 	"google.golang.org/grpc"
 )

 type (
-	// RegisterFn defines the method to register a server.
+	// RegisterFn 定义服务注册函数类型
 	RegisterFn func(*grpc.Server)

+	// Service 微服务实例
 	Service struct {
-		GrpcSrv *grpc.Server
-		Opts    *Options
+		GrpcSrv *grpc.Server // gRPC服务器实例
+		Opts    *Options     // 服务配置选项
 	}

+	// Options 服务配置选项
 	Options struct {
-		Addr        string
-		EtcdClient  *clientv3.Client
-		MsConf      *conf.MicroServiceConf
-		GatewayConf *conf.GatewayConf
-		GatewayCtx  context.Context
-		GatewayMux  *gwRuntime.ServeMux
+		Addr        string                 // 服务监听地址
+		EtcdClient  *clientv3.Client       // Etcd客户端
+		MsConf      *conf.MicroServiceConf // 微服务配置
+		GatewayConf *conf.GatewayConf      // 网关配置
+		GatewayCtx  context.Context        // 网关上下文
+		GatewayMux  *gwRuntime.ServeMux    // 网关多路复用器
 	}
 )

+// New 创建新的服务实例
+// srv: gRPC服务器实例
+// opts: 服务配置选项
 func New(srv *grpc.Server, opts *Options) *Service {
 	return &Service{GrpcSrv: srv, Opts: opts}
 }

+// Addr 将IP和端口格式化为host:port格式
+// ip: IP地址
+// port: 端口号
 func Addr(ip string, port int) string {
 	return net.JoinHostPort(ip, strconv.Itoa(port))
 }

+// Start 启动服务
+// 包括etcd注册、gRPC服务启动、HTTP网关启动
 func (s *Service) Start() {
-	print.Info("[BSM - %s] Service Starting ...", vars.ServiceKey)
+	printer.Info("[BSM - %s] Service Starting ...", vars.ServiceKey)

-	// register to etcd.
+	// 注册到etcd
 	if s.Opts.MsConf != nil && s.Opts.MsConf.Enable {
 		if s.Opts.EtcdClient == nil {
-			print.Error("[BSM Register] Etcd Client is nil.")
+			printer.Error("[BSM Register] Etcd Client is nil.")
 			os.Exit(1)
 		}
-		print.Info("[BSM - %s] Registering Service to Etcd ...", vars.ServiceKey)
-		// get methods
+		printer.Info("[BSM - %s] Registering Service to Etcd ...", vars.ServiceKey)
+		// 获取gRPC方法用于网关/路由发现
 		methods := FoundGrpcMethods(s.GrpcSrv)

-		// set router key
+		// 设置路由键
 		routerKey := vars.ServiceRootPrefix + "Router/" + env.Runtime.Workspace + "/" + strings.ToLower(vars.ServiceKey) + "/" + s.Opts.Addr

-		// register to etcd
+		// 使用租约注册到etcd
 		register, err := RegisterService(s.Opts.EtcdClient, routerKey, methods, vars.ServiceLease)
 		if err != nil {
 			log.Panicf("[ERROR] %s Service Register:%s \n", vars.ServiceKey, err.Error())
@ -73,11 +85,11 @@ func (s *Service) Start() {

 		register.SetAnonymous(anonKey, s.Opts.MsConf.Anonymous)

-		// service register lease
+		// 服务注册租约监听
 		go register.ListenLeaseRespChan()
 	}

-	// run grpc srv.
+	// 启动gRPC服务
 	tcpListen, err := net.Listen("tcp", s.Opts.Addr)
 	if err != nil {
 		panic(err)
@ -88,31 +100,52 @@ func (s *Service) Start() {
 			panic(err)
 		}
 	}()
-	print.Success("[BSM - %s] Grpc %s Runing Success !", vars.ServiceKey, s.Opts.Addr)
+	printer.Success("[BSM - %s] Grpc %s Runing Success !", vars.ServiceKey, s.Opts.Addr)

+	// 启动HTTP网关
 	if s.Opts.GatewayConf != nil && s.Opts.GatewayConf.Enable {
 		addr := Addr("0.0.0.0", s.Opts.GatewayConf.Port)
 		go s.Gateway(s.Opts.Addr, addr)

-		print.Success("[BSM - %s] Http %s Runing Success!", vars.ServiceKey, addr)
+		printer.Success("[BSM - %s] Http %s Runing Success!", vars.ServiceKey, addr)
 	}

+	// 阻塞主线程
 	select {}
 }

+// Gateway 启动HTTP网关服务
+// grpcAddr: gRPC服务地址
+// httpAddr: HTTP服务地址
 func (s *Service) Gateway(grpcAddr string, httpAddr string) {
-	// 1. 定义一个context
+	// 定义上下文
 	_, cancel := context.WithCancel(s.Opts.GatewayCtx)
 	defer cancel()

-	http.ListenAndServe(httpAddr, s.Opts.GatewayMux)
+	// 启动HTTP服务，不因HTTP启动失败而导致panic
+	if err := http.ListenAndServe(httpAddr, s.Opts.GatewayMux); err != nil {
+		printer.Error("[BSM - %s] Http Serve Error: %v", vars.ServiceKey, err)
+	}
 }

+// Use 执行初始化函数
+// initFunc: 初始化函数
+func (s *Service) Use(initFunc func() error) {
+	err := (initFunc)()
+	if err != nil {
+		printer.Error(err.Error())
+		panic(err)
+	}
+}
+
+// Stop 优雅停止服务
 func (s *Service) Stop() {
 	s.GrpcSrv.GracefulStop()
 }

-// found grpc methods.
+// FoundGrpcMethods 发现gRPC服务中的所有方法
+// s: gRPC服务器实例
+// 返回: 方法名列表
 func FoundGrpcMethods(s *grpc.Server) []string {
 	var mothods []string
 	for key, srv := range s.GetServiceInfo() {
--- a/types/db.go
+++ b/types/db.go
@ -10,62 +10,68 @@ type (

 	// sql options
 	SqlOptions struct {
-		MaxIdleConns    int
-		MaxOpenConns    int
+		MaxIdleConns    int `gorm:"column:max_idle_conns;"  json:"max_idle_conns"`
+		MaxOpenConns    int `gorm:"column:max_open_conns;"  json:"max_open_conns"`
 		ConnMaxLifetime time.Duration

-		LogStdout bool
-		Debug     bool
+		LogStdout bool `gorm:"column:log_stdout;"  json:"log_stdout"`
+		Debug     bool `gorm:"column:debug;"  json:"debug"`
 	}

 	// standard ID,Identity definition.
 	Std_IDIdentity struct {
-		ID       uint   `gorm:"primarykey;"  json:"id"`
+		ID       uint   `gorm:"column:id;primarykey;"  json:"id"`
 		Identity string `gorm:"column:identity;type:varchar(36);uniqueIndex;"  json:"identity"` // 唯一标识，24位NanoID,36位为ULID
 	}

 	// standard ID,Created,Updated,Deleted definition.
 	Std_IICUDS struct {
-		ID        uint           `gorm:"primarykey;"  json:"id"`
+		ID        uint           `gorm:"column:id;primarykey;"  json:"id"`
 		Identity  string         `gorm:"column:identity;type:varchar(36);uniqueIndex;"  json:"identity"` // 唯一标识，24位NanoID,36位为ULID
-		CreatedAt time.Time      `gorm:"" json:"created_at"`
-		UpdatedAt time.Time      `gorm:"" json:"updated_at"`
-		DeletedAt gorm.DeletedAt `gorm:"index;" json:"deleted_at"`
-		Status    int8           `gorm:"default:0;index;" json:"status"` // 状态：默认为0，-1禁止，1为正常
+		CreatedAt time.Time      `gorm:"column:created_at;type:TIMESTAMP;" json:"created_at"`
+		UpdatedAt time.Time      `gorm:"column:updated_at;type:TIMESTAMP;" json:"updated_at"`
+		DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:TIMESTAMP;index;" json:"deleted_at"`
+		Status    int8           `gorm:"column:status;default:0;index;" json:"status"` // 状态：默认为0，-1禁止，1为正常
 	}

 	// standard ID,Identity,Created,Updated,Deleted,Status definition.
 	Std_ICUD struct {
-		ID        uint           `gorm:"primarykey;"  json:"id"`
-		CreatedAt time.Time      `gorm:"" json:"created_at"`
-		UpdatedAt time.Time      `gorm:"" json:"updated_at"`
-		DeletedAt gorm.DeletedAt `gorm:"index;" json:"deleted_at"`
+		ID        uint           `gorm:"column:id;primarykey;"  json:"id"`
+		CreatedAt time.Time      `gorm:"column:created_at;" json:"created_at"`
+		UpdatedAt time.Time      `gorm:"column:updated_at;type:TIMESTAMP;" json:"updated_at"`
+		DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:TIMESTAMP;index;" json:"deleted_at"`
 	}

 	// standard ID,Created definition.
 	Std_IdCreated struct {
-		ID        uint      `gorm:"primarykey;"  json:"id"`
-		CreatedAt time.Time `gorm:"" json:"created_at"`
+		ID        uint      `gorm:"column:id;primarykey;"  json:"id"`
+		CreatedAt time.Time `gorm:"column:created_at;type:TIMESTAMP;" json:"created_at"`
 	}

 	// standard PassportID,PassportIdentity definition.
 	Std_Passport struct {
 		PassportID       uint   `gorm:"column:passport_id;Index;" json:"passport_id"`
-		PassportIdentity string `gorm:"column:passport_identity;type:varchar(36);Index;"  json:"passport_identity"` // 用户唯一标识，24位NanoID,36位为ULID
+		PassportIdentity string `gorm:"column:passport_identity;type:varchar(36);Index;"  json:"passport_identity"` // 用户唯一标识，24位NanoID,36位为UUID
+	}
+
+	// standard OwnerID,OwnerIdentity definition.
+	Std_Owner struct {
+		OwnerID       uint   `gorm:"column:owner_id;Index;" json:"owner_id"`
+		OwnerIdentity string `gorm:"column:owner_identity;type:varchar(36);Index;"  json:"owner_identity"` // 用户唯一标识，24位NanoID,36位为UUID
 	}

 	// standard ID definition.
 	Std_ID struct {
-		ID uint `gorm:"primarykey;"  json:"id"`
+		ID uint `gorm:"column:id;primarykey;"  json:"id"`
 	}

 	// standard Identity definition.
 	Std_Identity struct {
-		Identity string `gorm:"column:identity;type:varchar(36);uniqueIndex;"  json:"identity"` // 唯一标识，24位NanoID,36位为ULID
+		Identity string `gorm:"column:identity;type:varchar(36);uniqueIndex;"  json:"identity"` // 唯一标识，24位NanoID,36位为UUID
 	}

 	// standard Status definition.
 	Std_Status struct {
-		Status int64 `gorm:"default:0;index;" json:"status"` // 状态：默认为0，-1禁止，1为正常
+		Status int64 `gorm:"column:status;default:0;index;" json:"status"` // 状态：默认为0，-1禁止，1为正常
 	}
 )
--- a/types/types.go
+++ b/types/types.go
@ -1,28 +1,36 @@
+// Package types 提供通用数据类型定义
+// 包括分页、ID、身份标识等常用结构体
 package types

+// Empty 空结构体
 type Empty struct {
 }

+// Paginate 分页参数
 type Paginate struct {
-	Offset int `form:"offset,default=0,range=[0:)"`
-	Size   int `form:"size,default=10,range=[1:50]"`
+	Offset int `form:"offset,default=0,range=[0:)"`  // 偏移量
+	Size   int `form:"size,default=10,range=[1:50]"` // 每页大小
 }

+// ID ID结构体
 type ID struct {
-	ID uint `json:"id"`
+	ID uint `json:"id"` // ID字段
 }

+// Identity 身份标识结构体
 type Identity struct {
-	Identity string `json:"identity"`
+	Identity string `json:"identity"` // 身份标识
 }

+// Ident ID和身份标识组合结构体
 type Ident struct {
-	ID       uint   `json:"id"`
-	Identity string `json:"identity"`
+	ID       uint   `json:"id"`       // ID字段
+	Identity string `json:"identity"` // 身份标识
 }

+// FetchRequest 获取请求结构体
 type FetchRequest struct {
-	Params    map[string]string `json:"params,optional"`
-	TimeRange string            `json:"time_range,optional"`
-	Paginate
+	Params    map[string]string `json:"params,optional"`     // 查询参数
+	TimeRange string            `json:"time_range,optional"` // 时间范围
+	Paginate                    // 分页参数
 }
--- a/utils/convert.go
+++ b/utils/convert.go
@ -1,3 +1,5 @@
+// Package utils 提供通用工具函数
+// 包括数据类型转换、时间处理、网络工具等
 package utils

 import (
@ -6,61 +8,72 @@ import (
 	"strings"
 )

-// 字符串转Int
-//
-//	intStr：数字的字符串
+// String2Int 字符串转Int
+// intStr: 数字的字符串
+// 返回: 转换后的整数，转换失败返回0
 func String2Int(intStr string) (intNum int) {
-	intNum, _ = strconv.Atoi(intStr)
+	intNum, err := strconv.Atoi(intStr)
+	if err != nil {
+		return 0
+	}
 	return
 }

-// 字符串转Int64
-//
-//	intStr：数字的字符串
+// String2Int64 字符串转Int64
+// intStr: 数字的字符串
+// 返回: 转换后的64位整数，转换失败返回0
 func String2Int64(intStr string) (int64Num int64) {
-	intNum, _ := strconv.Atoi(intStr)
-	int64Num = int64(intNum)
-	return
+	intNum, err := strconv.ParseInt(intStr, 10, 64)
+	if err != nil {
+		return 0
+	}
+	return intNum
 }

-// 字符串转Float64
-//
-//	floatStr：小数点数字的字符串
+// String2Float64 字符串转Float64
+// floatStr: 小数点数字的字符串
+// 返回: 转换后的64位浮点数，转换失败返回0
 func String2Float64(floatStr string) (floatNum float64) {
-	floatNum, _ = strconv.ParseFloat(floatStr, 64)
+	floatNum, err := strconv.ParseFloat(floatStr, 64)
+	if err != nil {
+		return 0
+	}
 	return
 }

-// 字符串转Float32
-//
-//	floatStr：小数点数字的字符串
+// String2Float32 字符串转Float32
+// floatStr: 小数点数字的字符串
+// 返回: 转换后的32位浮点数，转换失败返回0
 func String2Float32(floatStr string) (floatNum float32) {
-	floatNum64, _ := strconv.ParseFloat(floatStr, 32)
+	floatNum64, err := strconv.ParseFloat(floatStr, 32)
+	if err != nil {
+		return 0
+	}
 	floatNum = float32(floatNum64)
 	return
 }

-// Int转字符串
-//
-//	intNum：数字字符串
+// Int2String Int转字符串
+// intNum: 整数
+// 返回: 转换后的字符串
 func Int2String(intNum int) (intStr string) {
 	intStr = strconv.Itoa(intNum)
 	return
 }

-// Int64转字符串
-//
-//	intNum：数字字符串
+// Int642String Int64转字符串
+// intNum: 64位整数
+// 返回: 转换后的字符串
 func Int642String(intNum int64) (int64Str string) {
-	//10, 代表10进制
+	// 10代表10进制
 	int64Str = strconv.FormatInt(intNum, 10)
 	return
 }

-// Float64转字符串
-//
-//	floatNum：float64数字
-//	prec：精度位数（不传则默认float数字精度）
+// Float64ToString Float64转字符串
+// floatNum: float64数字
+// prec: 精度位数（不传则默认float数字精度）
+// 返回: 转换后的字符串
 func Float64ToString(floatNum float64, prec ...int) (floatStr string) {
 	if len(prec) > 0 {
 		floatStr = strconv.FormatFloat(floatNum, 'f', prec[0], 64)
@ -70,10 +83,10 @@ func Float64ToString(floatNum float64, prec ...int) (floatStr string) {
 	return
 }

-// Float32转字符串
-//
-//	floatNum：float32数字
-//	prec：精度位数（不传则默认float数字精度）
+// Float32ToString Float32转字符串
+// floatNum: float32数字
+// prec: 精度位数（不传则默认float数字精度）
+// 返回: 转换后的字符串
 func Float32ToString(floatNum float32, prec ...int) (floatStr string) {
 	if len(prec) > 0 {
 		floatStr = strconv.FormatFloat(float64(floatNum), 'f', prec[0], 32)
@ -83,7 +96,9 @@ func Float32ToString(floatNum float32, prec ...int) (floatStr string) {
 	return
 }

-// 二进制转10进制
+// BinaryToDecimal 二进制转10进制
+// bit: 二进制字符串
+// 返回: 转换后的十进制数
 func BinaryToDecimal(bit string) (num int) {
 	fields := strings.Split(bit, "")
 	lens := len(fields)
@ -96,7 +111,9 @@ func BinaryToDecimal(bit string) (num int) {
 	return
 }

-// interface to string
+// AnyToString 任意类型转字符串
+// in: 输入值
+// 返回: 转换后的字符串
 func AnyToString(in any) (s string) {
 	if in == nil {
 		return ""
--- a/utils/dir.go
+++ b/utils/dir.go
@ -25,11 +25,17 @@ func CreateDir(dirName string) bool {
 }

 func GetRunPath() string {
-	path, _ := os.Executable()
+	path, err := os.Executable()
+	if err != nil {
+		return ""
+	}
 	return path
 }

 func GetCurrentPath() string {
-	path, _ := os.Getwd()
+	path, err := os.Getwd()
+	if err != nil {
+		return ""
+	}
 	return path
-}
+}
--- a/utils/ext.go
+++ b/utils/ext.go
@ -12,7 +12,7 @@ func If(condition bool, trueValue, falseValue interface{}) interface{} {
 	return falseValue
 }

-//如果首字母是小写字母, 则变换为大写字母
+// 如果首字母是小写字母, 则变换为大写字母
 func FirstToUpper(str string) string {
 	if str == "" {
 		return ""
--- a/utils/file.go
+++ b/utils/file.go
@ -2,11 +2,20 @@ package utils

 import (
 	"errors"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 )

+
+const (
+	B  = 1
+	KB = 1024 * B
+	MB = 1024 * KB
+	GB = 1024 * MB
+)
+
 // 将字符串写入文件
 func StringToFile(path, content string) error {
 	startF, err := os.Create(path)
@ -21,11 +30,58 @@ func StringToFile(path, content string) error {
 	return nil
 }

+// 文件复制
+func CopyFile(src, dst string) (int64, error) {
+	sourceFileStat, err := os.Stat(src)
+	if err != nil {
+		return 0, err
+	}
+	if !sourceFileStat.Mode().IsRegular() {
+		return 0, fmt.Errorf("%s is not a regular file", src)
+	}
+
+	source, err := os.Open(src)
+	if err != nil {
+		return 0, err
+	}
+	defer source.Close()
+
+	destination, err := os.Create(dst)
+	if err != nil {
+		return 0, err
+	}
+	defer destination.Close()
+
+	nBytes, err := io.Copy(destination, source)
+	return nBytes, err
+}
+
+
+func FileSize(fp string) string {
+	fileInfo, err := os.Stat(fp)
+	if err != nil {
+		return "0 B"
+	}
+	bytes := fileInfo.Size()
+
+	switch {
+	case bytes >= GB:
+		return fmt.Sprintf("%.2f GB", float64(bytes)/float64(GB))
+	case bytes >= MB:
+		return fmt.Sprintf("%.2f MB", float64(bytes)/float64(MB))
+	case bytes >= KB:
+		return fmt.Sprintf("%.2f KB", float64(bytes)/float64(KB))
+	default:
+		return fmt.Sprintf("%d B", bytes)
+	}
+}
+
+
 // 递归遍历文件夹
 // rootDir: 文件夹根目录
 // s: 存储文件名的切片
 // filter: 过滤条件：".git", ".idea", ".vscode", ".gitignore", ".gitea", ".github", ".golangci.yml", "*.pyc"
-func FileTree(rootDir string, s []string, filter []string) ([]string, error) {
+func FileTreeByFilter(rootDir string, s []string, filter []string) ([]string, error) {
 	rd, err := os.ReadDir(rootDir)
 	if err != nil {
 		return s, err
@ -50,7 +106,48 @@ func FileTree(rootDir string, s []string, filter []string) ([]string, error) {

 		if fi.IsDir() {
 			fullDir := rootDir + "/" + fi.Name()
-			s, err = FileTree(fullDir, s, filter)
+			s, err = FileTreeByFilter(fullDir, s, filter)
+			if err != nil {
+				return s, err
+			}
+		} else {
+			fullName := rootDir + "/" + fi.Name()
+			s = append(s, fullName)
+		}
+	}
+	return s, nil
+}
+
+// 递归遍历文件夹
+// rootDir: 文件夹根目录
+// s: 存储文件名的切片
+// allow: 允许条件：".zip", ".check"
+func FileTreeBySelect(rootDir string, s []string, allow []string) ([]string, error) {
+	rd, err := os.ReadDir(rootDir)
+	if err != nil {
+		return s, err
+	}
+	for _, fi := range rd {
+		// 检查文件名是否匹配任何一个过滤模式
+		matched := false
+		for _, item := range allow {
+			exists, err := filepath.Match(item, fi.Name())
+			if err != nil {
+				continue
+			}
+			if exists {
+				matched = true
+				break
+			}
+		}
+
+		if !matched {
+			continue
+		}
+
+		if fi.IsDir() {
+			fullDir := rootDir + "/" + fi.Name()
+			s, err = FileTreeBySelect(fullDir, s, allow)
 			if err != nil {
 				return s, err
 			}
--- a/utils/fmt.go
+++ b/utils/fmt.go
@ -0,0 +1,34 @@
+package utils
+
+import (
+	"strconv"
+	"strings"
+)
+
+func FloatRoundString(in float64, place int) string {
+
+	return Float64ToString(FloatRound(in, place))
+}
+
+func FloatRound(in float64, place int) float64 {
+	// 限制 place 范围在合理区间
+	if place < 0 {
+		place = 0
+	}
+
+	// 使用 strconv.FormatFloat 直接格式化，避免多次条件判断
+	str := strconv.FormatFloat(in, 'f', place, 64)
+	num, _ := strconv.ParseFloat(str, 64)
+	return num
+}
+
+func RateToFloat64(s string) float64 {
+	// 去掉百分号
+	s = strings.TrimSuffix(s, "%")
+	// 转换为 float64
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return 0
+	}
+	return f / 100
+}
--- a/utils/net.go
+++ b/utils/net.go
@ -1,8 +1,56 @@
+// Package utils 提供通用工具函数
+// 包括数据类型转换、时间处理、网络工具等
+//
+// 网络工具模块
+//
+// 本模块提供了完整的网络相关工具函数，包括：
+//
+// IP地址相关：
+// - IsPublicIP: 判断IP是否为公网IP（识别私有网段）
+// - GetLocationIP: 获取本机第一个有效IPv4地址
+// - LocalIPv4s: 获取本机所有IPv4地址列表
+// - GetOutBoundIP: 获取外网IP地址
+//
+// HTTP请求相关（带超时保护）：
+// - HttpGet: 发送HTTP GET请求
+// - HttpPost: 发送HTTP POST请求
+// - HttpPostJSON: 发送HTTP POST JSON请求
+// - HttpRequest: 执行自定义HTTP请求
+// - DownloadFile: 下载文件（支持进度回调）
+//
+// 性能特点：
+// - 所有HTTP请求都有超时保护（默认30秒）
+// - 支持自定义超时时间
+// - 使用Context进行超时控制
+// - 完善的错误处理
+// - 并发安全
+//
+// 使用示例：
+//
+//	// 获取本机IP
+//	localIP := utils.GetLocationIP()
+//
+//	// HTTP GET请求（默认30秒超时）
+//	body, _ := utils.HttpGet("https://api.example.com/data")
+//
+//	// 自定义超时
+//	body, _ := utils.HttpGet("https://api.example.com/data", 5*time.Second)
+//
+//	// POST JSON数据
+//	data := map[string]any{"key": "value"}
+//	body, _ := utils.HttpPostJSON(url, headers, data)
+//
+//	// 下载文件（带进度）
+//	progress := func(total, downloaded int64) {
+//	    fmt.Printf("进度: %.2f%%\n", float64(downloaded)/float64(total)*100)
+//	}
+//	err := utils.DownloadFile(url, "file.zip", progress)
 package utils

 import (
 	"bytes"
-	"errors"
+	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net"
@ -10,20 +58,39 @@ import (
 	"os"
 	"strconv"
 	"strings"
+	"time"
 )

+const (
+	// DefaultHTTPTimeout HTTP请求默认超时时间
+	DefaultHTTPTimeout = 30 * time.Second
+	// DefaultDownloadTimeout 文件下载默认超时时间
+	DefaultDownloadTimeout = 5 * time.Minute
+	// DefaultBufferSize 默认缓冲区大小
+	DefaultBufferSize = 32 * 1024
+)
+
+// IsPublicIP 判断是否为公网IP
+// ipString: IP地址字符串
+// 返回: 是否为公网IP
 func IsPublicIP(ipString string) bool {
 	ip := net.ParseIP(ipString)
+	if ip == nil {
+		return false
+	}
+
 	if ip.IsLoopback() || ip.IsLinkLocalMulticast() || ip.IsLinkLocalUnicast() {
 		return false
 	}
+
 	if ip4 := ip.To4(); ip4 != nil {
-		switch true {
-		case ip4[0] == 10:
+		// 检查私有IP地址段
+		switch {
+		case ip4[0] == 10: // 10.0.0.0/8
 			return false
-		case ip4[0] == 172 && ip4[1] >= 16 && ip4[1] <= 31:
+		case ip4[0] == 172 && ip4[1] >= 16 && ip4[1] <= 31: // 172.16.0.0/12
 			return false
-		case ip4[0] == 192 && ip4[1] == 168:
+		case ip4[0] == 192 && ip4[1] == 168: // 192.168.0.0/16
 			return false
 		default:
 			return true
@ -32,70 +99,77 @@ func IsPublicIP(ipString string) bool {
 	return false
 }

-// Get Location IP .
-func GetLocationIP() (localIp string) {
-	localIp = "127.0.0.1"
-	// Get all network interfaces
+// GetLocationIP 获取本机IP地址
+// 返回: 本机IP地址，如果找不到则返回 "127.0.0.1"
+func GetLocationIP() string {
+	localIP := "127.0.0.1"
+
+	// 获取所有网络接口
 	interfaces, err := net.Interfaces()
 	if err != nil {
-		return
+		return localIP
 	}

 	for _, iface := range interfaces {
-		// Skip the loopback interface
+		// 跳过回环接口
 		if iface.Flags&net.FlagLoopback != 0 {
 			continue
 		}

-		// Get addresses associated with the interface
+		// 获取接口关联的地址
 		addrs, err := iface.Addrs()
 		if err != nil {
 			continue
 		}

 		for _, addr := range addrs {
-			// Check if the address is an IPNet
+			// 检查地址是否为 IPNet 类型
 			ipnet, ok := addr.(*net.IPNet)
 			if !ok || ipnet.IP.IsLoopback() {
 				continue
 			}

-			// Get the IP address
+			// 获取 IPv4 地址
 			ip := ipnet.IP.To4()
 			if ip == nil {
 				continue
 			}

-			// Skip IP addresses in the 169.254.x.x range
-			if strings.HasPrefix(ip.String(), "169.254") {
+			ipStr := ip.String()
+			// 跳过链路本地地址 169.254.x.x 和虚拟网络地址 26.26.x.x
+			if strings.HasPrefix(ipStr, "169.254") || strings.HasPrefix(ipStr, "26.26") {
 				continue
 			}

-			// Skip IP addresses in the 169.254.x.x range
-			if strings.HasPrefix(ip.String(), "26.26") {
-				continue
-			}
-
-			// Return the first valid IP address found
-			return ip.String()
+			// 返回找到的第一个有效 IP 地址
+			return ipStr
 		}
 	}

-	return
+	return localIP
 }

+// LocalIPv4s 获取本机所有IPv4地址
+// 返回: IPv4地址列表和错误信息
 func LocalIPv4s() ([]string, error) {
-
 	var ips []string
-	addrs, _ := net.InterfaceAddrs()
+
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return nil, err
+	}

 	for _, addr := range addrs {
-		if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
-			if ipnet.IP.To4() != nil {
-				locIP := ipnet.IP.To4().String()
-				if locIP[0:7] != "169.254" {
-					ips = append(ips, locIP)
-				}
+		ipnet, ok := addr.(*net.IPNet)
+		if !ok || ipnet.IP.IsLoopback() {
+			continue
+		}
+
+		if ipv4 := ipnet.IP.To4(); ipv4 != nil {
+			ipStr := ipv4.String()
+			// 跳过链路本地地址
+			if !strings.HasPrefix(ipStr, "169.254") {
+				ips = append(ips, ipStr)
 			}
 		}
 	}
@ -103,41 +177,97 @@ func LocalIPv4s() ([]string, error) {
 	return ips, nil
 }

-func GetOutBoundIP() (ip string, err error) {
-	body, err := HttpGet("http://ip.dhcp.cn/?ip") // 获取外网 IP
-	return string(body), err
+// GetOutBoundIP 获取外网IP地址
+// 返回: 外网IP地址字符串和错误信息
+func GetOutBoundIP() (string, error) {
+	body, err := HttpGet("http://ip.dhcp.cn/?ip")
+	if err != nil {
+		return "", err
+	}
+	return string(body), nil
 }

-func HttpGet(url string) ([]byte, error) {
-	resp, err := http.Get(url)
+// getTimeoutDuration 获取超时时间，如果未指定则使用默认值
+func getTimeoutDuration(timeout []time.Duration, defaultTimeout time.Duration) time.Duration {
+	if len(timeout) > 0 {
+		return timeout[0]
+	}
+	return defaultTimeout
+}
+
+// createHTTPClient 创建带超时的HTTP客户端
+func createHTTPClient(timeout time.Duration) *http.Client {
+	return &http.Client{
+		Timeout: timeout,
+	}
+}
+
+// HttpGet 发送HTTP GET请求
+// url: 请求地址
+// timeout: 超时时间(可选，默认30秒)，可以传入多个，只使用第一个
+// 返回: 响应体和错误信息
+func HttpGet(url string, timeout ...time.Duration) ([]byte, error) {
+	timeoutDuration := getTimeoutDuration(timeout, DefaultHTTPTimeout)
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeoutDuration)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
-		// handle error
 		return nil, err
 	}

+	client := createHTTPClient(timeoutDuration)
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
 	defer resp.Body.Close()
-	body, err := io.ReadAll(resp.Body)

-	return body, err
+	return io.ReadAll(resp.Body)
 }

-func HttpPost(url string, header map[string]string, data []byte) ([]byte, error) {
-	var err error
-	reader := bytes.NewBuffer(data)
-	request, err := http.NewRequest("POST", url, reader)
+// HttpPostJSON 发送HTTP POST JSON请求
+// url: 请求地址
+// header: 请求头
+// data: 请求数据(将被序列化为JSON)
+// 返回: 响应体和错误信息
+func HttpPostJSON(url string, header map[string]string, data map[string]any) ([]byte, error) {
+	jsonBytes, err := json.Marshal(data)
+	if err != nil {
+		return nil, fmt.Errorf("marshal json failed: %w", err)
+	}

+	return HttpPost(url, header, jsonBytes)
+}
+
+// HttpPost 发送HTTP POST请求
+// url: 请求地址
+// header: 请求头
+// data: 请求体数据
+// timeout: 超时时间(可选，默认30秒)，可以传入多个，只使用第一个
+// 返回: 响应体和错误信息
+func HttpPost(url string, header map[string]string, data []byte, timeout ...time.Duration) ([]byte, error) {
+	timeoutDuration := getTimeoutDuration(timeout, DefaultHTTPTimeout)
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeoutDuration)
+	defer cancel()
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(data))
 	if err != nil {
 		return nil, err
 	}

+	// 设置默认请求头
 	request.Header.Set("Content-Type", "application/json;charset=UTF-8")
 	request.Header.Set("Request-Id", ULID())

+	// 设置自定义请求头
 	for key, val := range header {
 		request.Header.Set(key, val)
 	}

-	client := http.Client{}
+	client := createHTTPClient(timeoutDuration)
 	resp, err := client.Do(request)
 	if err != nil {
 		return nil, err
@ -149,97 +279,112 @@ func HttpPost(url string, header map[string]string, data []byte) ([]byte, error)
 		return nil, err
 	}

-	if resp.StatusCode != 200 {
-		return nil, errors.New(string(respBytes))
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("http status %d: %s", resp.StatusCode, string(respBytes))
 	}

 	return respBytes, nil
 }

-func HttpRequest(r *http.Request) ([]byte, error) {
-	var err error
-	client := http.Client{}
+// HttpRequest 执行HTTP请求
+// r: HTTP请求对象
+// timeout: 超时时间(可选，默认30秒)，可以传入多个，只使用第一个
+// 返回: 响应体和错误信息
+func HttpRequest(r *http.Request, timeout ...time.Duration) ([]byte, error) {
+	timeoutDuration := getTimeoutDuration(timeout, DefaultHTTPTimeout)
+
+	// 如果请求还没有设置context，添加一个带超时的context
+	if r.Context() == context.Background() || r.Context() == nil {
+		ctx, cancel := context.WithTimeout(context.Background(), timeoutDuration)
+		defer cancel()
+		r = r.WithContext(ctx)
+	}
+
+	client := createHTTPClient(timeoutDuration)
 	resp, err := client.Do(r)
 	if err != nil {
 		return nil, err
 	}
 	defer resp.Body.Close()

-	respBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	return respBytes, nil
+	return io.ReadAll(resp.Body)
 }

-func DownloadFile(url, saveTo string, fb func(length, downLen int64)) {
-	var (
-		fsize   int64
-		buf     = make([]byte, 32*1024)
-		written int64
-	)
-	//创建一个http client
-	client := new(http.Client)
-	//get方法获取资源
-	resp, err := client.Get(url)
+// DownloadFile 下载文件
+// url: 下载地址
+// saveTo: 保存路径
+// fb: 进度回调函数
+// timeout: 超时时间(可选，默认5分钟)，可以传入多个，只使用第一个
+func DownloadFile(url, saveTo string, fb func(length, downLen int64), timeout ...time.Duration) error {
+	timeoutDuration := getTimeoutDuration(timeout, DefaultDownloadTimeout)
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeoutDuration)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
-		fmt.Printf("download %s error:%s\n", url, err)
-		os.Exit(0)
+		return fmt.Errorf("create request error: %w", err)
 	}
-	//读取服务器返回的文件大小
-	fsize, err = strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 32)
+
+	client := createHTTPClient(timeoutDuration)
+	resp, err := client.Do(req)
 	if err != nil {
-		fmt.Println(err)
-	}
-	//创建文件
-	file, err := os.Create(saveTo)
-	file.Chmod(0777)
-	if err != nil {
-		fmt.Printf("Create %s error:%s\n", saveTo, err)
-		os.Exit(0)
-	}
-	defer file.Close()
-	if resp.Body == nil {
-		fmt.Printf("resp %s error:%s\n", url, err)
-		os.Exit(0)
+		return fmt.Errorf("download %s error: %w", url, err)
 	}
 	defer resp.Body.Close()
-	//下面是 io.copyBuffer() 的简化版本
+
+	if resp.Body == nil {
+		return fmt.Errorf("response body is nil for %s", url)
+	}
+
+	// 读取服务器返回的文件大小
+	fsize, err := strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 64)
+	if err != nil {
+		// 如果无法获取文件大小，设置为-1表示未知
+		fsize = -1
+	}
+
+	// 创建文件
+	file, err := os.Create(saveTo)
+	if err != nil {
+		return fmt.Errorf("create file %s error: %w", saveTo, err)
+	}
+	defer file.Close()
+
+	// 设置文件权限
+	if err := file.Chmod(0644); err != nil {
+		return fmt.Errorf("chmod file %s error: %w", saveTo, err)
+	}
+
+	// 使用缓冲区读取并写入文件，同时调用进度回调
+	buf := make([]byte, DefaultBufferSize)
+	var written int64
+
 	for {
-		//读取bytes
-		nr, er := resp.Body.Read(buf)
+		nr, readErr := resp.Body.Read(buf)
 		if nr > 0 {
-			//写入bytes
-			nw, ew := file.Write(buf[0:nr])
-			//数据长度大于0
+			nw, writeErr := file.Write(buf[0:nr])
 			if nw > 0 {
 				written += int64(nw)
+				// 调用进度回调
+				if fb != nil {
+					fb(fsize, written)
+				}
 			}
-			//写入出错
-			if ew != nil {
-				err = ew
-				break
+			if writeErr != nil {
+				return fmt.Errorf("write file error: %w", writeErr)
 			}
-			//读取是数据长度不等于写入的数据长度
 			if nr != nw {
-				err = io.ErrShortWrite
+				return fmt.Errorf("write file error: %w", io.ErrShortWrite)
+			}
+		}
+		if readErr != nil {
+			if readErr == io.EOF {
 				break
 			}
+			return fmt.Errorf("read response error: %w", readErr)
 		}
-		if er != nil {
-			if er != io.EOF {
-				err = er
-			}
-			break
-		}
-		//没有错误了快使用 callback
-
-		fb(fsize, written)
 	}

-	if err != nil {
-		fmt.Printf("callback error:%s\n", err)
-		os.Exit(0)
-	}
+	return nil
 }
--- a/utils/qrcode.go
+++ b/utils/qrcode.go
@ -0,0 +1,457 @@
+// Package utils 提供通用工具函数
+//
+// 二维码生成功能模块
+//
+// 本模块提供了完整的二维码生成功能，支持：
+// - 基础二维码生成（保存为PNG文件）
+// - 生成字节数组（可用于HTTP响应、数据库存储等）
+// - Base64编码输出（便于存储和传输）
+// - Data URL格式（可直接用于HTML <img>标签）
+// - 自定义配置（尺寸、颜色、纠错级别）
+// - 带Logo的二维码
+// - 批量生成二维码
+package utils
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"image"
+	"image/color"
+	"image/png"
+	"os"
+
+	"github.com/skip2/go-qrcode"
+)
+
+// QRCodeErrorLevel 二维码纠错级别
+//
+// 纠错级别决定了二维码能容忍多少损坏：
+// - 级别越高，容错能力越强，但二维码会更复杂
+// - 添加Logo时建议使用高级纠错
+// - 一般场景使用中级纠错即可
+type QRCodeErrorLevel int
+
+const (
+	// QRCodeErrorLevelLow 低级纠错（约7%容错）
+	// 适用场景：环境良好、追求小尺寸、内容较少
+	QRCodeErrorLevelLow QRCodeErrorLevel = iota
+
+	// QRCodeErrorLevelMedium 中级纠错（约15%容错）
+	// 适用场景：通用场景（默认推荐）
+	QRCodeErrorLevelMedium
+
+	// QRCodeErrorLevelQuartile 较高级纠错（约25%容错）
+	// 适用场景：需要较高容错能力
+	QRCodeErrorLevelQuartile
+
+	// QRCodeErrorLevelHigh 高级纠错（约30%容错）
+	// 适用场景：添加Logo、容易损坏的环境、长期使用
+	QRCodeErrorLevelHigh
+)
+
+const (
+	// DefaultQRCodeSize 默认二维码尺寸（像素）
+	DefaultQRCodeSize = 256
+	// MinQRCodeSize 最小二维码尺寸
+	MinQRCodeSize = 21
+	// MaxQRCodeSize 最大二维码尺寸
+	MaxQRCodeSize = 8192
+)
+
+// QRCodeConfig 二维码配置结构
+//
+// 用于自定义二维码的外观和质量参数
+//
+// 示例：
+//
+//	config := &QRCodeConfig{
+//	    Size: 512,                                      // 尺寸512x512像素
+//	    ErrorLevel: QRCodeErrorLevelHigh,               // 高级纠错
+//	    ForegroundColor: color.RGBA{255, 0, 0, 255},    // 红色二维码
+//	    BackgroundColor: color.White,                    // 白色背景
+//	}
+type QRCodeConfig struct {
+	Size            int              // 尺寸（像素），范围：21-8192
+	ErrorLevel      QRCodeErrorLevel // 纠错级别，影响容错能力和复杂度
+	ForegroundColor color.Color      // 前景色（二维码颜色），建议使用深色
+	BackgroundColor color.Color      // 背景色，建议使用浅色以保证对比度
+}
+
+// DefaultQRCodeConfig 返回默认配置
+//
+// 默认配置适用于大多数场景：
+// - 尺寸：256x256像素（适合手机扫描）
+// - 纠错级别：中级（15%容错）
+// - 颜色：黑白配色（最佳识别率）
+//
+// 返回值：
+//
+//	*QRCodeConfig: 默认配置对象
+func DefaultQRCodeConfig() *QRCodeConfig {
+	return &QRCodeConfig{
+		Size:            DefaultQRCodeSize,
+		ErrorLevel:      QRCodeErrorLevelMedium,
+		ForegroundColor: color.Black,
+		BackgroundColor: color.White,
+	}
+}
+
+// convertErrorLevel 转换纠错级别为底层库的纠错级别
+//
+// 将自定义的纠错级别枚举转换为 go-qrcode 库所需的格式
+//
+// 参数：
+//
+//	level: 自定义纠错级别
+//
+// 返回值：
+//
+//	qrcode.RecoveryLevel: go-qrcode库的纠错级别
+func convertErrorLevel(level QRCodeErrorLevel) qrcode.RecoveryLevel {
+	switch level {
+	case QRCodeErrorLevelLow:
+		return qrcode.Low
+	case QRCodeErrorLevelMedium:
+		return qrcode.Medium
+	case QRCodeErrorLevelQuartile:
+		return qrcode.High
+	case QRCodeErrorLevelHigh:
+		return qrcode.Highest
+	default:
+		return qrcode.Medium
+	}
+}
+
+// GenerateQRCode 生成二维码并保存为PNG文件
+//
+// 这是最简单的二维码生成方法，适合快速生成标准黑白二维码。
+// 使用中级纠错，黑白配色，PNG格式输出。
+//
+// 参数：
+//
+//	content: 二维码内容（支持URL、文本、vCard、WiFi等格式）
+//	filename: 保存的文件路径（.png文件）
+//	size: 二维码尺寸（可选，单位：像素）
+//	      - 不传参数：使用默认256x256
+//	      - 传一个参数：使用指定尺寸
+//	      - 有效范围：21-8192像素
+//
+// 返回值：
+//
+//	error: 错误信息，成功时返回nil
+//
+// 注意事项：
+//   - 内容越长，二维码越复杂，建议尺寸>=256
+//   - 文件权限为0644
+//   - 会覆盖已存在的同名文件
+func GenerateQRCode(content, filename string, size ...int) error {
+	qrSize := DefaultQRCodeSize
+	if len(size) > 0 {
+		qrSize = size[0]
+		if qrSize < MinQRCodeSize || qrSize > MaxQRCodeSize {
+			return fmt.Errorf("二维码尺寸必须在 %d 到 %d 之间", MinQRCodeSize, MaxQRCodeSize)
+		}
+	}
+
+	err := qrcode.WriteFile(content, qrcode.Medium, qrSize, filename)
+	if err != nil {
+		return fmt.Errorf("生成二维码失败: %w", err)
+	}
+
+	return nil
+}
+
+// GenerateQRCodeBytes 生成二维码字节数组（PNG格式）
+//
+// 生成二维码的字节数组而不保存到文件，适合：
+// - HTTP响应直接返回图片
+// - 存储到数据库
+// - 通过网络传输
+// - 进一步处理（如添加到PDF）
+//
+// 参数：
+//
+//	content: 二维码内容
+//	size: 二维码尺寸（可选，默认256）
+//
+// 返回值：
+//
+//	[]byte: PNG格式的图片字节数组
+//	error: 错误信息
+func GenerateQRCodeBytes(content string, size ...int) ([]byte, error) {
+	qrSize := DefaultQRCodeSize
+	if len(size) > 0 {
+		qrSize = size[0]
+		if qrSize < MinQRCodeSize || qrSize > MaxQRCodeSize {
+			return nil, fmt.Errorf("二维码尺寸必须在 %d 到 %d 之间", MinQRCodeSize, MaxQRCodeSize)
+		}
+	}
+
+	bytes, err := qrcode.Encode(content, qrcode.Medium, qrSize)
+	if err != nil {
+		return nil, fmt.Errorf("生成二维码失败: %w", err)
+	}
+
+	return bytes, nil
+}
+
+// GenerateQRCodeBase64 生成Base64编码的二维码字符串
+//
+// 将二维码图片编码为Base64字符串，便于：
+// - 存储到数据库的文本字段
+// - 通过JSON/XML传输
+// - 避免二进制数据处理问题
+//
+// 参数：
+//
+//	content: 二维码内容
+//	size: 二维码尺寸（可选，默认256）
+//
+// 返回值：
+//
+//	string: Base64编码的字符串（不包含data:image/png;base64,前缀）
+//	error: 错误信息
+func GenerateQRCodeBase64(content string, size ...int) (string, error) {
+	qrBytes, err := GenerateQRCodeBytes(content, size...)
+	if err != nil {
+		return "", err
+	}
+
+	base64Str := base64.StdEncoding.EncodeToString(qrBytes)
+	return base64Str, nil
+}
+
+// GenerateQRCodeWithConfig 使用自定义配置生成二维码
+//
+// 提供完全自定义的二维码生成能力，可以控制：
+// - 尺寸大小
+// - 纠错级别
+// - 前景色和背景色
+//
+// 参数：
+//
+//	content: 二维码内容
+//	config: 二维码配置对象（nil时使用默认配置）
+//
+// 返回值：
+//
+//	[]byte: PNG格式的字节数组
+//	error: 错误信息
+//
+// 注意事项：
+//   - 确保前景色和背景色有足够对比度
+//   - 浅色前景配深色背景可能影响扫描
+func GenerateQRCodeWithConfig(content string, config *QRCodeConfig) ([]byte, error) {
+	if config == nil {
+		config = DefaultQRCodeConfig()
+	}
+
+	// 验证尺寸
+	if config.Size < MinQRCodeSize || config.Size > MaxQRCodeSize {
+		return nil, fmt.Errorf("二维码尺寸必须在 %d 到 %d 之间", MinQRCodeSize, MaxQRCodeSize)
+	}
+
+	// 创建二维码对象
+	qr, err := qrcode.New(content, convertErrorLevel(config.ErrorLevel))
+	if err != nil {
+		return nil, fmt.Errorf("创建二维码失败: %w", err)
+	}
+
+	// 设置颜色
+	qr.ForegroundColor = config.ForegroundColor
+	qr.BackgroundColor = config.BackgroundColor
+
+	// 生成PNG
+	pngBytes, err := qr.PNG(config.Size)
+	if err != nil {
+		return nil, fmt.Errorf("生成PNG失败: %w", err)
+	}
+
+	return pngBytes, nil
+}
+
+// GenerateQRCodeWithLogo 生成带Logo的二维码
+//
+// 在二维码中心嵌入Logo图片，Logo会占据二维码约1/5的区域。
+// 使用高级纠错以确保Logo不影响二维码的可读性。
+//
+// 参数：
+//
+//	content: 二维码内容
+//	logoPath: Logo图片文件路径（支持PNG、JPEG等格式）
+//	size: 二维码尺寸（可选，默认256，建议>=512以保证清晰度）
+//
+// 返回值：
+//
+//	[]byte: PNG格式的字节数组
+//	error: 错误信息
+//
+// 注意事项：
+//   - Logo会自动缩放到二维码的1/5大小
+//   - 建议Logo使用正方形图片
+//   - 使用高级纠错级别（~30%容错）
+//   - Logo会覆盖二维码中心区域
+//   - 建议二维码尺寸>=512以保证Logo清晰
+//   - Logo文件必须存在且可读取
+func GenerateQRCodeWithLogo(content, logoPath string, size ...int) ([]byte, error) {
+	qrSize := DefaultQRCodeSize
+	if len(size) > 0 {
+		qrSize = size[0]
+		if qrSize < MinQRCodeSize || qrSize > MaxQRCodeSize {
+			return nil, fmt.Errorf("二维码尺寸必须在 %d 到 %d 之间", MinQRCodeSize, MaxQRCodeSize)
+		}
+	}
+
+	// 生成基础二维码
+	qr, err := qrcode.New(content, qrcode.High)
+	if err != nil {
+		return nil, fmt.Errorf("创建二维码失败: %w", err)
+	}
+
+	// 生成二维码图像
+	qrImage := qr.Image(qrSize)
+
+	// 读取Logo图片
+	logoFile, err := os.Open(logoPath)
+	if err != nil {
+		return nil, fmt.Errorf("打开Logo文件失败: %w", err)
+	}
+	defer logoFile.Close()
+
+	logoImage, _, err := image.Decode(logoFile)
+	if err != nil {
+		return nil, fmt.Errorf("解码Logo图片失败: %w", err)
+	}
+
+	// 计算Logo位置和大小（Logo占二维码的1/5）
+	logoSize := qrSize / 5
+	logoX := (qrSize - logoSize) / 2
+	logoY := (qrSize - logoSize) / 2
+
+	// 创建最终图像
+	finalImage := image.NewRGBA(qrImage.Bounds())
+
+	// 绘制二维码
+	for y := 0; y < qrSize; y++ {
+		for x := 0; x < qrSize; x++ {
+			finalImage.Set(x, y, qrImage.At(x, y))
+		}
+	}
+
+	// 绘制Logo
+	logoOriginalBounds := logoImage.Bounds()
+	for y := 0; y < logoSize; y++ {
+		for x := 0; x < logoSize; x++ {
+			// 计算原始Logo的对应像素
+			origX := x * logoOriginalBounds.Dx() / logoSize
+			origY := y * logoOriginalBounds.Dy() / logoSize
+			finalImage.Set(logoX+x, logoY+y, logoImage.At(origX, origY))
+		}
+	}
+
+	// 转换为PNG字节
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, finalImage); err != nil {
+		return nil, fmt.Errorf("编码PNG失败: %w", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// SaveQRCodeBytes 保存二维码字节数组到文件
+//
+// 将二维码字节数组保存为PNG文件，常与 GenerateQRCodeBytes 或
+// GenerateQRCodeWithConfig 配合使用。
+//
+// 参数：
+//
+//	data: PNG格式的二维码字节数组
+//	filename: 保存的文件路径
+//
+// 返回值：
+//
+//	error: 错误信息
+//
+// 注意事项：
+//   - 文件权限为0644
+//   - 会覆盖已存在的文件
+//   - 确保目录已存在
+func SaveQRCodeBytes(data []byte, filename string) error {
+	if err := os.WriteFile(filename, data, 0644); err != nil {
+		return fmt.Errorf("保存文件失败: %w", err)
+	}
+	return nil
+}
+
+// GenerateQRCodeDataURL 生成Data URL格式的二维码
+//
+// 生成可以直接用于HTML <img>标签的Data URL格式字符串。
+// Data URL包含了完整的图片数据，无需额外的图片文件。
+//
+// 参数：
+//
+//	content: 二维码内容
+//	size: 二维码尺寸（可选，默认256）
+//
+// 返回值：
+//
+//	string: Data URL格式字符串（包含data:image/png;base64,前缀）
+//	error: 错误信息
+//
+// 注意事项：
+//   - Data URL字符串较长，不适合存储到数据库
+//   - 适合临时显示、前端渲染等场景
+//   - 某些老旧浏览器可能不支持
+func GenerateQRCodeDataURL(content string, size ...int) (string, error) {
+	qrBytes, err := GenerateQRCodeBytes(content, size...)
+	if err != nil {
+		return "", err
+	}
+
+	base64Str := base64.StdEncoding.EncodeToString(qrBytes)
+	dataURL := fmt.Sprintf("data:image/png;base64,%s", base64Str)
+	return dataURL, nil
+}
+
+// BatchGenerateQRCode 批量生成二维码文件
+//
+// 一次性生成多个二维码文件，适合：
+// - 批量生成产品二维码
+// - 生成多个用户的会员卡
+// - 批量生成门票、优惠券等
+//
+// 参数：
+//
+//	items: map[内容]文件名，例如：map["产品A":"qr_a.png", "产品B":"qr_b.png"]
+//	size: 二维码尺寸（可选，默认256，所有二维码使用相同尺寸）
+//
+// 返回值：
+//
+//	[]string: 失败的文件名列表（成功时为nil）
+//	error: 错误信息（部分失败时返回错误，但成功的文件已生成）
+//
+// 注意事项：
+//   - 即使部分失败，成功的二维码仍会生成
+//   - 建议检查返回的failed列表以确定哪些失败了
+//   - 大批量生成时注意磁盘空间
+func BatchGenerateQRCode(items map[string]string, size ...int) ([]string, error) {
+	var failed []string
+	qrSize := DefaultQRCodeSize
+	if len(size) > 0 {
+		qrSize = size[0]
+	}
+
+	for content, filename := range items {
+		err := GenerateQRCode(content, filename, qrSize)
+		if err != nil {
+			failed = append(failed, filename)
+		}
+	}
+
+	if len(failed) > 0 {
+		return failed, fmt.Errorf("有 %d 个二维码生成失败", len(failed))
+	}
+
+	return nil, nil
+}
--- a/utils/time.go
+++ b/utils/time.go
@ -1,13 +1,23 @@
+// Package utils 提供通用工具函数
+// 包括时间处理、数据类型转换、网络工具等
 package utils

 import (
 	"time"
 )

+// Time2String 将时间转换为字符串
+// layout: 时间格式
+// t: 时间对象
+// 返回: 格式化的时间字符串
 func Time2String(layout string, t time.Time) string {
 	return t.Format(layout)
 }

+// String2Time 将字符串转换为时间
+// layout: 时间格式
+// in: 时间字符串
+// 返回: 时间对象
 func String2Time(layout, in string) time.Time {
 	t, _ := time.ParseInLocation(layout, in, time.Local)
 	return t
--- a/utils/validator.go
+++ b/utils/validator.go
@ -0,0 +1,129 @@
+package utils
+
+import (
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// IsEmail 验证是否是邮箱格式
+func IsEmail(email string) bool {
+	if strings.TrimSpace(email) == "" {
+		return false
+	}
+
+	// 邮箱正则表达式
+	pattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
+	matched, err := regexp.MatchString(pattern, email)
+	if err != nil {
+		return false
+	}
+	return matched
+}
+
+// IsMobile 验证是否是手机号（中国手机号格式）
+func IsMobile(mobile string) bool {
+	if strings.TrimSpace(mobile) == "" {
+		return false
+	}
+
+	// 中国手机号正则表达式：1开头，第二位3-9，后面9位数字
+	pattern := `^1[3-9]\d{9}$`
+	matched, err := regexp.MatchString(pattern, mobile)
+	if err != nil {
+		return false
+	}
+	return matched
+}
+
+// IsNumber 验证是否是纯数字
+func IsNumber(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsDigit(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsEnglish 验证是否是英文字符（不限大小写）
+func IsEnglish(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsLetter(char) {
+			return false
+		}
+		if !isEnglishLetter(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsEnglishWithSpace 验证是否是英文字符（允许空格）
+func IsEnglishWithSpace(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if unicode.IsSpace(char) {
+			continue
+		}
+		if !unicode.IsLetter(char) {
+			return false
+		}
+		if !isEnglishLetter(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsAlphanumeric 验证是否是字母和数字组合
+func IsAlphanumeric(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsLetter(char) && !unicode.IsDigit(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsStrongPassword 验证强密码（至少8位，包含大小写字母和数字）
+func IsStrongPassword(password string) bool {
+	if len(password) < 8 {
+		return false
+	}
+
+	var hasUpper, hasLower, hasDigit bool
+
+	for _, char := range password {
+		switch {
+		case unicode.IsUpper(char):
+			hasUpper = true
+		case unicode.IsLower(char):
+			hasLower = true
+		case unicode.IsDigit(char):
+			hasDigit = true
+		}
+	}
+
+	return hasUpper && hasLower && hasDigit
+}
+
+// 辅助函数：判断是否是英文字母
+func isEnglishLetter(char rune) bool {
+	return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z')
+}
--- a/vars/cache.go
+++ b/vars/cache.go
@ -8,4 +8,10 @@ var (
 	MemLRUMaxNumber int           = 1024
 	MemShardings    int           = 64
 	RedisShardings  int           = 256
+
+	// CacheKeyPrefix 缓存键前缀
+	CacheKeyPrefix = "bsm:"
+
+	// DefaultTTL 默认缓存过期时间
+	DefaultTTL = 30 * time.Minute // 30分钟
 )
--- a/vars/jwt.go
+++ b/vars/jwt.go
@ -4,5 +4,5 @@ import "time"

 var (
 	// cache def value
-	JwtExpireDay    time.Duration = 1 * 24 * time.Hour
+	JwtExpire    time.Duration = 1 * 24 * time.Hour
 )
--- a/vars/logger.go
+++ b/vars/logger.go
@ -0,0 +1,12 @@
+package vars
+
+// LogLevel 日志级别
+type LogLevel int
+
+const (
+	DEBUG LogLevel = iota
+	INFO
+	WARN
+	ERROR
+	FATAL
+)
--- a/vars/status.go
+++ b/vars/status.go
@ -5,4 +5,6 @@ const (
 	NormalStatus = 1
 	// DisabledStatus .
 	DisabledStatus = -1
+
+	OK string = "OK"
 )
--- a/with/databases.go
+++ b/with/databases.go
@ -0,0 +1,27 @@
+package with
+
+import (
+	"git.apinb.com/bsm-sdk/core/conf"
+	"git.apinb.com/bsm-sdk/core/database"
+	"git.apinb.com/bsm-sdk/core/printer"
+	"git.apinb.com/bsm-sdk/core/types"
+	"git.apinb.com/bsm-sdk/core/vars"
+	"gorm.io/gorm"
+)
+
+func Databases(cfg *conf.DBConf, opts *types.SqlOptions) *gorm.DB {
+	if cfg == nil || len(cfg.Source) == 0 {
+		panic("No Database Source Found !")
+	}
+
+	// print inform.
+	printer.Info("[BSM - %s] Databases: %v", vars.ServiceKey, cfg)
+
+	var err error
+	db, err := database.NewDatabase(cfg.Driver, cfg.Source, opts)
+	if err != nil {
+		printer.Error("Database Init Failed !")
+		panic(err)
+	}
+	return db
+}
--- a/with/etcd.go
+++ b/with/etcd.go
@ -0,0 +1,54 @@
+package with
+
+import (
+	"time"
+
+	"git.apinb.com/bsm-sdk/core/conf"
+	"git.apinb.com/bsm-sdk/core/errcode"
+	"git.apinb.com/bsm-sdk/core/printer"
+	"git.apinb.com/bsm-sdk/core/vars"
+	"go.etcd.io/etcd/client/pkg/v3/transport"
+	clientv3 "go.etcd.io/etcd/client/v3"
+)
+
+func Etcd(cfg *conf.EtcdConf) (cli *clientv3.Client) {
+	if cfg == nil || len(cfg.Endpoints) == 0 {
+		return
+	}
+
+	etcdCfg := clientv3.Config{
+		Endpoints:   cfg.Endpoints,
+		DialTimeout: 5 * time.Second,
+	}
+
+	if cfg.Passwd != nil {
+		etcdCfg.Username = cfg.Passwd.Account
+		etcdCfg.Password = cfg.Passwd.Password
+
+	}
+
+	if cfg.TLS != nil {
+		tlsInfo := transport.TLSInfo{
+			TrustedCAFile: cfg.TLS.CaFile,
+			CertFile:      cfg.TLS.CertFile,
+			KeyFile:       cfg.TLS.KeyFile,
+		}
+		tlsConfig, err := tlsInfo.ClientConfig()
+		if err != nil {
+			printer.Error(errcode.ErrEtcd.Error())
+			panic(err)
+		}
+		etcdCfg.TLS = tlsConfig
+	}
+
+	var err error
+	cli, err = clientv3.New(etcdCfg)
+	if err != nil {
+		printer.Error(errcode.ErrEtcd.Error())
+		panic(err)
+	}
+
+	// print inform.
+	printer.Info("[BSM - %s] Service Center: %v", vars.ServiceKey, cfg.Endpoints)
+	return
+}
--- a/with/memory.go
+++ b/with/memory.go
@ -0,0 +1,36 @@
+package with
+
+import (
+	"context"
+	"time"
+
+	"git.apinb.com/bsm-sdk/core/printer"
+	"git.apinb.com/bsm-sdk/core/vars"
+	"github.com/allegro/bigcache/v3"
+)
+
+func Memory(opts *bigcache.Config) (cli *bigcache.BigCache) {
+	if opts == nil {
+		opts = &bigcache.Config{
+			Shards:             1024,
+			LifeWindow:         10 * time.Minute,
+			CleanWindow:        5 * time.Minute,
+			MaxEntriesInWindow: 1000 * 10 * 60,
+			MaxEntrySize:       500,
+			Verbose:            true,
+			HardMaxCacheSize:   8192,
+			OnRemove:           nil,
+			OnRemoveWithReason: nil,
+		}
+	}
+
+	var err error
+	cli, err = bigcache.New(context.Background(), *opts)
+	if err != nil {
+		printer.Error("Memory Cache Fatal Error")
+		panic(err)
+	}
+
+	printer.Success("[BSM - %s] Memory Cache: Shards=%d, MaxEntrySize=%d", vars.ServiceKey, opts.Shards, opts.MaxEntrySize)
+	return
+}
--- a/with/redis.go
+++ b/with/redis.go
@ -0,0 +1,18 @@
+package with
+
+import (
+	"git.apinb.com/bsm-sdk/core/cache/redis"
+	"git.apinb.com/bsm-sdk/core/printer"
+	"git.apinb.com/bsm-sdk/core/vars"
+)
+
+func RedisCache(cfg string) (cli *redis.RedisClient) {
+	if cfg != "" {
+		cli = redis.New(cfg, vars.ServiceKey)
+
+		// print inform.
+		printer.Info("[BSM - %s] Cache: %s, DBIndex: %d", vars.ServiceKey, cfg, cli.DB)
+	}
+
+	return
+}
Author	SHA1	Message	Date
zhaoxiaorong	2c5aab84da	新增二维码功能模块：qrcode.go; 为http请求添加超时	2025-11-03 15:27:12 +08:00
yanweidong	3271453878	fix env	2025-10-26 01:30:17 +08:00
yanweidong	42e9d55b62	fix logger new	2025-10-16 13:29:25 +08:00
yanweidong	179157f49e	修复Reply结构体中的字段名称，更新成功和错误响应方法以使用新的字段	2025-10-14 14:48:44 +08:00
yanweidong	8aafcbd91c	fix bug	2025-10-13 13:10:01 +08:00
yanweidong	7e91109bce	fix parsejwt	2025-10-13 11:59:49 +08:00
yanweidong	d451eb3eff	修复GenerateJwt函数中的错误处理逻辑	2025-10-12 03:54:19 +08:00
yanweidong	3d71936ecf	add token	2025-10-11 23:45:55 +08:00
yanweidong	524e310dfe	fix logger	2025-10-07 17:31:14 +08:00
yanweidong	409cb53e8c	fix bug	2025-10-05 15:05:50 +08:00
yanweidong	404957f16a	fix bug	2025-10-05 15:00:07 +08:00
yanweidong	3d6871138a	fix bug	2025-10-05 14:59:01 +08:00
yanweidong	f7d8988415	add AppendMigrate	2025-10-05 14:57:17 +08:00
yanweidong	820d7a5c63	fix errcode	2025-10-04 20:21:45 +08:00
yanweidong	3038c6c22c	fix logger bug	2025-10-04 18:22:19 +08:00
yanweidong	5584757ff4	fix logger bug	2025-10-04 17:42:26 +08:00
yanweidong	464617626b	ai update.	2025-10-03 19:55:20 +08:00
yanweidong	0401a39a94	fix bug	2025-10-03 19:32:57 +08:00
yanweidong	82e6b81126	fix cache.	2025-10-02 19:46:15 +08:00
yanweidong	f934472e50	fix logger,cache	2025-10-02 18:06:23 +08:00
yanweidong	10ee9bba10	build(go): 移除 go.mod 中所有依赖项声明清理 go.mod 文件，移除了所有的 require 声明，包括直接依赖和间接依赖，仅保留模块基本信息。	2025-09-27 00:52:00 +08:00
yanweidong	9f70704081	feat(dependencies): 更新 go.mod 和 go.sum 文件，添加新依赖并优化现有依赖版本在 go.mod 中添加了多个新依赖，包括用于微服务架构、数据库支持、缓存和消息队列的库。同时，更新了 go.sum 文件以反映这些更改。README.md 文件也进行了相应的更新，增加了微服务架构的描述和功能模块的详细信息，确保文档与代码保持一致。	2025-09-27 00:41:27 +08:00
yanweidong	25386cf0e1	``` refactor(print): 将 print 包重命名为 printer 并更新所有引用将项目中的 print 包统一重命名为 printer，以避免与标准库或第三方库产生命名冲突。同时，更新了所有相关模块对该包的引用，确保功能一致性和代码可维护性。涉及文件包括： - conf/new.go - infra/service.go - service/register.go - service/service.go - with/databases.go - with/etcd.go - with/memory.go - with/redis.go 此外，删除了以下已废弃或未使用的代码文件： - cmd/cmd.go - data/map_float.go - data/map_string.go - oplog/new.go - oplog/types.go - print/print.go - utils/ext.go ```	2025-09-27 00:20:36 +08:00
yanweidong	21716c4340	``` feat(database): 自动迁移表结构并优化数据库初始化函数将 `AutoMigrate` 逻辑从各数据库初始化方法中提取至统一的 `NewDatabase` 方法内，避免重复代码。同时修改 `Databases`、`Etcd`、`Memory` 和 `RedisCache` 函数签名，使其返回实例而非通过参数传递，提高代码可读性和一致性。 ```	2025-09-23 16:17:03 +08:00
yanweidong	518c237061	fix(conf): 修改YAML解析方式以支持字符串输入将yaml.Unmarshal的输入从文件字节流改为直接使用yamlString变量，确保配置解析能够正确处理字符串格式的YAML内容。	2025-09-23 15:04:14 +08:00
yanweidong	139983134b	``` feat(service): 优化地址解析逻辑以支持端口号直接解析重构 parseTraditionalStyle 函数，简化 NetworkAddress 构造方式，并引入 utils.IsNumber 判断纯端口号情况，提升地址解析的准确性与兼容性。 ```	2025-09-23 13:26:47 +08:00
yanweidong	75aa6ae647	dev	2025-09-23 13:09:27 +08:00
yanweidong	f681f0bb17	``` refactor(service): 优化Use函数参数类型移除Use函数中initFunc参数的指针包装，直接使用func() error类型。简化函数内部调用逻辑，提升代码可读性和健壮性。 ```	2025-09-23 12:41:31 +08:00
yanweidong	44319d03b9	``` refactor(database): 移除全局初始化函数定义将数据库初始化函数从 database 包中移除，避免全局状态污染。 feat(service): 新增 Use 方法用于执行初始化函数在 Service 结构体中添加 Use 方法，允许传入并执行初始化函数。如果函数执行失败，则打印错误并 panic。 refactor(with): 删除旧的初始化逻辑包删除 with 包中与数据库初始化相关的旧逻辑，统一初始化入口。 ```	2025-09-23 12:37:00 +08:00
yanweidong	2f57edd277	``` refactor(database): 重构数据库初始化逻辑移除 NewDatabase 函数中的 Init 参数，改用 InitFunc 变量进行初始化操作。更新 MigrateTables 附近的注释，明确说明 InitFunc 的用途。删除函数内对 Init 参数的执行逻辑，确保代码简洁性。 ```	2025-09-23 11:28:33 +08:00
yanweidong	cf0ee224f7	``` refactor(database): 调整数据库初始化函数参数传递方式将 Init 函数参数从全局变量改为通过 NewDatabase 函数参数传入，使初始化逻辑更清晰、可控。同时优化代码格式，去除多余空行，提升代码可读性。 ```	2025-09-23 11:02:25 +08:00
yanweidong	f2d8ae26f6	build(go): 移除 go.mod 中所有依赖项声明清理 go.mod 文件，移除了所有直接和间接的依赖项引用，可能为后续依赖管理或模块重构做准备。	2025-09-22 19:03:20 +08:00
yanweidong	dbf68c38c1	``` docs(readme): 重构 README 文档结构并补充模块说明 - 重新组织 README 内容，明确划分私有仓库设置、功能模块等章节 - 补充 crypto、cache、database、middleware、queue 和 utils 模块的功能简介 - 统一代码示例格式，增加 bash 和 go 语言标识 feat(crypto): 优化 PKCS7 填充与去填充函数实现 - 新增 PKCS7Padding 和 PKCS7UnPadding 函数的详细注释 - 添加对输入参数的有效性校验，提升健壮性 - 修复可能引发越界 panic 的潜在问题 feat(database): 完善数据库连接及初始化逻辑 - 为 NewDatabase、NewMysql 和 NewPostgres 函数添加完整注释 - 修复 MaxOpenConns 配置未正确赋值的问题 - 在获取 *sql.DB 实例时增加错误处理逻辑 - 支持通过 Init 变量在连接建立后执行自定义初始化函数 feat(go.mod): 初始化项目依赖管理并引入核心组件 - 添加项目所需的主要依赖包，包括 gin、gorm、redis、nats 等 - 引入常用的工具库如 uuid、ulid、gopsutil 等 - 自动拉取并锁定所有间接依赖版本 ```	2025-09-22 19:02:38 +08:00
yanweidong	f70f8d94db	fix(with): 修复 memory.go 中的配置初始化错误将 bigcache.Config 结构体实例改为指针传递，确保配置能够正确初始化和传递。	2025-09-20 11:32:24 +08:00
yanweidong	257f0a6b6e	fix(with): 优化 memory cache 配置初始化逻辑移除未使用的 `encoding/json` 包导入。调整配置初始化方式，避免不必要的结构体拷贝。改进日志输出内容，仅显示关键配置项。	2025-09-20 11:21:02 +08:00
yanweidong	5e25e8eccc	fix(with/etcd): 修改Etcd配置为空时的处理逻辑当Etcd配置或端点为空时，将panic改为直接返回，避免程序崩溃	2025-09-20 11:08:47 +08:00
yanweidong	4f584726d6	``` refactor(with): 调整Memory函数参数顺序将Memory函数的参数顺序从(opts, cli)调整为(cli, opts)，使函数签名更加符合常规的客户端优先参数排列习惯，提升代码可读性和一致性。 ```	2025-09-20 10:59:45 +08:00
yanweidong	b9d144353e	``` refactor(cache): 移除内存缓存和Redis缓存的初始化逻辑移除了mem包中内存缓存的初始化函数，以及with包中Redis缓存的初始化函数。这些缓存初始化逻辑将被重构到其他位置或采用新的实现方式。 ```	2025-09-20 10:55:06 +08:00
yanweidong	7e7fa16441	``` feat(database): 新增数据库初始化函数新增 NewDatabase 函数，支持根据驱动类型初始化 MySQL 或 Postgres 数据库连接。该函数根据传入的驱动名称自动路由到对应的数据库连接创建逻辑，并提供错误处理。 ```	2025-09-20 10:30:06 +08:00
yanweidong	bc2cb53287	database 新增 new,MigrateTables	2025-09-18 13:56:58 +08:00
yanweidong	cef8b55fba	feat(conf/new.go): 添加配置文件不存在时的处理逻辑及环境变量替换在`New`函数中增加了对配置文件不存在时的处理逻辑，如果指定的服务配置文件不存在，则尝试读取基于工作空间的配置文件。此外，在加载YAML配置之前，新增了对环境变量的替换步骤，确保配置中的环境变量能够被正确解析。这些改动提高了配置加载过程的灵活性与适应性，使得应用能够在缺少特定服务配置的情况下也能正常启动，并且支持通过环境变量动态调整配置内容。	2025-09-18 13:34:35 +08:00
yanweidong	2e07861622	build: 更新 go.mod 文件 - 移除了大量未使用的依赖包 - 保留了必要的依赖包 - 优化了项目结构，提高了代码的可维护性	2025-09-12 23:28:07 +08:00
yanweidong	e30d50845a	feat(vars): 添加 OK 状态码在 status.go 文件中添加了新的状态码 OK，值为 "OK"。这个状态码可以用于表示系统或组件运行正常的情况。	2025-09-12 23:27:14 +08:00
yanweidong	b4cd51a6dc	refactor(encipher): 更新 JWT 过期时间变量 - 将 vars.JwtExpireDay 更改为 vars.JwtExpire，使代码更具通用性 - 优化了 GenerateTokenAes 函数中的过期时间计算逻辑	2025-09-12 20:11:49 +08:00
yanweidong	dac969d798	refactor(vars): 修改 JWT 过期时间变量名称 - 将 JwtExpireDay 重命名为 JwtExpire - 新变量名称更加简洁，同时消除了冗余的 Day 后缀	2025-09-12 18:56:23 +08:00
yanweidong	2f398c73b3	add middleware for CORS and mode configuration	2025-09-02 10:01:09 +08:00
zhaoxiaorong	cb8e9bad4b	fix 操作痕迹可选加密	2025-09-01 12:40:23 +08:00
zhaoxiaorong	1005e89e4f	Merge branch 'main' of https://git.apinb.com/bsm-sdk/core	2025-08-23 21:17:56 +08:00
zhaoxiaorong	268c7f99c7	fix 取消从redis获取token，改为从token中获取有效时间	2025-08-23 21:17:51 +08:00
yanweidong	fc72fd123d	add PrintJson	2025-08-22 12:15:55 +08:00
yanweidong	63a4653eb2	add CopyFile	2025-08-21 10:59:18 +08:00
yanweidong	ffb706df32	Merge branch 'main' of https://git.apinb.com/bsm-sdk/core	2025-08-11 14:42:38 +08:00
yanweidong	282cdde7f9	add file free by filter and allow	2025-08-11 14:42:23 +08:00
zhaoxiaorong	e28934d7b8	fix	2025-07-29 09:48:53 +08:00
zhaoxiaorong	93491fa747	fix	2025-07-29 09:43:14 +08:00
zhaoxiaorong	f8d7737723	fix	2025-07-25 15:10:59 +08:00
zhaoxiaorong	35104ebb90	fix	2025-07-04 16:03:47 +08:00
yanweidong	fc7c1e87a6	fix licence watch	2025-05-28 15:58:28 +08:00
zhaoxiaorong	8c62f529e3	Merge branch 'main' of https://git.apinb.com/bsm-sdk/core	2025-05-27 09:41:00 +08:00
zhaoxiaorong	9d3b3404e4	fix	2025-05-27 09:40:56 +08:00
yanweidong	bfccf4d468	fix licence	2025-05-26 22:11:47 +08:00
yanweidong	cd72620e49	add HttpPostJSON	2025-05-23 10:45:28 +08:00
zhaoxiaorong	5bb23deb3b	fix	2025-05-21 20:13:55 +08:00
david.yan	2c713adc16	add sync map data.	2025-05-03 15:49:16 +08:00
zhaoxiaorong	21f09ea41e	fix	2025-04-24 17:52:29 +08:00
yanweidong	4d06ad3e8b	add err code	2025-04-19 20:14:37 +08:00
yanweidong	52a81a404e	fix infra response	2025-04-18 19:11:50 +08:00
yanweidong	6cd06d86bc	add std_owner	2025-04-17 17:18:58 +08:00