feat: 删除不需要文件夹

2023-10-10 10:56:44 +08:00
parent ce7c3cae68
commit d173205528
154 changed files with 32276 additions and 1 deletions
--- a/lib/core/account/account.go
+++ b/lib/core/account/account.go
@@ -0,0 +1,54 @@
+package account
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	sysMenuService "ems.agt/features/sys_menu/service"
+	sysRoleService "ems.agt/features/sys_role/service"
+	"ems.agt/lib/core/cache"
+	"ems.agt/lib/core/conf"
+	"ems.agt/lib/core/vo"
+	"ems.agt/lib/dborm"
+)
+
+// 登录缓存用户信息
+func CacheLoginUser(user *dborm.User) {
+	// 过期时间
+	expiresStr, err := dborm.XormGetConfigValue("Security", "sessionExpires")
+	if err != nil {
+		expiresStr = "18000"
+	}
+	expiresValue, _ := strconv.Atoi(expiresStr)
+	expireTime := time.Duration(expiresValue) * time.Second
+
+	nowTime := time.Now().UnixMilli()
+
+	// 登录用户
+	loginUser := vo.LoginUser{
+		UserID:     fmt.Sprint(user.Id),
+		UserName:   user.Name,
+		ExpireTime: nowTime + expireTime.Milliseconds(),
+		LoginTime:  nowTime,
+		User:       *user,
+	}
+
+	// 是否管理员
+	if conf.IsAdmin(loginUser.UserID) {
+		loginUser.Permissions = []string{"*:*:*"}
+	} else {
+		// 获取权限标识
+		loginUser.Permissions = sysMenuService.NewRepoSysMenu.SelectMenuPermsByUserId(loginUser.UserID)
+		// 获取角色信息
+		loginUser.User.Roles = sysRoleService.NewRepoSysRole.SelectRoleListByUserId(loginUser.UserID)
+	}
+
+	// 缓存时间
+	cache.SetLocalTTL(user.AccountId, loginUser, time.Duration(expireTime))
+}
+
+// 清除缓存用户信息
+func ClearLoginUser(accountId string) {
+	cache.DeleteLocalTTL(accountId)
+}
--- a/lib/core/cache/lcoal.go
+++ b/lib/core/cache/lcoal.go
@@ -0,0 +1,56 @@
+package cache
+
+import (
+	"strings"
+	"time"
+
+	"github.com/patrickmn/go-cache"
+)
+
+// 创建一个全局的不过期缓存对象
+var cNoExpiration = cache.New(cache.NoExpiration, cache.NoExpiration)
+
+// 将数据放入缓存，并设置永不过期
+func SetLocal(key string, value any) {
+	cNoExpiration.Set(key, value, cache.NoExpiration)
+}
+
+// 从缓存中获取数据
+func GetLocal(key string) (any, bool) {
+	return cNoExpiration.Get(key)
+}
+
+// 从缓存中删除数据
+func DeleteLocal(key string) {
+	cNoExpiration.Delete(key)
+}
+
+// 获取指定前缀的所有键
+func GetLocalKeys(prefix string) []string {
+	prefix = strings.TrimSuffix(prefix, "*")
+	var keys []string
+	for key := range cNoExpiration.Items() {
+		if strings.HasPrefix(key, prefix) {
+			keys = append(keys, key)
+		}
+	}
+	return keys
+}
+
+// 创建一个全局的过期缓存对象
+var cTTL = cache.New(6*time.Hour, 12*time.Hour)
+
+// 设置具有过期时间的缓存项
+func SetLocalTTL(key string, value any, expiration time.Duration) {
+	cTTL.Set(key, value, expiration)
+}
+
+// 从缓存中获取数据
+func GetLocalTTL(key string) (any, bool) {
+	return cTTL.Get(key)
+}
+
+// 从缓存中删除数据
+func DeleteLocalTTL(key string) {
+	cTTL.Delete(key)
+}
--- a/lib/core/cmd/cmd.go
+++ b/lib/core/cmd/cmd.go
@@ -0,0 +1,201 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+func Exec(cmdStr string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	defer cancel()
+	cmd := exec.Command("bash", "-c", cmdStr)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if ctx.Err() == context.DeadlineExceeded {
+		return "", fmt.Errorf("errCmdTimeout %v", err)
+	}
+	if err != nil {
+		errMsg := ""
+		if len(stderr.String()) != 0 {
+			errMsg = fmt.Sprintf("stderr: %s", stderr.String())
+		}
+		if len(stdout.String()) != 0 {
+			if len(errMsg) != 0 {
+				errMsg = fmt.Sprintf("%s; stdout: %s", errMsg, stdout.String())
+			} else {
+				errMsg = fmt.Sprintf("stdout: %s", stdout.String())
+			}
+		}
+		return errMsg, err
+	}
+	return stdout.String(), nil
+}
+
+func ExecWithTimeOut(cmdStr string, timeout time.Duration) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	cmd := exec.Command("bash", "-c", cmdStr)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if ctx.Err() == context.DeadlineExceeded {
+		return "", fmt.Errorf("errCmdTimeout %v", err)
+	}
+	if err != nil {
+		errMsg := ""
+		if len(stderr.String()) != 0 {
+			errMsg = fmt.Sprintf("stderr: %s", stderr.String())
+		}
+		if len(stdout.String()) != 0 {
+			if len(errMsg) != 0 {
+				errMsg = fmt.Sprintf("%s; stdout: %s", errMsg, stdout.String())
+			} else {
+				errMsg = fmt.Sprintf("stdout: %s", stdout.String())
+			}
+		}
+		return errMsg, err
+	}
+	return stdout.String(), nil
+}
+
+func ExecCronjobWithTimeOut(cmdStr string, workdir string, timeout time.Duration) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	cmd := exec.Command("bash", "-c", cmdStr)
+	cmd.Dir = workdir
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if ctx.Err() == context.DeadlineExceeded {
+		return "", fmt.Errorf("errCmdTimeout %v", err)
+	}
+
+	errMsg := ""
+	if len(stderr.String()) != 0 {
+		errMsg = fmt.Sprintf("stderr:\n %s", stderr.String())
+	}
+	if len(stdout.String()) != 0 {
+		if len(errMsg) != 0 {
+			errMsg = fmt.Sprintf("%s \n\n; stdout:\n %s", errMsg, stdout.String())
+		} else {
+			errMsg = fmt.Sprintf("stdout:\n %s", stdout.String())
+		}
+	}
+	return errMsg, err
+}
+
+func Execf(cmdStr string, a ...interface{}) (string, error) {
+	cmd := exec.Command("bash", "-c", fmt.Sprintf(cmdStr, a...))
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if err != nil {
+		errMsg := ""
+		if len(stderr.String()) != 0 {
+			errMsg = fmt.Sprintf("stderr: %s", stderr.String())
+		}
+		if len(stdout.String()) != 0 {
+			if len(errMsg) != 0 {
+				errMsg = fmt.Sprintf("%s; stdout: %s", errMsg, stdout.String())
+			} else {
+				errMsg = fmt.Sprintf("stdout: %s", stdout.String())
+			}
+		}
+		return errMsg, err
+	}
+	return stdout.String(), nil
+}
+
+func ExecWithCheck(name string, a ...string) (string, error) {
+	cmd := exec.Command(name, a...)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if err != nil {
+		errMsg := ""
+		if len(stderr.String()) != 0 {
+			errMsg = fmt.Sprintf("stderr: %s", stderr.String())
+		}
+		if len(stdout.String()) != 0 {
+			if len(errMsg) != 0 {
+				errMsg = fmt.Sprintf("%s; stdout: %s", errMsg, stdout.String())
+			} else {
+				errMsg = fmt.Sprintf("stdout: %s", stdout.String())
+			}
+		}
+		return errMsg, err
+	}
+	return stdout.String(), nil
+}
+
+func ExecScript(scriptPath, workDir string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
+	defer cancel()
+	cmd := exec.Command("bash", scriptPath)
+	cmd.Dir = workDir
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if ctx.Err() == context.DeadlineExceeded {
+		return "", fmt.Errorf("errCmdTimeout %v", err)
+	}
+	if err != nil {
+		errMsg := ""
+		if len(stderr.String()) != 0 {
+			errMsg = fmt.Sprintf("stderr: %s", stderr.String())
+		}
+		if len(stdout.String()) != 0 {
+			if len(errMsg) != 0 {
+				errMsg = fmt.Sprintf("%s; stdout: %s", errMsg, stdout.String())
+			} else {
+				errMsg = fmt.Sprintf("stdout: %s", stdout.String())
+			}
+		}
+		return errMsg, err
+	}
+	return stdout.String(), nil
+}
+
+func CheckIllegal(args ...string) bool {
+	if args == nil {
+		return false
+	}
+	for _, arg := range args {
+		if strings.Contains(arg, "&") || strings.Contains(arg, "|") || strings.Contains(arg, ";") ||
+			strings.Contains(arg, "$") || strings.Contains(arg, "'") || strings.Contains(arg, "`") ||
+			strings.Contains(arg, "(") || strings.Contains(arg, ")") || strings.Contains(arg, "\"") {
+			return true
+		}
+	}
+	return false
+}
+
+func HasNoPasswordSudo() bool {
+	cmd2 := exec.Command("sudo", "-n", "ls")
+	err2 := cmd2.Run()
+	return err2 == nil
+}
+
+func SudoHandleCmd() string {
+	cmd := exec.Command("sudo", "-n", "ls")
+	if err := cmd.Run(); err == nil {
+		return "sudo "
+	}
+	return ""
+}
+
+func Which(name string) bool {
+	_, err := exec.LookPath(name)
+	return err == nil
+}
--- a/lib/core/conf/conf.go
+++ b/lib/core/conf/conf.go
@@ -0,0 +1,52 @@
+package conf
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/spf13/viper"
+)
+
+// 配置文件读取
+func InitConfig(configFile string) {
+	// 设置配置文件路径
+	viper.SetConfigFile(configFile)
+
+	// 读取配置文件
+	err := viper.ReadInConfig()
+	if err != nil {
+		fmt.Printf("读取配置文件失败: %v \n", err)
+		return
+	}
+
+	// 记录程序开始运行的时间点
+	viper.Set("runTime", time.Now())
+}
+
+// RunTime 程序开始运行的时间
+func RunTime() time.Time {
+	return viper.GetTime("runTime")
+}
+
+// Get 获取配置信息
+//
+// Get("framework.name")
+func Get(key string) any {
+	return viper.Get(key)
+}
+
+// IsAdmin 用户是否为管理员
+func IsAdmin(userID string) bool {
+	if userID == "" {
+		return false
+	}
+	// 从本地配置获取user信息
+	// admins := Get("user.adminList").([]any)
+	admins := []string{"1", "2", "3"}
+	for _, s := range admins {
+		if s == userID {
+			return true
+		}
+	}
+	return false
+}
--- a/lib/core/constants/cachekey/cachekey.go
+++ b/lib/core/constants/cachekey/cachekey.go
@@ -0,0 +1,24 @@
+package cachekey
+
+// 缓存的key常量
+
+// 登录用户
+const LOGIN_TOKEN_KEY = "login_tokens:"
+
+// 验证码
+const CAPTCHA_CODE_KEY = "captcha_codes:"
+
+// 参数管理
+const SYS_CONFIG_KEY = "sys_config:"
+
+// 字典管理
+const SYS_DICT_KEY = "sys_dict:"
+
+// 防重提交
+const REPEAT_SUBMIT_KEY = "repeat_submit:"
+
+// 限流
+const RATE_LIMIT_KEY = "rate_limit:"
+
+// 登录账户密码错误次数
+const PWD_ERR_CNT_KEY = "pwd_err_cnt:"
--- a/lib/core/datasource/datasource.go
+++ b/lib/core/datasource/datasource.go
@@ -0,0 +1,49 @@
+package datasource
+
+import (
+	"database/sql"
+	"regexp"
+
+	"ems.agt/lib/dborm"
+	"xorm.io/xorm"
+)
+
+// 获取默认数据源
+func DefaultDB() *xorm.Engine {
+	return dborm.DbClient.XEngine
+}
+
+// RawDB 原生查询语句
+func RawDB(source string, sql string, parameters []any) ([]map[string]any, error) {
+	// 数据源
+	db := DefaultDB()
+
+	// 使用正则表达式替换连续的空白字符为单个空格
+	fmtSql := regexp.MustCompile(`\s+`).ReplaceAllString(sql, " ")
+
+	// log.Infof("sql=> %v", fmtSql)
+	// log.Infof("parameters=> %v", parameters)
+
+	// 查询结果
+	var rows []map[string]any
+	err := db.SQL(fmtSql, parameters...).Find(&rows)
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+// ExecDB 原生执行语句
+func ExecDB(source string, sql string, parameters []any) (sql.Result, error) {
+	// 数据源
+	db := DefaultDB()
+
+	// 使用正则表达式替换连续的空白字符为单个空格
+	fmtSql := regexp.MustCompile(`\s+`).ReplaceAllString(sql, " ")
+	// 执行结果
+	res, err := db.Exec(append([]any{fmtSql}, parameters...)...)
+	if err != nil {
+		return nil, err
+	}
+	return res, err
+}
--- a/lib/core/datasource/repo.go
+++ b/lib/core/datasource/repo.go
@@ -0,0 +1,135 @@
+package datasource
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// PageNumSize 分页页码记录数
+func PageNumSize(pageNum, pageSize any) (int, int) {
+	// 记录起始索引
+	pageNumStr := fmt.Sprintf("%v", pageNum)
+	num := 1
+	if v, err := strconv.Atoi(pageNumStr); err == nil && v > 0 {
+		if num > 5000 {
+			num = 5000
+		}
+		num = v
+	}
+
+	// 显示记录数
+	pageSizeStr := fmt.Sprintf("%v", pageSize)
+	size := 10
+	if v, err := strconv.Atoi(pageSizeStr); err == nil && v > 0 {
+		if size < 0 {
+			size = 10
+		} else if size > 1000 {
+			size = 1000
+		} else {
+			size = v
+		}
+	}
+	return num - 1, size
+}
+
+// SetFieldValue 判断结构体内是否存在指定字段并设置值
+func SetFieldValue(obj any, fieldName string, value any) {
+	// 获取结构体的反射值
+	userValue := reflect.ValueOf(obj)
+
+	// 获取字段的反射值
+	fieldValue := userValue.Elem().FieldByName(fieldName)
+
+	// 检查字段是否存在
+	if fieldValue.IsValid() && fieldValue.CanSet() {
+		// 获取字段的类型
+		fieldType := fieldValue.Type()
+
+		// 转换传入的值类型为字段类型
+		switch fieldType.Kind() {
+		case reflect.String:
+			if value == nil {
+				fieldValue.SetString("")
+			} else {
+				fieldValue.SetString(fmt.Sprintf("%v", value))
+			}
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			intValue, err := strconv.ParseInt(fmt.Sprintf("%v", value), 10, 64)
+			if err != nil {
+				intValue = 0
+			}
+			fieldValue.SetInt(intValue)
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			uintValue, err := strconv.ParseUint(fmt.Sprintf("%v", value), 10, 64)
+			if err != nil {
+				uintValue = 0
+			}
+			fieldValue.SetUint(uintValue)
+		case reflect.Float32, reflect.Float64:
+			floatValue, err := strconv.ParseFloat(fmt.Sprintf("%v", value), 64)
+			if err != nil {
+				floatValue = 0
+			}
+			fieldValue.SetFloat(floatValue)
+		default:
+			// 设置字段的值
+			fieldValue.Set(reflect.ValueOf(value).Convert(fieldValue.Type()))
+		}
+	}
+}
+
+// ConvertIdsSlice 将 []string 转换为 []any
+func ConvertIdsSlice(ids []string) []any {
+	// 将 []string 转换为 []any
+	arr := make([]any, len(ids))
+	for i, v := range ids {
+		arr[i] = v
+	}
+	return arr
+}
+
+// 查询-参数值的占位符
+func KeyPlaceholderByQuery(sum int) string {
+	placeholders := make([]string, sum)
+	for i := 0; i < sum; i++ {
+		placeholders[i] = "?"
+	}
+	return strings.Join(placeholders, ",")
+}
+
+// 插入-参数映射键值占位符 keys, placeholder, values
+func KeyPlaceholderValueByInsert(params map[string]any) ([]string, string, []any) {
+	// 参数映射的键
+	keys := make([]string, len(params))
+	// 参数映射的值
+	values := make([]any, len(params))
+	sum := 0
+	for k, v := range params {
+		keys[sum] = k
+		values[sum] = v
+		sum++
+	}
+	// 参数值的占位符
+	placeholders := make([]string, sum)
+	for i := 0; i < sum; i++ {
+		placeholders[i] = "?"
+	}
+	return keys, strings.Join(placeholders, ","), values
+}
+
+// 更新-参数映射键值占位符 keys, values
+func KeyValueByUpdate(params map[string]any) ([]string, []any) {
+	// 参数映射的键
+	keys := make([]string, len(params))
+	// 参数映射的值
+	values := make([]any, len(params))
+	sum := 0
+	for k, v := range params {
+		keys[sum] = k + "=?"
+		values[sum] = v
+		sum++
+	}
+	return keys, values
+}
--- a/lib/core/file/csv.go
+++ b/lib/core/file/csv.go
@@ -0,0 +1,88 @@
+package file
+
+import (
+	"encoding/csv"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"ems.agt/lib/log"
+)
+
+// 写入CSV文件，需要转换数据
+// 例如：
+// data := [][]string{}
+// data = append(data, []string{"姓名", "年龄", "城市"})
+// data = append(data, []string{"1", "2", "3"})
+// err := file.WriterCSVFile(data, filePath)
+func WriterCSVFile(data [][]string, filePath string) error {
+	// 获取文件所在的目录路径
+	dirPath := filepath.Dir(filePath)
+
+	// 确保文件夹路径存在
+	err := os.MkdirAll(dirPath, os.ModePerm)
+	if err != nil {
+		log.Errorf("创建文件夹失败 CreateFile %v", err)
+	}
+
+	// 创建或打开文件
+	file, err := os.Create(filePath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	// 创建CSV编写器
+	writer := csv.NewWriter(file)
+	defer writer.Flush()
+
+	// 写入数据
+	for _, row := range data {
+		writer.Write(row)
+	}
+	return nil
+}
+
+// 读取CSV文件，转换map数据
+func ReadCSVFile(filePath string) []map[string]string {
+	// 创建 map 存储 CSV 数据
+	arr := make([]map[string]string, 0)
+
+	// 打开 CSV 文件
+	file, err := os.Open(filePath)
+	if err != nil {
+		log.Fatal("无法打开 CSV 文件：", err)
+		return arr
+	}
+	defer file.Close()
+
+	// 创建 CSV Reader
+	reader := csv.NewReader(file)
+
+	// 读取 CSV 头部行
+	header, err := reader.Read()
+	if err != nil {
+		log.Fatal("无法读取 CSV 头部行：", err)
+		return arr
+	}
+
+	// 遍历 CSV 数据行
+	for {
+		// 读取一行数据
+		record, err := reader.Read()
+		if err != nil {
+			// 到达文件末尾或遇到错误时退出循环
+			break
+		}
+
+		// 将 CSV 数据插入到 map 中
+		data := make(map[string]string)
+		for i, value := range record {
+			key := strings.ToLower(header[i])
+			data[key] = value
+		}
+		arr = append(arr, data)
+	}
+
+	return arr
+}
--- a/lib/core/file/ssh.go
+++ b/lib/core/file/ssh.go
@@ -0,0 +1,49 @@
+package file
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"ems.agt/lib/core/conf"
+	"ems.agt/lib/log"
+)
+
+// 网元NE 文件复制到远程文件
+func FileSCPLocalToNe(neIp, localPath, nePath string) error {
+	usernameNe := conf.Get("ne.user").(string)
+	// scp /path/to/local/file.txt user@remote-server:/path/to/remote/directory/
+	neDir := fmt.Sprintf("%s@%s:%s", usernameNe, neIp, nePath)
+	cmd := exec.Command("scp", "-r", localPath, neDir)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return err
+	}
+	log.Infof("FileSCPLocalToNe %s", string(out))
+	return nil
+}
+
+// 网元NE 远程文件复制到本地文件
+func FileSCPNeToLocal(neIp, nePath, localPath string) error {
+	// 获取文件所在的目录路径
+	dirPath := filepath.Dir(localPath)
+
+	// 确保文件夹路径存在
+	err := os.MkdirAll(dirPath, os.ModePerm)
+	if err != nil {
+		log.Errorf("创建文件夹失败 CreateFile %v", err)
+		return err
+	}
+
+	usernameNe := conf.Get("ne.user").(string)
+	// scp user@remote-server:/path/to/remote/directory/ /path/to/local/file.txt
+	neDir := fmt.Sprintf("%s@%s:%s", usernameNe, neIp, nePath)
+	cmd := exec.Command("scp", "-r", neDir, localPath)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return err
+	}
+	log.Infof("FileSCPNeToLocal %s", string(out))
+	return nil
+}
--- a/lib/core/file/txt.go
+++ b/lib/core/file/txt.go
@@ -0,0 +1,79 @@
+package file
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"ems.agt/lib/log"
+)
+
+// 写入Txt文件用,号分割 需要转换数据
+// 例如：
+// data := [][]string{}
+// data = append(data, []string{"姓名", "年龄", "城市"})
+// data = append(data, []string{"1", "2", "3"})
+// err := file.WriterCSVFile(data, filePath)
+func WriterTxtFile(data [][]string, filePath string) error {
+	// 获取文件所在的目录路径
+	dirPath := filepath.Dir(filePath)
+
+	// 确保文件夹路径存在
+	err := os.MkdirAll(dirPath, os.ModePerm)
+	if err != nil {
+		log.Errorf("创建文件夹失败 CreateFile %v", err)
+	}
+
+	// 创建或打开文件
+	file, err := os.Create(filePath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	// 创建一个 Writer 对象，用于将数据写入文件
+	writer := bufio.NewWriter(file)
+	for _, row := range data {
+		line := strings.Join(row, ",")
+		fmt.Fprintln(writer, line)
+	}
+
+	// 将缓冲区中的数据刷新到文件中
+	err = writer.Flush()
+	if err != nil {
+		log.Errorf("刷新缓冲区时发生错误:", err)
+		return err
+	}
+	return nil
+}
+
+// 读取Txt文件，用,号分割 转换数组数据
+func ReadTxtFile(filePath string) [][]string {
+	// 创建 map 存储 CSV 数据
+	arr := make([][]string, 0)
+
+	// 打开文本文件
+	file, err := os.Open(filePath)
+	if err != nil {
+		log.Fatal("无法打开文件:", err)
+		return arr
+	}
+	defer file.Close()
+
+	// 创建一个 Scanner 对象，用于逐行读取文件内容
+	scanner := bufio.NewScanner(file)
+	if scanner.Err() != nil {
+		log.Fatal("读取文件时出错:", scanner.Err())
+		return arr
+	}
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		fields := strings.Split(line, ",")
+		arr = append(arr, fields)
+	}
+
+	return arr
+}
--- a/lib/core/mml_client/mml_client.go
+++ b/lib/core/mml_client/mml_client.go
@@ -0,0 +1,88 @@
+package mmlclient
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"net"
+	"time"
+
+	"ems.agt/lib/core/conf"
+)
+
+// 定义MMLClient结构体
+type MMLClient struct {
+	awaitTime time.Duration // 等待时间
+	conn      net.Conn
+	reader    *bufio.Reader
+	size      int // 包含字符
+}
+
+// 封装NewMMLClient函数，用于创建MMLClient实例
+// 网元UDM的IP地址 "198.51.100.1"
+func NewMMLClient(ip string) (*MMLClient, error) {
+	// 创建TCP连接
+	portMML := conf.Get("mml.port").(int)
+	hostMML := fmt.Sprintf("%s:%d", ip, portMML)
+	conn, err := net.Dial("tcp", hostMML)
+	if err != nil {
+		return nil, err
+	}
+
+	// 进行登录
+	usernameMML := conf.Get("mml.user").(string)
+	passwordMML := conf.Get("mml.password").(string)
+	fmt.Fprintln(conn, usernameMML)
+	fmt.Fprintln(conn, passwordMML)
+
+	// 发送后等待
+	sleepTime := conf.Get("mml.sleep").(int)
+	awaitTime := time.Duration(sleepTime) * time.Millisecond
+	time.Sleep(awaitTime)
+
+	// 读取内容
+	buf := make([]byte, 1024*8)
+	n, err := conn.Read(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	// 创建MMLClient实例
+	client := &MMLClient{
+		conn:      conn,
+		reader:    bufio.NewReader(conn),
+		awaitTime: awaitTime,
+		size:      n,
+	}
+
+	return client, nil
+}
+
+// 封装Send函数，用于向TCP连接发送数据
+func (c *MMLClient) Send(msg string) error {
+	_, err := fmt.Fprintln(c.conn, msg)
+	if err != nil {
+		return err
+	}
+	time.Sleep(c.awaitTime)
+	return nil
+}
+
+// 封装Receive函数，用于从TCP连接中接收数据
+func (c *MMLClient) Receive() (string, error) {
+	buf := make([]byte, 1024*8)
+	n, err := c.reader.Read(buf)
+	if err != nil {
+		if err == io.EOF {
+			return "", fmt.Errorf("server closed the connection")
+		}
+		return "", err
+	}
+
+	return string(buf[0:n]), nil
+}
+
+// 封装Close函数，用于关闭TCP连接
+func (c *MMLClient) Close() error {
+	return c.conn.Close()
+}
--- a/lib/core/mml_client/send.go
+++ b/lib/core/mml_client/send.go
@@ -0,0 +1,104 @@
+package mmlclient
+
+import (
+	"fmt"
+	"strings"
+)
+
+// 发送MML原始消息
+// ip 网元IP地址
+// msg 指令
+func MMLSendMsg(ip, msg string) (string, error) {
+	// 创建MMLClient实例
+	client, err := NewMMLClient(ip)
+	if err != nil {
+		return "", fmt.Errorf("创建MMLClient实例失败：%v", err)
+	}
+	defer client.Close()
+
+	// 发送数据
+	err = client.Send(msg)
+	if err != nil {
+		return "", fmt.Errorf("发送数据失败：%v", err)
+	}
+
+	// 接收数据
+	data, err := client.Receive()
+	if err != nil {
+		return "", fmt.Errorf("接收数据失败：%v", err)
+	}
+
+	return data, nil
+}
+
+// 发送MML
+// ip 网元IP地址
+// msg 指令
+func MMLSendMsgToString(ip, msg string) (string, error) {
+	// 发送获取数据
+	str, err := MMLSendMsg(ip, msg)
+	if err != nil {
+		return "", err
+	}
+
+	// 截断
+	index := strings.Index(str, "\n")
+	if index != -1 {
+		str = str[:index]
+		str = strings.ToLower(str)
+	}
+
+	// 命令成功
+	if strings.Contains(str, "ok") || strings.Contains(str, "OK") {
+		return str, nil
+	}
+
+	return "", fmt.Errorf(str)
+}
+
+// 发送MML
+// ip 网元IP地址
+// msg 指令
+func MMLSendMsgToMap(ip, msg string) (map[string]string, error) {
+	// 发送获取数据
+	str, err := MMLSendMsg(ip, msg)
+	if err != nil {
+		return nil, err
+	}
+
+	// 无数据
+	if strings.HasPrefix(str, "No Auth Data") {
+		return nil, fmt.Errorf("no auth data")
+	}
+
+	// 初始化一个map用于存储拆分后的键值对
+	m := make(map[string]string)
+
+	var items []string
+	if strings.Contains(str, "\r\n") {
+		// 按照分隔符"\r\n"进行拆分
+		items = strings.Split(str, "\r\n")
+	} else if strings.Contains(str, "\n") {
+		// 按照分隔符"\n"进行拆分
+		items = strings.Split(str, "\n")
+	}
+
+	// 遍历拆分后的结果
+	for _, item := range items {
+		var pair []string
+
+		if strings.Contains(item, "=") {
+			// 按照分隔符"="进行拆分键值对
+			pair = strings.Split(item, "=")
+		} else if strings.Contains(item, ":") {
+			// 按照分隔符":"进行拆分键值对
+			pair = strings.Split(item, ":")
+		}
+
+		if len(pair) == 2 {
+			// 将键值对存入map中
+			m[pair[0]] = pair[1]
+		}
+	}
+	return m, err
+}
--- a/lib/core/redis/redis.go
+++ b/lib/core/redis/redis.go
@@ -0,0 +1,358 @@
+package redis
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"ems.agt/lib/core/conf"
+	"ems.agt/lib/log"
+	"github.com/redis/go-redis/v9"
+)
+
+// Redis连接实例
+var rdbMap = make(map[string]*redis.Client)
+
+// 声明定义限流脚本命令
+var rateLimitCommand = redis.NewScript(`
+local key = KEYS[1]
+local time = tonumber(ARGV[1])
+local count = tonumber(ARGV[2])
+local current = redis.call('get', key);
+if current and tonumber(current) >= count then
+	return tonumber(current);
+end
+current = redis.call('incr', key)
+if tonumber(current) == 1 then 
+	redis.call('expire', key, time)
+end
+return tonumber(current);`)
+
+// 连接Redis实例
+func Connect() {
+	ctx := context.Background()
+	// 读取数据源配置
+	datasource := conf.Get("redis.dataSource").(map[string]any)
+	for k, v := range datasource {
+		client := v.(map[string]any)
+		// 创建连接
+		address := fmt.Sprintf("%s:%d", client["host"], client["port"])
+		rdb := redis.NewClient(&redis.Options{
+			Addr:     address,
+			Password: client["password"].(string),
+			DB:       client["db"].(int),
+		})
+		// 测试数据库连接
+		pong, err := rdb.Ping(ctx).Result()
+		if err != nil {
+			log.Fatalf("failed error ping redis %s %d is %v", client["host"], client["db"], err)
+			continue
+		}
+		log.Infof("redis %s %d %s connection is successful.", client["host"], client["db"], pong)
+		rdbMap[k] = rdb
+	}
+}
+
+// 关闭Redis实例
+func Close() {
+	for _, rdb := range rdbMap {
+		if err := rdb.Close(); err != nil {
+			log.Errorf("fatal error db close: %s", err)
+		}
+	}
+}
+
+// 获取默认实例
+func DefaultRDB() *redis.Client {
+	source := conf.Get("redis.defaultDataSourceName").(string)
+	return rdbMap[source]
+}
+
+// 获取实例
+func RDB(source string) *redis.Client {
+	return rdbMap[source]
+}
+
+// Info 获取redis服务信息
+func Info(source string) map[string]map[string]string {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	info, err := rdb.Info(ctx).Result()
+	if err != nil {
+		return map[string]map[string]string{}
+	}
+	infoObj := make(map[string]map[string]string)
+	lines := strings.Split(info, "\r\n")
+	label := ""
+	for _, line := range lines {
+		if strings.Contains(line, "#") {
+			label = strings.Fields(line)[len(strings.Fields(line))-1]
+			label = strings.ToLower(label)
+			infoObj[label] = make(map[string]string)
+			continue
+		}
+		kvArr := strings.Split(line, ":")
+		if len(kvArr) >= 2 {
+			key := strings.TrimSpace(kvArr[0])
+			value := strings.TrimSpace(kvArr[len(kvArr)-1])
+			infoObj[label][key] = value
+		}
+	}
+	return infoObj
+}
+
+// KeySize 获取redis当前连接可用键Key总数信息
+func KeySize(source string) int64 {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	size, err := rdb.DBSize(ctx).Result()
+	if err != nil {
+		return 0
+	}
+	return size
+}
+
+// CommandStats 获取redis命令状态信息
+func CommandStats(source string) []map[string]string {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	commandstats, err := rdb.Info(ctx, "commandstats").Result()
+	if err != nil {
+		return []map[string]string{}
+	}
+	statsObjArr := make([]map[string]string, 0)
+	lines := strings.Split(commandstats, "\r\n")
+	for _, line := range lines {
+		if !strings.HasPrefix(line, "cmdstat_") {
+			continue
+		}
+		kvArr := strings.Split(line, ":")
+		key := kvArr[0]
+		valueStr := kvArr[len(kvArr)-1]
+		statsObj := make(map[string]string)
+		statsObj["name"] = key[8:]
+		statsObj["value"] = valueStr[6:strings.Index(valueStr, ",usec=")]
+		statsObjArr = append(statsObjArr, statsObj)
+	}
+	return statsObjArr
+}
+
+// 获取键的剩余有效时间（秒）
+func GetExpire(source string, key string) (float64, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	ttl, err := rdb.TTL(ctx, key).Result()
+	if err != nil {
+		return 0, err
+	}
+	return ttl.Seconds(), nil
+}
+
+// 获得缓存数据的key列表
+func GetKeys(source string, pattern string) ([]string, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	// 初始化变量
+	var keys []string
+	var cursor uint64 = 0
+	ctx := context.Background()
+	// 循环遍历获取匹配的键
+	for {
+		// 使用 SCAN 命令获取匹配的键
+		batchKeys, nextCursor, err := rdb.Scan(ctx, cursor, pattern, 100).Result()
+		if err != nil {
+			log.Errorf("Failed to scan keys: %v", err)
+			return keys, err
+		}
+		cursor = nextCursor
+		keys = append(keys, batchKeys...)
+		// 当 cursor 为 0，表示遍历完成
+		if cursor == 0 {
+			break
+		}
+	}
+	return keys, nil
+}
+
+// 批量获得缓存数据
+func GetBatch(source string, keys []string) ([]any, error) {
+	if len(keys) == 0 {
+		return []any{}, fmt.Errorf("not keys")
+	}
+
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	// 获取缓存数据
+	result, err := rdb.MGet(context.Background(), keys...).Result()
+	if err != nil {
+		log.Errorf("Failed to get batch data: %v", err)
+		return []any{}, err
+	}
+	return result, nil
+}
+
+// 获得缓存数据
+func Get(source, key string) (string, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	value, err := rdb.Get(ctx, key).Result()
+	if err == redis.Nil || err != nil {
+		return "", err
+	}
+	return value, nil
+}
+
+// 获得缓存数据Hash
+func GetHash(source, key string) (map[string]string, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	value, err := rdb.HGetAll(ctx, key).Result()
+	if err == redis.Nil || err != nil {
+		return map[string]string{}, err
+	}
+	return value, nil
+}
+
+// 判断是否存在
+func Has(source string, keys ...string) (bool, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	exists, err := rdb.Exists(ctx, keys...).Result()
+	if err != nil {
+		return false, err
+	}
+	return exists >= 1, nil
+}
+
+// 设置缓存数据
+func Set(source, key string, value any) (bool, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	err := rdb.Set(ctx, key, value, 0).Err()
+	if err != nil {
+		log.Errorf("redis lua script err %v", err)
+		return false, err
+	}
+	return true, nil
+}
+
+// 设置缓存数据与过期时间
+func SetByExpire(source, key string, value any, expiration time.Duration) (bool, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	err := rdb.Set(ctx, key, value, expiration).Err()
+	if err != nil {
+		log.Errorf("redis lua script err %v", err)
+		return false, err
+	}
+	return true, nil
+}
+
+// 删除单个
+func Del(source string, key string) (bool, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	err := rdb.Del(ctx, key).Err()
+	if err != nil {
+		log.Errorf("redis lua script err %v", err)
+		return false, err
+	}
+	return true, nil
+}
+
+// 删除多个
+func DelKeys(source string, keys []string) (bool, error) {
+	if len(keys) == 0 {
+		return false, fmt.Errorf("no keys")
+	}
+
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	err := rdb.Del(ctx, keys...).Err()
+	if err != nil {
+		log.Errorf("redis lua script err %v", err)
+		return false, err
+	}
+	return true, nil
+}
+
+// 限流查询并记录
+func RateLimit(source, limitKey string, time, count int64) (int64, error) {
+	// 数据源
+	rdb := DefaultRDB()
+	if source != "" {
+		rdb = RDB(source)
+	}
+
+	ctx := context.Background()
+	result, err := rateLimitCommand.Run(ctx, rdb, []string{limitKey}, time, count).Result()
+	if err != nil {
+		log.Errorf("redis lua script err %v", err)
+		return 0, err
+	}
+	return result.(int64), err
+}
--- a/lib/core/utils/crypto/crypto.go
+++ b/lib/core/utils/crypto/crypto.go
@@ -0,0 +1,20 @@
+package crypto
+
+import (
+	"golang.org/x/crypto/bcrypt"
+)
+
+// BcryptHash Bcrypt密码加密
+func BcryptHash(originStr string) string {
+	hash, err := bcrypt.GenerateFromPassword([]byte(originStr), bcrypt.DefaultCost)
+	if err != nil {
+		return ""
+	}
+	return string(hash)
+}
+
+// BcryptCompare Bcrypt密码匹配检查
+func BcryptCompare(originStr, hashStr string) bool {
+	err := bcrypt.CompareHashAndPassword([]byte(hashStr), []byte(originStr))
+	return err == nil
+}
--- a/lib/core/utils/ctx/ctx.go
+++ b/lib/core/utils/ctx/ctx.go
@@ -0,0 +1,133 @@
+package ctx
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+
+	"ems.agt/lib/core/vo"
+	"github.com/gorilla/mux"
+)
+
+// Param 地址栏参数{id}
+func Param(r *http.Request, key string) string {
+	vars := mux.Vars(r)
+	v, ok := vars[key]
+	if ok {
+		return v
+	}
+	return ""
+}
+
+// GetQuery 查询参数
+func GetQuery(r *http.Request, key string) string {
+	return r.URL.Query().Get(key)
+}
+
+// QueryMap 查询参数转换Map
+func QueryMap(r *http.Request) map[string]any {
+	queryValues := r.URL.Query()
+	queryParams := make(map[string]any)
+	for key, values := range queryValues {
+		queryParams[key] = values[0]
+	}
+	return queryParams
+}
+
+// 读取json请求结构团体
+func ShouldBindJSON(r *http.Request, args any) error {
+	body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20)) // 设置较大的长度，例如 1<<20 (1MB)
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(body, args)
+	return err
+}
+
+// JSON 相应json数据
+func JSON(w http.ResponseWriter, code int, data any) {
+	w.Header().Set("Content-Type", "application/json;charset=UTF-8")
+
+	response, err := json.Marshal(data)
+	if err != nil {
+		w.WriteHeader(500)
+		w.Write([]byte(err.Error()))
+	} else {
+		w.WriteHeader(code)
+		w.Write(response)
+	}
+}
+
+// 将文件导出到外部下载
+func FileAttachment(w http.ResponseWriter, r *http.Request, filepath, filename string) {
+	w.Header().Set("Content-Disposition", `attachment; filename=`+url.QueryEscape(filename))
+	w.Header().Set("Content-Type", "application/octet-stream")
+	http.ServeFile(w, r, filepath)
+}
+
+// 将文件上传保存到指定目录
+// file, handler, err := r.FormFile("file")
+// SaveUploadedFile uploads the form file to specific dst.
+func SaveUploadedFile(r *http.Request, dst string) error {
+	// 解析请求中的文件
+	_, handler, err := r.FormFile("file")
+	if err != nil {
+		return err
+	}
+
+	src, err := handler.Open()
+	if err != nil {
+		return err
+	}
+	defer src.Close()
+
+	if err = os.MkdirAll(filepath.Dir(dst), 0750); err != nil {
+		return err
+	}
+
+	out, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	_, err = io.Copy(out, src)
+	return err
+}
+
+/// ==== 登录用户信息， 通过中间件后预置入
+
+// 定义自定义类型作为键
+type ContextKey string
+
+// LoginUser 登录用户信息需要Authorize中间件
+func LoginUser(r *http.Request) (vo.LoginUser, error) {
+	// 上下文
+	v := r.Context().Value(ContextKey("LoginUser"))
+	if v != nil {
+		return v.(vo.LoginUser), nil
+	}
+	return vo.LoginUser{}, fmt.Errorf("无用户信息")
+}
+
+// LoginUserToUserID 登录用户信息-用户ID
+func LoginUserToUserID(r *http.Request) string {
+	loginUser, err := LoginUser(r)
+	if err != nil {
+		return ""
+	}
+	return loginUser.UserID
+}
+
+// LoginUserToUserName 登录用户信息-用户名称
+func LoginUserToUserName(r *http.Request) string {
+	loginUser, err := LoginUser(r)
+	if err != nil {
+		return ""
+	}
+	return loginUser.UserName
+}
--- a/lib/core/utils/date/date.go
+++ b/lib/core/utils/date/date.go
@@ -0,0 +1,70 @@
+package date
+
+import (
+	"fmt"
+	"time"
+
+	"ems.agt/lib/log"
+)
+
+const (
+	// 年 列如：2022
+	YYYY = "2006"
+	// 年-月 列如：2022-12
+	YYYY_MM = "2006-01"
+	// 年-月-日 列如：2022-12-30
+	YYYY_MM_DD = "2006-01-02"
+	// 年月日时分秒 列如：20221230010159
+	YYYYMMDDHHMMSS = "20060102150405"
+	// 年-月-日 时:分:秒 列如：2022-12-30 01:01:59
+	YYYY_MM_DD_HH_MM_SS = "2006-01-02 15:04:05"
+)
+
+// 格式时间字符串
+//
+// dateStr 时间字符串
+//
+// formatStr 时间格式 默认YYYY-MM-DD HH:mm:ss
+func ParseStrToDate(dateStr, formatStr string) time.Time {
+	t, err := time.Parse(formatStr, dateStr)
+	if err != nil {
+		log.Infof("utils ParseStrToDate err %v", err)
+		return time.Time{}
+	}
+	return t
+}
+
+// 格式时间
+//
+// date 可转的Date对象
+//
+// formatStr 时间格式 默认YYYY-MM-DD HH:mm:ss
+func ParseDateToStr(date any, formatStr string) string {
+	t, ok := date.(time.Time)
+	if !ok {
+		switch v := date.(type) {
+		case int64:
+			if v == 0 {
+				return ""
+			}
+			t = time.UnixMilli(v)
+		case string:
+			parsedTime, err := time.Parse(formatStr, v)
+			if err != nil {
+				fmt.Printf("utils ParseDateToStr err %v \n", err)
+				return ""
+			}
+			t = parsedTime
+		default:
+			return ""
+		}
+	}
+	return t.Format(formatStr)
+}
+
+// 格式时间成日期路径
+//
+// 年/月 列如：2022/12
+func ParseDatePath(date time.Time) string {
+	return date.Format("2006/01")
+}
--- a/lib/core/utils/firewall/client.go
+++ b/lib/core/utils/firewall/client.go
@@ -0,0 +1,34 @@
+package firewall
+
+import (
+	"errors"
+	"os"
+
+	"ems.agt/lib/core/utils/firewall/client"
+)
+
+type FirewallClient interface {
+	Name() string // ufw firewalld
+	Start() error
+	Stop() error
+	Reload() error
+	Status() (string, error) // running not running
+	Version() (string, error)
+
+	ListPort() ([]client.FireInfo, error)
+	ListAddress() ([]client.FireInfo, error)
+
+	Port(port client.FireInfo, operation string) error
+	RichRules(rule client.FireInfo, operation string) error
+	PortForward(info client.Forward, operation string) error
+}
+
+func NewFirewallClient() (FirewallClient, error) {
+	if _, err := os.Stat("/usr/sbin/firewalld"); err == nil {
+		return client.NewFirewalld()
+	}
+	if _, err := os.Stat("/usr/sbin/ufw"); err == nil {
+		return client.NewUfw()
+	}
+	return nil, errors.New("no such type")
+}
--- a/lib/core/utils/firewall/client/firewalld.go
+++ b/lib/core/utils/firewall/client/firewalld.go
@@ -0,0 +1,209 @@
+package client
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	"ems.agt/lib/core/cmd"
+)
+
+type Firewall struct{}
+
+func NewFirewalld() (*Firewall, error) {
+	return &Firewall{}, nil
+}
+
+func (f *Firewall) Name() string {
+	return "firewalld"
+}
+
+func (f *Firewall) Status() (string, error) {
+	stdout, _ := cmd.Exec("firewall-cmd --state")
+	if stdout == "running\n" {
+		return "running", nil
+	}
+	return "not running", nil
+}
+
+func (f *Firewall) Version() (string, error) {
+	stdout, err := cmd.Exec("firewall-cmd --version")
+	if err != nil {
+		return "", fmt.Errorf("load the firewall version failed, err: %s", stdout)
+	}
+	return strings.ReplaceAll(stdout, "\n ", ""), nil
+}
+
+func (f *Firewall) Start() error {
+	stdout, err := cmd.Exec("systemctl start firewalld")
+	if err != nil {
+		return fmt.Errorf("enable the firewall failed, err: %s", stdout)
+	}
+	return nil
+}
+
+func (f *Firewall) Stop() error {
+	stdout, err := cmd.Exec("systemctl stop firewalld")
+	if err != nil {
+		return fmt.Errorf("stop the firewall failed, err: %s", stdout)
+	}
+	return nil
+}
+
+func (f *Firewall) Reload() error {
+	stdout, err := cmd.Exec("firewall-cmd --reload")
+	if err != nil {
+		return fmt.Errorf("reload firewall failed, err: %s", stdout)
+	}
+	return nil
+}
+
+func (f *Firewall) ListPort() ([]FireInfo, error) {
+	var wg sync.WaitGroup
+	var datas []FireInfo
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		stdout, err := cmd.Exec("firewall-cmd --zone=public --list-ports")
+		if err != nil {
+			return
+		}
+		ports := strings.Split(strings.ReplaceAll(stdout, "\n", ""), " ")
+		for _, port := range ports {
+			if len(port) == 0 {
+				continue
+			}
+			var itemPort FireInfo
+			if strings.Contains(port, "/") {
+				itemPort.Port = strings.Split(port, "/")[0]
+				itemPort.Protocol = strings.Split(port, "/")[1]
+			}
+			itemPort.Strategy = "accept"
+			datas = append(datas, itemPort)
+		}
+	}()
+
+	go func() {
+		defer wg.Done()
+		stdout1, err := cmd.Exec("firewall-cmd --zone=public --list-rich-rules")
+		if err != nil {
+			return
+		}
+		rules := strings.Split(stdout1, "\n")
+		for _, rule := range rules {
+			if len(rule) == 0 {
+				continue
+			}
+			itemRule := f.loadInfo(rule)
+			if len(itemRule.Port) != 0 && itemRule.Family == "ipv4" {
+				datas = append(datas, itemRule)
+			}
+		}
+	}()
+	wg.Wait()
+	return datas, nil
+}
+
+func (f *Firewall) ListAddress() ([]FireInfo, error) {
+	stdout, err := cmd.Exec("firewall-cmd --zone=public --list-rich-rules")
+	if err != nil {
+		return nil, err
+	}
+	var datas []FireInfo
+	rules := strings.Split(stdout, "\n")
+	for _, rule := range rules {
+		if len(rule) == 0 {
+			continue
+		}
+		itemRule := f.loadInfo(rule)
+		if len(itemRule.Port) == 0 && len(itemRule.Address) != 0 {
+			datas = append(datas, itemRule)
+		}
+	}
+	return datas, nil
+}
+
+func (f *Firewall) Port(port FireInfo, operation string) error {
+	if cmd.CheckIllegal(operation, port.Protocol, port.Port) {
+		return fmt.Errorf("errCmdIllegal %v", port)
+	}
+
+	stdout, err := cmd.Execf("firewall-cmd --zone=public --%s-port=%s/%s --permanent", operation, port.Port, port.Protocol)
+	if err != nil {
+		return fmt.Errorf("%s port failed, err: %s", operation, stdout)
+	}
+	return nil
+}
+
+func (f *Firewall) RichRules(rule FireInfo, operation string) error {
+	if cmd.CheckIllegal(operation, rule.Address, rule.Protocol, rule.Port, rule.Strategy) {
+		return fmt.Errorf("errCmdIllegal %v", rule)
+	}
+	ruleStr := ""
+	if strings.Contains(rule.Address, "-") {
+		std, err := cmd.Execf("firewall-cmd --permanent --new-ipset=%s --type=hash:ip", rule.Address)
+		if err != nil {
+			return fmt.Errorf("add new ipset failed, err: %s", std)
+		}
+		std2, err := cmd.Execf("firewall-cmd --permanent --ipset=%s --add-entry=%s", rule.Address, rule.Address)
+		if err != nil {
+			return fmt.Errorf("add entry to ipset failed, err: %s", std2)
+		}
+		if err := f.Reload(); err != nil {
+			return err
+		}
+		ruleStr = fmt.Sprintf("rule source ipset=%s %s", rule.Address, rule.Strategy)
+	} else {
+		ruleStr = "rule family=ipv4 "
+		if len(rule.Address) != 0 {
+			ruleStr += fmt.Sprintf("source address=%s ", rule.Address)
+		}
+		if len(rule.Port) != 0 {
+			ruleStr += fmt.Sprintf("port port=%s ", rule.Port)
+		}
+		if len(rule.Protocol) != 0 {
+			ruleStr += fmt.Sprintf("protocol=%s ", rule.Protocol)
+		}
+		ruleStr += rule.Strategy
+	}
+	stdout, err := cmd.Execf("firewall-cmd --zone=public --%s-rich-rule '%s' --permanent", operation, ruleStr)
+	if err != nil {
+		return fmt.Errorf("%s rich rules failed, err: %s", operation, stdout)
+	}
+	return nil
+}
+
+func (f *Firewall) PortForward(info Forward, operation string) error {
+	ruleStr := fmt.Sprintf("firewall-cmd --%s-forward-port=port=%s:proto=%s:toport=%s --permanent", operation, info.Port, info.Protocol, info.Target)
+	if len(info.Address) != 0 {
+		ruleStr = fmt.Sprintf("firewall-cmd --%s-forward-port=port=%s:proto=%s:toaddr=%s:toport=%s --permanent", operation, info.Port, info.Protocol, info.Address, info.Target)
+	}
+
+	stdout, err := cmd.Exec(ruleStr)
+	if err != nil {
+		return fmt.Errorf("%s port forward failed, err: %s", operation, stdout)
+	}
+	return nil
+}
+
+func (f *Firewall) loadInfo(line string) FireInfo {
+	var itemRule FireInfo
+	ruleInfo := strings.Split(strings.ReplaceAll(line, "\"", ""), " ")
+	for _, item := range ruleInfo {
+		switch {
+		case strings.Contains(item, "family="):
+			itemRule.Family = strings.ReplaceAll(item, "family=", "")
+		case strings.Contains(item, "ipset="):
+			itemRule.Address = strings.ReplaceAll(item, "ipset=", "")
+		case strings.Contains(item, "address="):
+			itemRule.Address = strings.ReplaceAll(item, "address=", "")
+		case strings.Contains(item, "port="):
+			itemRule.Port = strings.ReplaceAll(item, "port=", "")
+		case strings.Contains(item, "protocol="):
+			itemRule.Protocol = strings.ReplaceAll(item, "protocol=", "")
+		case item == "accept" || item == "drop" || item == "reject":
+			itemRule.Strategy = item
+		}
+	}
+	return itemRule
+}
--- a/lib/core/utils/firewall/client/info.go
+++ b/lib/core/utils/firewall/client/info.go
@@ -0,0 +1,20 @@
+package client
+
+type FireInfo struct {
+	Family   string `json:"family"`  // ipv4 ipv6
+	Address  string `json:"address"` // Anywhere
+	Port     string `json:"port"`
+	Protocol string `json:"protocol"` // tcp udp tcp/udp
+	Strategy string `json:"strategy"` // accept drop
+
+	APPName     string `json:"appName"`
+	IsUsed      bool   `json:"isUsed"`
+	Description string `json:"description"`
+}
+
+type Forward struct {
+	Protocol string `json:"protocol"`
+	Address  string `json:"address"`
+	Port     string `json:"port"`
+	Target   string `json:"target"`
+}
--- a/lib/core/utils/firewall/client/ufw.go
+++ b/lib/core/utils/firewall/client/ufw.go
@@ -0,0 +1,238 @@
+package client
+
+import (
+	"fmt"
+	"strings"
+
+	"ems.agt/lib/core/cmd"
+)
+
+type Ufw struct {
+	CmdStr string
+}
+
+func NewUfw() (*Ufw, error) {
+	var ufw Ufw
+	if cmd.HasNoPasswordSudo() {
+		ufw.CmdStr = "sudo ufw"
+	} else {
+		ufw.CmdStr = "ufw"
+	}
+	return &ufw, nil
+}
+
+func (f *Ufw) Name() string {
+	return "ufw"
+}
+
+func (f *Ufw) Status() (string, error) {
+	stdout, _ := cmd.Execf("%s status | grep Status", f.CmdStr)
+	if stdout == "Status: active\n" {
+		return "running", nil
+	}
+	stdout1, _ := cmd.Execf("%s status | grep 状态", f.CmdStr)
+	if stdout1 == "状态： 激活\n" {
+		return "running", nil
+	}
+	return "not running", nil
+}
+
+func (f *Ufw) Version() (string, error) {
+	stdout, err := cmd.Execf("%s version | grep ufw", f.CmdStr)
+	if err != nil {
+		return "", fmt.Errorf("load the firewall status failed, err: %s", stdout)
+	}
+	info := strings.ReplaceAll(stdout, "\n", "")
+	return strings.ReplaceAll(info, "ufw ", ""), nil
+}
+
+func (f *Ufw) Start() error {
+	stdout, err := cmd.Execf("echo y | %s enable", f.CmdStr)
+	if err != nil {
+		return fmt.Errorf("enable the firewall failed, err: %s", stdout)
+	}
+	return nil
+}
+
+func (f *Ufw) Stop() error {
+	stdout, err := cmd.Execf("%s disable", f.CmdStr)
+	if err != nil {
+		return fmt.Errorf("stop the firewall failed, err: %s", stdout)
+	}
+	return nil
+}
+
+func (f *Ufw) Reload() error {
+	return nil
+}
+
+func (f *Ufw) ListPort() ([]FireInfo, error) {
+	stdout, err := cmd.Execf("%s status verbose", f.CmdStr)
+	if err != nil {
+		return nil, err
+	}
+	portInfos := strings.Split(stdout, "\n")
+	var datas []FireInfo
+	isStart := false
+	for _, line := range portInfos {
+		if strings.HasPrefix(line, "-") {
+			isStart = true
+			continue
+		}
+		if !isStart {
+			continue
+		}
+		itemFire := f.loadInfo(line, "port")
+		if len(itemFire.Port) != 0 && itemFire.Port != "Anywhere" && !strings.Contains(itemFire.Port, ".") {
+			itemFire.Port = strings.ReplaceAll(itemFire.Port, ":", "-")
+			datas = append(datas, itemFire)
+		}
+	}
+	return datas, nil
+}
+
+func (f *Ufw) ListAddress() ([]FireInfo, error) {
+	stdout, err := cmd.Execf("%s status verbose", f.CmdStr)
+	if err != nil {
+		return nil, err
+	}
+	portInfos := strings.Split(stdout, "\n")
+	var datas []FireInfo
+	isStart := false
+	for _, line := range portInfos {
+		if strings.HasPrefix(line, "-") {
+			isStart = true
+			continue
+		}
+		if !isStart {
+			continue
+		}
+		if !strings.Contains(line, " IN") {
+			continue
+		}
+		itemFire := f.loadInfo(line, "address")
+		if strings.Contains(itemFire.Port, ".") {
+			itemFire.Address += ("-" + itemFire.Port)
+			itemFire.Port = ""
+		}
+		if len(itemFire.Port) == 0 && len(itemFire.Address) != 0 {
+			datas = append(datas, itemFire)
+		}
+	}
+	return datas, nil
+}
+
+func (f *Ufw) Port(port FireInfo, operation string) error {
+	switch port.Strategy {
+	case "accept":
+		port.Strategy = "allow"
+	case "drop":
+		port.Strategy = "deny"
+	default:
+		return fmt.Errorf("unsupport strategy %s", port.Strategy)
+	}
+	if cmd.CheckIllegal(port.Protocol, port.Port) {
+		return fmt.Errorf("errCmdIllegal %v", port)
+	}
+
+	command := fmt.Sprintf("%s %s %s", f.CmdStr, port.Strategy, port.Port)
+	if operation == "remove" {
+		command = fmt.Sprintf("%s delete %s %s", f.CmdStr, port.Strategy, port.Port)
+	}
+	if len(port.Protocol) != 0 {
+		command += fmt.Sprintf("/%s", port.Protocol)
+	}
+	stdout, err := cmd.Exec(command)
+	if err != nil {
+		return fmt.Errorf("%s port failed, err: %s", operation, stdout)
+	}
+	return nil
+}
+
+func (f *Ufw) RichRules(rule FireInfo, operation string) error {
+	switch rule.Strategy {
+	case "accept":
+		rule.Strategy = "allow"
+	case "drop":
+		rule.Strategy = "deny"
+	default:
+		return fmt.Errorf("unsupport strategy %s", rule.Strategy)
+	}
+
+	if cmd.CheckIllegal(operation, rule.Protocol, rule.Address, rule.Port) {
+		return fmt.Errorf("errCmdIllegal %v", rule)
+	}
+
+	ruleStr := fmt.Sprintf("%s %s ", f.CmdStr, rule.Strategy)
+	if operation == "remove" {
+		ruleStr = fmt.Sprintf("%s delete %s ", f.CmdStr, rule.Strategy)
+	}
+	if len(rule.Protocol) != 0 {
+		ruleStr += fmt.Sprintf("proto %s ", rule.Protocol)
+	}
+	if strings.Contains(rule.Address, "-") {
+		ruleStr += fmt.Sprintf("from %s to %s ", strings.Split(rule.Address, "-")[0], strings.Split(rule.Address, "-")[1])
+	} else {
+		ruleStr += fmt.Sprintf("from %s ", rule.Address)
+	}
+	if len(rule.Port) != 0 {
+		ruleStr += fmt.Sprintf("to any port %s ", rule.Port)
+	}
+
+	stdout, err := cmd.Exec(ruleStr)
+	if err != nil {
+		return fmt.Errorf("%s rich rules failed, err: %s", operation, stdout)
+	}
+	return nil
+}
+
+func (f *Ufw) PortForward(info Forward, operation string) error {
+	ruleStr := fmt.Sprintf("firewall-cmd --%s-forward-port=port=%s:proto=%s:toport=%s --permanent", operation, info.Port, info.Protocol, info.Target)
+	if len(info.Address) != 0 {
+		ruleStr = fmt.Sprintf("firewall-cmd --%s-forward-port=port=%s:proto=%s:toaddr=%s:toport=%s --permanent", operation, info.Port, info.Protocol, info.Address, info.Target)
+	}
+
+	stdout, err := cmd.Exec(ruleStr)
+	if err != nil {
+		return fmt.Errorf("%s port forward failed, err: %s", operation, stdout)
+	}
+	if err := f.Reload(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (f *Ufw) loadInfo(line string, fireType string) FireInfo {
+	fields := strings.Fields(line)
+	var itemInfo FireInfo
+	if len(fields) < 4 {
+		return itemInfo
+	}
+	if fields[1] == "(v6)" {
+		return itemInfo
+	}
+	if fields[0] == "Anywhere" && fireType != "port" {
+		itemInfo.Strategy = "drop"
+		if fields[1] == "ALLOW" {
+			itemInfo.Strategy = "accept"
+		}
+		itemInfo.Address = fields[3]
+		return itemInfo
+	}
+	if strings.Contains(fields[0], "/") {
+		itemInfo.Port = strings.Split(fields[0], "/")[0]
+		itemInfo.Protocol = strings.Split(fields[0], "/")[1]
+	} else {
+		itemInfo.Port = fields[0]
+		itemInfo.Protocol = "tcp/udp"
+	}
+	itemInfo.Family = "ipv4"
+	if fields[1] == "ALLOW" {
+		itemInfo.Strategy = "accept"
+	} else {
+		itemInfo.Strategy = "drop"
+	}
+	itemInfo.Address = fields[3]
+
+	return itemInfo
+}
--- a/lib/core/utils/parse/parse.go
+++ b/lib/core/utils/parse/parse.go
@@ -0,0 +1,139 @@
+package parse
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/robfig/cron/v3"
+)
+
+// Number 解析数值型
+func Number(str any) int64 {
+	switch str := str.(type) {
+	case string:
+		if str == "" {
+			return 0
+		}
+		num, err := strconv.ParseInt(str, 10, 64)
+		if err != nil {
+			return 0
+		}
+		return num
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
+		return reflect.ValueOf(str).Int()
+	case float32, float64:
+		return int64(reflect.ValueOf(str).Float())
+	default:
+		return 0
+	}
+}
+
+// Boolean 解析布尔型
+func Boolean(str any) bool {
+	switch str := str.(type) {
+	case string:
+		if str == "" || str == "false" || str == "0" {
+			return false
+		}
+		// 尝试将字符串解析为数字
+		if num, err := strconv.ParseFloat(str, 64); err == nil {
+			return num != 0
+		}
+		return true
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
+		num := reflect.ValueOf(str).Int()
+		return num != 0
+	case float32, float64:
+		num := reflect.ValueOf(str).Float()
+		return num != 0
+	default:
+		return false
+	}
+}
+
+// FirstUpper 首字母转大写
+//
+// 字符串 abc_123!@# 结果 Abc_123
+func FirstUpper(str string) string {
+	if len(str) == 0 {
+		return str
+	}
+	reg := regexp.MustCompile(`[^_\w]+`)
+	str = reg.ReplaceAllString(str, "")
+	return strings.ToUpper(str[:1]) + str[1:]
+}
+
+// Bit 比特位为单位
+func Bit(bit float64) string {
+	var GB, MB, KB string
+
+	if bit > float64(1<<30) {
+		GB = fmt.Sprintf("%0.2f", bit/(1<<30))
+	}
+
+	if bit > float64(1<<20) && bit < (1<<30) {
+		MB = fmt.Sprintf("%.2f", bit/(1<<20))
+	}
+
+	if bit > float64(1<<10) && bit < (1<<20) {
+		KB = fmt.Sprintf("%.2f", bit/(1<<10))
+	}
+
+	if GB != "" {
+		return GB + "GB"
+	} else if MB != "" {
+		return MB + "MB"
+	} else if KB != "" {
+		return KB + "KB"
+	} else {
+		return fmt.Sprintf("%vB", bit)
+	}
+}
+
+// CronExpression 解析 Cron 表达式，返回下一次执行的时间戳（毫秒）
+//
+// 【*/5 * * * * ?】 6个参数
+func CronExpression(expression string) int64 {
+	specParser := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)
+	schedule, err := specParser.Parse(expression)
+	if err != nil {
+		fmt.Println(err)
+		return 0
+	}
+	return schedule.Next(time.Now()).UnixMilli()
+}
+
+// SafeContent 内容值进行安全掩码
+func SafeContent(value string) string {
+	if len(value) < 3 {
+		return strings.Repeat("*", len(value))
+	} else if len(value) < 6 {
+		return string(value[0]) + strings.Repeat("*", len(value)-1)
+	} else if len(value) < 10 {
+		return string(value[0]) + strings.Repeat("*", len(value)-2) + string(value[len(value)-1])
+	} else if len(value) < 15 {
+		return value[:2] + strings.Repeat("*", len(value)-4) + value[len(value)-2:]
+	} else {
+		return value[:3] + strings.Repeat("*", len(value)-6) + value[len(value)-3:]
+	}
+}
+
+// RemoveDuplicates 数组内字符串去重
+func RemoveDuplicates(ids []string) []string {
+	uniqueIDs := make(map[string]bool)
+	uniqueIDSlice := make([]string, 0)
+
+	for _, id := range ids {
+		_, ok := uniqueIDs[id]
+		if !ok && id != "" {
+			uniqueIDs[id] = true
+			uniqueIDSlice = append(uniqueIDSlice, id)
+		}
+	}
+
+	return uniqueIDSlice
+}
--- a/lib/core/utils/regular/regular.go
+++ b/lib/core/utils/regular/regular.go
@@ -0,0 +1,54 @@
+package regular
+
+import (
+	"regexp"
+)
+
+// Replace 正则替换
+func Replace(originStr, pattern, repStr string) string {
+	regex := regexp.MustCompile(pattern)
+	return regex.ReplaceAllString(originStr, repStr)
+}
+
+// 判断是否为有效用户名格式
+//
+// 用户名不能以数字开头，可包含大写小写字母，数字，且不少于5位
+func ValidUsername(username string) bool {
+	if username == "" {
+		return false
+	}
+	pattern := `^[a-zA-Z][a-z0-9A-Z]{5,}`
+	match, err := regexp.MatchString(pattern, username)
+	if err != nil {
+		return false
+	}
+	return match
+}
+
+// 判断是否为有效手机号格式，1开头的11位手机号
+func ValidMobile(mobile string) bool {
+	if mobile == "" {
+		return false
+	}
+	pattern := `^1[3|4|5|6|7|8|9][0-9]\d{8}$`
+	match, err := regexp.MatchString(pattern, mobile)
+	if err != nil {
+		return false
+	}
+	return match
+}
+
+// 判断是否为http(s)://开头
+//
+// link 网络链接
+func ValidHttp(link string) bool {
+	if link == "" {
+		return false
+	}
+	pattern := `^http(s)?:\/\/+`
+	match, err := regexp.MatchString(pattern, link)
+	if err != nil {
+		return false
+	}
+	return match
+}
--- a/lib/core/utils/scan/scan.go
+++ b/lib/core/utils/scan/scan.go
@@ -0,0 +1,31 @@
+package scan
+
+import (
+	"net"
+	"strconv"
+)
+
+func ScanPort(port int) bool {
+	ln, err := net.Listen("tcp", ":"+strconv.Itoa(port))
+	if err != nil {
+		return true
+	}
+	defer ln.Close()
+	return false
+}
+
+func ScanUDPPort(port int) bool {
+	ln, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: port})
+	if err != nil {
+		return true
+	}
+	defer ln.Close()
+	return false
+}
+
+func ScanPortWithProto(port int, proto string) bool {
+	if proto == "udp" {
+		return ScanUDPPort(port)
+	}
+	return ScanPort(port)
+}
--- a/lib/core/vo/login_user.go
+++ b/lib/core/vo/login_user.go
@@ -0,0 +1,28 @@
+package vo
+
+import (
+	"ems.agt/lib/dborm"
+)
+
+// LoginUser 登录用户身份权限信息对象
+type LoginUser struct {
+	// UserID 用户ID
+	UserID string `json:"userId"`
+
+	// UserName 用户名
+	UserName string `json:"userName"`
+
+	// LoginTime 登录时间时间戳
+	LoginTime int64 `json:"loginTime"`
+
+	// ExpireTime 过期时间时间戳
+	ExpireTime int64 `json:"expireTime"`
+
+	// Permissions 权限列表
+	Permissions []string `json:"permissions"`
+
+	// User 用户信息
+	User dborm.User `json:"user"`
+
+	Session dborm.Session `json:"-"`
+}
--- a/lib/core/vo/result/result.go
+++ b/lib/core/vo/result/result.go
@@ -0,0 +1,72 @@
+package result
+
+const CODE_ERROR = 0
+const MSG_ERROR = "error"
+const CODE_SUCCESS = 1
+const MSG_SUCCESS = "success"
+
+// CodeMsg 响应结果
+func CodeMsg(code int, msg string) map[string]any {
+	args := make(map[string]any)
+	args["code"] = code
+	args["msg"] = msg
+	return args
+}
+
+// 响应成功结果 map[string]any{}
+func Ok(v map[string]any) map[string]any {
+	args := make(map[string]any)
+	args["code"] = CODE_SUCCESS
+	args["msg"] = MSG_SUCCESS
+	// v合并到args
+	for key, value := range v {
+		args[key] = value
+	}
+	return args
+}
+
+// 响应成功结果信息
+func OkMsg(msg string) map[string]any {
+	args := make(map[string]any)
+	args["code"] = CODE_SUCCESS
+	args["msg"] = msg
+	return args
+}
+
+// 响应成功结果数据
+func OkData(data any) map[string]any {
+	args := make(map[string]any)
+	args["code"] = CODE_SUCCESS
+	args["msg"] = MSG_SUCCESS
+	args["data"] = data
+	return args
+}
+
+// 响应失败结果 map[string]any{}
+func Err(v map[string]any) map[string]any {
+	args := make(map[string]any)
+	args["code"] = CODE_ERROR
+	args["msg"] = MSG_ERROR
+	// v合并到args
+	for key, value := range v {
+		args[key] = value
+	}
+	return args
+}
+
+// 响应失败结果信息
+func ErrMsg(msg string) map[string]any {
+	args := make(map[string]any)
+	args["code"] = CODE_ERROR
+	args["msg"] = msg
+	return args
+}
+
+// 响应失败结果数据
+func ErrData(data any) map[string]any {
+	args := make(map[string]any)
+	args["code"] = CODE_ERROR
+	args["msg"] = MSG_ERROR
+	args["data"] = data
+	return args
+}
--- a/lib/core/vo/router.go
+++ b/lib/core/vo/router.go
@@ -0,0 +1,17 @@
+package vo
+
+// Router 路由信息对象
+type Router struct {
+	// 路由名字 英文首字母大写
+	Name string `json:"name"`
+	// 路由地址
+	Path string `json:"path"`
+	// 其他元素
+	Meta RouterMeta `json:"meta"`
+	// 组件地址
+	Component string `json:"component"`
+	// 重定向地址
+	Redirect string `json:"redirect"`
+	// 子路由
+	Children []Router `json:"children,omitempty"`
+}
--- a/lib/core/vo/router_meta.go
+++ b/lib/core/vo/router_meta.go
@@ -0,0 +1,17 @@
+package vo
+
+// RouterMeta 路由元信息对象
+type RouterMeta struct {
+	// 设置该菜单在侧边栏和面包屑中展示的名字
+	Title string `json:"title"`
+	// 设置该菜单的图标
+	Icon string `json:"icon"`
+	// 设置为true，则不会被 <keep-alive>缓存
+	Cache bool `json:"cache"`
+	// 内链地址（http(s)://开头）, 打开目标位置 '_blank' | '_self' | ''
+	Target string `json:"target"`
+	// 在菜单中隐藏子节点
+	HideChildInMenu bool `json:"hideChildInMenu"`
+	// 在菜单中隐藏自己和子节点
+	HideInMenu bool `json:"hideInMenu"`
+}
--- a/lib/core/vo/treeselect.go
+++ b/lib/core/vo/treeselect.go
@@ -0,0 +1,36 @@
+package vo
+
+// import sysmenu "ems.agt/features/sys_menu"
+
+// TreeSelect 树结构实体类
+type TreeSelect struct {
+	// ID 节点ID
+	ID string `json:"id"`
+
+	// Label 节点名称
+	Label string `json:"label"`
+
+	// Title 节点名称旧版本layui
+	Title string `json:"title"`
+
+	// Children 子节点
+	Children []TreeSelect `json:"children"`
+}
+
+// // SysMenuTreeSelect 使用给定的 SysMenu 对象解析为 TreeSelect 对象
+// func SysMenuTreeSelect(sysMenu sysmenu.SysMenu) TreeSelect {
+// 	t := TreeSelect{}
+// 	t.ID = sysMenu.MenuID
+// 	t.Label = sysMenu.MenuName
+
+// 	if len(sysMenu.Children) > 0 {
+// 		for _, menu := range sysMenu.Children {
+// 			child := SysMenuTreeSelect(menu)
+// 			t.Children = append(t.Children, child)
+// 		}
+// 	} else {
+// 		t.Children = []TreeSelect{}
+// 	}
+
+// 	return t
+// }