refactor: 更新项目引用路径从perfect-panel/ppanel-server到perfect-panel/server

feat: 添加版本和构建时间变量
fix: 修正短信队列类型注释错误
style: 清理未使用的代码和测试文件
docs: 更新安装文档中的下载链接
chore: 迁移数据库脚本添加日志和订阅配置

internal/model/node/cache.go

@@ -0,0 +1,163 @@
+package node
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/redis/go-redis/v9"
+)
+
+type (
+	customCacheLogicModel interface {
+		StatusCache(ctx context.Context, serverId int64) (Status, error)
+		UpdateStatusCache(ctx context.Context, serverId int64, status *Status) error
+		OnlineUserSubscribe(ctx context.Context, serverId int64, protocol string) (OnlineUserSubscribe, error)
+		UpdateOnlineUserSubscribe(ctx context.Context, serverId int64, protocol string, subscribe OnlineUserSubscribe) error
+		OnlineUserSubscribeGlobal(ctx context.Context) (int64, error)
+		UpdateOnlineUserSubscribeGlobal(ctx context.Context, subscribe OnlineUserSubscribe) error
+	}
+
+	Status struct {
+		Cpu       float64 `json:"cpu"`
+		Mem       float64 `json:"mem"`
+		Disk      float64 `json:"disk"`
+		UpdatedAt int64   `json:"updated_at"`
+	}
+
+	OnlineUserSubscribe map[int64][]string
+)
+
+// Marshal  to json string
+func (s *Status) Marshal() string {
+	type Alias Status
+	data, _ := json.Marshal(&struct {
+		*Alias
+	}{
+		Alias: (*Alias)(s),
+	})
+	return string(data)
+}
+
+// Unmarshal from json string
+func (s *Status) Unmarshal(data string) error {
+	type Alias Status
+	aux := &struct {
+		*Alias
+	}{
+		Alias: (*Alias)(s),
+	}
+	return json.Unmarshal([]byte(data), &aux)
+}
+
+const (
+	Expiry                                = 300 * time.Second              // Cache expiry time in seconds
+	StatusCacheKey                        = "node:status:%d"               // Node status cache key format (Server ID and protocol) Example: node:status:1:shadowsocks
+	OnlineUserCacheKeyWithSubscribe       = "node:online:subscribe:%d:%s"  // Online user subscribe cache key format (Server ID and protocol) Example: node:online:subscribe:1:shadowsocks
+	OnlineUserSubscribeCacheKeyWithGlobal = "node:online:subscribe:global" // Online user global subscribe cache key
+)
+
+// UpdateStatusCache Update server status to cache
+func (m *customServerModel) UpdateStatusCache(ctx context.Context, serverId int64, status *Status) error {
+	key := fmt.Sprintf(StatusCacheKey, serverId)
+	return m.Cache.Set(ctx, key, status.Marshal(), Expiry).Err()
+
+}
+
+// DeleteStatusCache Delete server status from cache
+func (m *customServerModel) DeleteStatusCache(ctx context.Context, serverId int64) error {
+	key := fmt.Sprintf(StatusCacheKey, serverId)
+	return m.Cache.Del(ctx, key).Err()
+}
+
+// StatusCache Get server status from cache
+func (m *customServerModel) StatusCache(ctx context.Context, serverId int64) (Status, error) {
+	var status Status
+	key := fmt.Sprintf(StatusCacheKey, serverId)
+
+	result, err := m.Cache.Get(ctx, key).Result()
+	if err != nil {
+		if errors.Is(err, redis.Nil) {
+			return status, nil
+		}
+		return status, err
+	}
+	if result == "" {
+		return status, nil
+	}
+	err = status.Unmarshal(result)
+	return status, err
+}
+
+// OnlineUserSubscribe Get online user subscribe
+func (m *customServerModel) OnlineUserSubscribe(ctx context.Context, serverId int64, protocol string) (OnlineUserSubscribe, error) {
+	key := fmt.Sprintf(OnlineUserCacheKeyWithSubscribe, serverId, protocol)
+	result, err := m.Cache.Get(ctx, key).Result()
+	if err != nil {
+		if errors.Is(err, redis.Nil) {
+			return OnlineUserSubscribe{}, nil
+		}
+		return nil, err
+	}
+	if result == "" {
+		return OnlineUserSubscribe{}, nil
+	}
+	var subscribe OnlineUserSubscribe
+	err = json.Unmarshal([]byte(result), &subscribe)
+	return subscribe, err
+}
+
+// UpdateOnlineUserSubscribe Update online user subscribe
+func (m *customServerModel) UpdateOnlineUserSubscribe(ctx context.Context, serverId int64, protocol string, subscribe OnlineUserSubscribe) error {
+	key := fmt.Sprintf(OnlineUserCacheKeyWithSubscribe, serverId, protocol)
+	data, err := json.Marshal(subscribe)
+	if err != nil {
+		return err
+	}
+	return m.Cache.Set(ctx, key, data, Expiry).Err()
+}
+
+// DeleteOnlineUserSubscribe Delete online user subscribe
+func (m *customServerModel) DeleteOnlineUserSubscribe(ctx context.Context, serverId int64, protocol string) error {
+	key := fmt.Sprintf(OnlineUserCacheKeyWithSubscribe, serverId, protocol)
+	return m.Cache.Del(ctx, key).Err()
+}
+
+// OnlineUserSubscribeGlobal Get global online user subscribe count
+func (m *customServerModel) OnlineUserSubscribeGlobal(ctx context.Context) (int64, error) {
+	now := time.Now().Unix()
+	// Clear expired data
+	if err := m.Cache.ZRemRangeByScore(ctx, OnlineUserSubscribeCacheKeyWithGlobal, "-inf", fmt.Sprintf("%d", now)).Err(); err != nil {
+		return 0, err
+	}
+	return m.Cache.ZCard(ctx, OnlineUserSubscribeCacheKeyWithGlobal).Result()
+}
+
+// UpdateOnlineUserSubscribeGlobal Update global online user subscribe count
+func (m *customServerModel) UpdateOnlineUserSubscribeGlobal(ctx context.Context, subscribe OnlineUserSubscribe) error {
+	now := time.Now()
+	expireTime := now.Add(5 * time.Minute).Unix() // set expire time 5 minutes later
+
+	pipe := m.Cache.Pipeline()
+
+	// Clear expired data
+	pipe.ZRemRangeByScore(ctx, OnlineUserSubscribeCacheKeyWithGlobal, "-inf", fmt.Sprintf("%d", now.Unix()))
+	// Add or update each subscribe with new expire time
+	for sub := range subscribe {
+		// Use ZAdd to add or update the member with new score (expire time)
+		pipe.ZAdd(ctx, OnlineUserSubscribeCacheKeyWithGlobal, redis.Z{
+			Score:  float64(expireTime),
+			Member: sub,
+		})
+	}
+
+	_, err := pipe.Exec(ctx)
+	return err
+}
+
+// DeleteOnlineUserSubscribeGlobal Delete global online user subscribe count
+func (m *customServerModel) DeleteOnlineUserSubscribeGlobal(ctx context.Context) error {
+	return m.Cache.Del(ctx, OnlineUserSubscribeCacheKeyWithGlobal).Err()
+}

internal/model/node/default.go

@@ -0,0 +1,131 @@
+package node
+
+import (
+	"context"
+
+	"github.com/redis/go-redis/v9"
+	"gorm.io/gorm"
+)
+
+var _ Model = (*customServerModel)(nil)
+
+//goland:noinspection GoNameStartsWithPackageName
+type (
+	Model interface {
+		serverModel
+		NodeModel
+		customCacheLogicModel
+		customServerLogicModel
+	}
+	serverModel interface {
+		InsertServer(ctx context.Context, data *Server, tx ...*gorm.DB) error
+		FindOneServer(ctx context.Context, id int64) (*Server, error)
+		UpdateServer(ctx context.Context, data *Server, tx ...*gorm.DB) error
+		DeleteServer(ctx context.Context, id int64, tx ...*gorm.DB) error
+		Transaction(ctx context.Context, fn func(db *gorm.DB) error) error
+	}
+
+	NodeModel interface {
+		InsertNode(ctx context.Context, data *Node, tx ...*gorm.DB) error
+		FindOneNode(ctx context.Context, id int64) (*Node, error)
+		UpdateNode(ctx context.Context, data *Node, tx ...*gorm.DB) error
+		DeleteNode(ctx context.Context, id int64, tx ...*gorm.DB) error
+	}
+
+	customServerModel struct {
+		*defaultServerModel
+	}
+	defaultServerModel struct {
+		*gorm.DB
+		Cache *redis.Client
+	}
+)
+
+func newServerModel(db *gorm.DB, cache *redis.Client) *defaultServerModel {
+	return &defaultServerModel{
+		DB:    db,
+		Cache: cache,
+	}
+}
+
+// NewModel returns a model for the database table.
+func NewModel(conn *gorm.DB, cache *redis.Client) Model {
+	return &customServerModel{
+		defaultServerModel: newServerModel(conn, cache),
+	}
+}
+
+func (m *defaultServerModel) InsertServer(ctx context.Context, data *Server, tx ...*gorm.DB) error {
+	db := m.DB
+	if len(tx) > 0 {
+		db = tx[0]
+	}
+	return db.WithContext(ctx).Create(data).Error
+}
+
+func (m *defaultServerModel) FindOneServer(ctx context.Context, id int64) (*Server, error) {
+	var server Server
+	err := m.WithContext(ctx).Model(&Server{}).Where("id = ?", id).First(&server).Error
+	return &server, err
+}
+
+func (m *defaultServerModel) UpdateServer(ctx context.Context, data *Server, tx ...*gorm.DB) error {
+	_, err := m.FindOneServer(ctx, data.Id)
+	if err != nil {
+		return err
+	}
+
+	db := m.DB
+	if len(tx) > 0 {
+		db = tx[0]
+	}
+	return db.WithContext(ctx).Where("`id` = ?", data.Id).Save(data).Error
+
+}
+
+func (m *defaultServerModel) DeleteServer(ctx context.Context, id int64, tx ...*gorm.DB) error {
+	db := m.DB
+	if len(tx) > 0 {
+		db = tx[0]
+	}
+	return db.WithContext(ctx).Where("`id` = ?", id).Delete(&Server{}).Error
+}
+
+func (m *defaultServerModel) InsertNode(ctx context.Context, data *Node, tx ...*gorm.DB) error {
+	db := m.DB
+	if len(tx) > 0 {
+		db = tx[0]
+	}
+	return db.WithContext(ctx).Create(data).Error
+}
+
+func (m *defaultServerModel) FindOneNode(ctx context.Context, id int64) (*Node, error) {
+	var node Node
+	err := m.WithContext(ctx).Model(&Node{}).Where("id = ?", id).First(&node).Error
+	return &node, err
+}
+
+func (m *defaultServerModel) UpdateNode(ctx context.Context, data *Node, tx ...*gorm.DB) error {
+	_, err := m.FindOneNode(ctx, data.Id)
+	if err != nil {
+		return err
+	}
+
+	db := m.DB
+	if len(tx) > 0 {
+		db = tx[0]
+	}
+	return db.WithContext(ctx).Where("`id` = ?", data.Id).Save(data).Error
+}
+
+func (m *defaultServerModel) DeleteNode(ctx context.Context, id int64, tx ...*gorm.DB) error {
+	db := m.DB
+	if len(tx) > 0 {
+		db = tx[0]
+	}
+	return db.WithContext(ctx).Where("`id` = ?", id).Delete(&Node{}).Error
+}
+
+func (m *defaultServerModel) Transaction(ctx context.Context, fn func(db *gorm.DB) error) error {
+	return m.WithContext(ctx).Transaction(fn)
+}

internal/model/node/model.go

@@ -0,0 +1,185 @@
+package node
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/perfect-panel/server/pkg/tool"
+	"gorm.io/gorm"
+)
+
+type customServerLogicModel interface {
+	FilterServerList(ctx context.Context, params *FilterParams) (int64, []*Server, error)
+	FilterNodeList(ctx context.Context, params *FilterNodeParams) (int64, []*Node, error)
+	ClearNodeCache(ctx context.Context, params *FilterNodeParams) error
+}
+
+const (
+	// ServerUserListCacheKey Server User List Cache Key
+	ServerUserListCacheKey = "server:user:"
+
+	// ServerConfigCacheKey Server Config Cache Key
+	ServerConfigCacheKey = "server:config:"
+)
+
+// FilterParams Filter Server Params
+type FilterParams struct {
+	Page   int
+	Size   int
+	Ids    []int64 // Server IDs
+	Search string
+}
+
+type FilterNodeParams struct {
+	Page     int      // Page Number
+	Size     int      // Page Size
+	NodeId   []int64  // Node IDs
+	ServerId []int64  // Server IDs
+	Tag      []string // Tags
+	Search   string   // Search Address or Name
+	Protocol string   // Protocol
+	Preload  bool     // Preload Server
+	Enabled  *bool    // Enabled
+}
+
+// FilterServerList Filter Server List
+func (m *customServerModel) FilterServerList(ctx context.Context, params *FilterParams) (int64, []*Server, error) {
+	var servers []*Server
+	var total int64
+	query := m.WithContext(ctx).Model(&Server{})
+	if params == nil {
+		params = &FilterParams{
+			Page: 1,
+			Size: 10,
+		}
+	}
+	if params.Search != "" {
+		s := "%" + params.Search + "%"
+		query = query.Where("`name` LIKE ? OR `address` LIKE ?", s, s)
+	}
+	if len(params.Ids) > 0 {
+		query = query.Where("id IN ?", params.Ids)
+	}
+	err := query.Count(&total).Order("sort ASC").Limit(params.Size).Offset((params.Page - 1) * params.Size).Find(&servers).Error
+	return total, servers, err
+}
+
+// FilterNodeList Filter Node List
+func (m *customServerModel) FilterNodeList(ctx context.Context, params *FilterNodeParams) (int64, []*Node, error) {
+	var nodes []*Node
+	var total int64
+	query := m.WithContext(ctx).Model(&Node{})
+	if params == nil {
+		params = &FilterNodeParams{
+			Page: 1,
+			Size: 10,
+		}
+	}
+	if params.Search != "" {
+		s := "%" + params.Search + "%"
+		query = query.Where("`name` LIKE ? OR `address` LIKE ? OR `tags` LIKE ? OR `port` LIKE ? ", s, s, s, s)
+	}
+	if len(params.NodeId) > 0 {
+		query = query.Where("id IN ?", params.NodeId)
+	}
+	if len(params.ServerId) > 0 {
+		query = query.Where("server_id IN ?", params.ServerId)
+	}
+	if len(params.Tag) > 0 {
+		query = query.Scopes(InSet("tags", params.Tag))
+	}
+	if params.Protocol != "" {
+		query = query.Where("protocol = ?", params.Protocol)
+	}
+
+	if params.Enabled != nil {
+		query = query.Where("enabled = ?", *params.Enabled)
+	}
+
+	if params.Preload {
+		query = query.Preload("Server")
+	}
+
+	err := query.Count(&total).Order("sort ASC").Limit(params.Size).Offset((params.Page - 1) * params.Size).Find(&nodes).Error
+	return total, nodes, err
+}
+
+// ClearNodeCache Clear Node Cache
+func (m *customServerModel) ClearNodeCache(ctx context.Context, params *FilterNodeParams) error {
+	_, nodes, err := m.FilterNodeList(ctx, params)
+	if err != nil {
+		return err
+	}
+	var cacheKeys []string
+	for _, node := range nodes {
+		cacheKeys = append(cacheKeys, fmt.Sprintf("%s%d", ServerUserListCacheKey, node.ServerId))
+		if node.Protocol != "" {
+			var cursor uint64
+			for {
+				keys, newCursor, err := m.Cache.Scan(ctx, cursor, fmt.Sprintf("%s%d*", ServerConfigCacheKey, node.ServerId), 100).Result()
+				if err != nil {
+					return err
+				}
+				if len(keys) > 0 {
+					cacheKeys = append(keys, keys...)
+				}
+				cursor = newCursor
+				if cursor == 0 {
+					break
+				}
+			}
+		}
+	}
+
+	if len(cacheKeys) > 0 {
+		cacheKeys = tool.RemoveDuplicateElements(cacheKeys...)
+		return m.Cache.Del(ctx, cacheKeys...).Err()
+	}
+	return nil
+}
+
+// ClearServerCache Clear Server Cache
+func (m *customServerModel) ClearServerCache(ctx context.Context, serverId int64) error {
+	var cacheKeys []string
+	cacheKeys = append(cacheKeys, fmt.Sprintf("%s%d", ServerUserListCacheKey, serverId))
+	var cursor uint64
+	for {
+		keys, newCursor, err := m.Cache.Scan(ctx, 0, fmt.Sprintf("%s%d*", ServerConfigCacheKey, serverId), 100).Result()
+		if err != nil {
+			return err
+		}
+		if len(keys) > 0 {
+			cacheKeys = append(cacheKeys, keys...)
+		}
+		cursor = newCursor
+		if cursor == 0 {
+			break
+		}
+	}
+
+	if len(cacheKeys) > 0 {
+		cacheKeys = tool.RemoveDuplicateElements(cacheKeys...)
+		return m.Cache.Del(ctx, cacheKeys...).Err()
+	}
+	return nil
+}
+
+// InSet 支持多值 OR 查询
+func InSet(field string, values []string) func(db *gorm.DB) *gorm.DB {
+	return func(db *gorm.DB) *gorm.DB {
+		if len(values) == 0 {
+			return db
+		}
+
+		conds := make([]string, len(values))
+		args := make([]interface{}, len(values))
+		for i, v := range values {
+			conds[i] = "FIND_IN_SET(?, " + field + ")"
+			args[i] = v
+		}
+
+		// 用括号包裹 OR 条件，保证外层 AND 不受影响
+		return db.Where("("+strings.Join(conds, " OR ")+")", args...)
+	}
+}

internal/model/node/node.go

@@ -0,0 +1,82 @@
+package node
+
+import (
+	"time"
+
+	"github.com/perfect-panel/server/pkg/logger"
+	"gorm.io/gorm"
+)
+
+type Node struct {
+	Id        int64     `gorm:"primary_key"`
+	Name      string    `gorm:"type:varchar(100);not null;default:'';comment:Node Name"`
+	Tags      string    `gorm:"type:varchar(255);not null;default:'';comment:Tags"`
+	Port      uint16    `gorm:"not null;default:0;comment:Connect Port"`
+	Address   string    `gorm:"type:varchar(255);not null;default:'';comment:Connect Address"`
+	ServerId  int64     `gorm:"not null;default:0;comment:Server ID"`
+	Server    *Server   `gorm:"foreignKey:ServerId;references:Id"`
+	Protocol  string    `gorm:"type:varchar(100);not null;default:'';comment:Protocol"`
+	Enabled   *bool     `gorm:"type:boolean;not null;default:true;comment:Enabled"`
+	Sort      int       `gorm:"uniqueIndex;not null;default:0;comment:Sort"`
+	CreatedAt time.Time `gorm:"<-:create;comment:Creation Time"`
+	UpdatedAt time.Time `gorm:"comment:Update Time"`
+}
+
+func (n *Node) TableName() string {
+	return "nodes"
+}
+
+func (n *Node) BeforeCreate(tx *gorm.DB) error {
+	if n.Sort == 0 {
+		var maxSort int
+		if err := tx.Model(&Node{}).Select("COALESCE(MAX(sort), 0)").Scan(&maxSort).Error; err != nil {
+			return err
+		}
+		n.Sort = maxSort + 1
+	}
+	return nil
+}
+
+func (n *Node) BeforeDelete(tx *gorm.DB) error {
+	if err := tx.Exec("UPDATE `nodes` SET sort = sort - 1 WHERE sort > ?", n.Sort).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func (n *Node) BeforeUpdate(tx *gorm.DB) error {
+	var count int64
+	if err := tx.Set("gorm:query_option", "FOR UPDATE").Model(&Server{}).
+		Where("sort = ? AND id != ?", n.Sort, n.Id).Count(&count).Error; err != nil {
+		return err
+	}
+	if count > 1 {
+		// reorder sort
+		if err := reorderSortWithNode(tx); err != nil {
+			logger.Errorf("[Server] BeforeUpdate reorderSort error: %v", err.Error())
+			return err
+		}
+		// get max sort
+		var maxSort int
+		if err := tx.Model(&Server{}).Select("MAX(sort)").Scan(&maxSort).Error; err != nil {
+			return err
+		}
+		n.Sort = maxSort + 1
+	}
+	return nil
+}
+
+func reorderSortWithNode(tx *gorm.DB) error {
+	var nodes []Node
+	if err := tx.Order("sort, id").Find(&nodes).Error; err != nil {
+		return err
+	}
+	for i, node := range nodes {
+		if node.Sort != i+1 {
+			if err := tx.Exec("UPDATE `nodes` SET sort = ? WHERE id = ?", i+1, node.Id).Error; err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}

internal/model/node/server.go

@@ -0,0 +1,188 @@
+package node
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+type Server struct {
+	Id      int64  `gorm:"primary_key"`
+	Name    string `gorm:"type:varchar(100);not null;default:'';comment:Server Name"`
+	Country string `gorm:"type:varchar(128);not null;default:'';comment:Country"`
+	City    string `gorm:"type:varchar(128);not null;default:'';comment:City"`
+	//Ratio          float32    `gorm:"type:DECIMAL(4,2);not null;default:0;comment:Traffic Ratio"`
+	Address        string     `gorm:"type:varchar(100);not null;default:'';comment:Server Address"`
+	Sort           int        `gorm:"type:int;not null;default:0;comment:Sort"`
+	Protocols      string     `gorm:"type:text;default:null;comment:Protocol"`
+	LastReportedAt *time.Time `gorm:"comment:Last Reported Time"`
+	CreatedAt      time.Time  `gorm:"<-:create;comment:Creation Time"`
+	UpdatedAt      time.Time  `gorm:"comment:Update Time"`
+}
+
+func (*Server) TableName() string {
+	return "servers"
+}
+
+func (m *Server) BeforeCreate(tx *gorm.DB) error {
+	if m.Sort == 0 {
+		var maxSort int
+		if err := tx.Model(&Server{}).Select("COALESCE(MAX(sort), 0)").Scan(&maxSort).Error; err != nil {
+			return err
+		}
+		m.Sort = maxSort + 1
+	}
+	return nil
+}
+
+func (m *Server) BeforeDelete(tx *gorm.DB) error {
+	if err := tx.Exec("UPDATE `servers` SET sort = sort - 1 WHERE sort > ?", m.Sort).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m *Server) BeforeUpdate(tx *gorm.DB) error {
+	var count int64
+	if err := tx.Set("gorm:query_option", "FOR UPDATE").Model(&Server{}).
+		Where("sort = ? AND id != ?", m.Sort, m.Id).Count(&count).Error; err != nil {
+		return err
+	}
+	if count > 1 {
+		// reorder sort
+		if err := reorderSortWithServer(tx); err != nil {
+			logger.Errorf("[Server] BeforeUpdate reorderSort error: %v", err.Error())
+			return err
+		}
+		// get max sort
+		var maxSort int
+		if err := tx.Model(&Server{}).Select("MAX(sort)").Scan(&maxSort).Error; err != nil {
+			return err
+		}
+		m.Sort = maxSort + 1
+	}
+	return nil
+}
+
+// MarshalProtocols Marshal server protocols to json
+func (m *Server) MarshalProtocols(list []Protocol) error {
+	var validate = make(map[string]bool)
+	for _, protocol := range list {
+		if protocol.Type == "" {
+			return errors.New("protocol type is required")
+		}
+		if _, exists := validate[protocol.Type]; exists {
+			return errors.New("duplicate protocol type: " + protocol.Type)
+		}
+		validate[protocol.Type] = true
+	}
+	data, err := json.Marshal(list)
+	if err != nil {
+		return err
+	}
+	m.Protocols = string(data)
+	return nil
+}
+
+// UnmarshalProtocols Unmarshal server protocols from json
+func (m *Server) UnmarshalProtocols() ([]Protocol, error) {
+	var list []Protocol
+	if m.Protocols == "" {
+		return list, nil
+	}
+	err := json.Unmarshal([]byte(m.Protocols), &list)
+	if err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+
+type Protocol struct {
+	Type                    string `json:"type"`
+	Port                    uint16 `json:"port"`
+	Enable                  bool   `json:"enable"`
+	Security                string `json:"security,omitempty"`
+	SNI                     string `json:"sni,omitempty"`
+	AllowInsecure           bool   `json:"allow_insecure,omitempty"`
+	Fingerprint             string `json:"fingerprint,omitempty"`
+	RealityServerAddr       string `json:"reality_server_addr,omitempty"`
+	RealityServerPort       int    `json:"reality_server_port,omitempty"`
+	RealityPrivateKey       string `json:"reality_private_key,omitempty"`
+	RealityPublicKey        string `json:"reality_public_key,omitempty"`
+	RealityShortId          string `json:"reality_short_id,omitempty"`
+	Transport               string `json:"transport,omitempty"`
+	Host                    string `json:"host,omitempty"`
+	Path                    string `json:"path,omitempty"`
+	ServiceName             string `json:"service_name,omitempty"`
+	Cipher                  string `json:"cipher,omitempty"`
+	ServerKey               string `json:"server_key,omitempty"`
+	Flow                    string `json:"flow,omitempty"`
+	HopPorts                string `json:"hop_ports,omitempty"`
+	HopInterval             int    `json:"hop_interval,omitempty"`
+	ObfsPassword            string `json:"obfs_password,omitempty"`
+	DisableSNI              bool   `json:"disable_sni,omitempty"`
+	ReduceRtt               bool   `json:"reduce_rtt,omitempty"`
+	UDPRelayMode            string `json:"udp_relay_mode,omitempty"`
+	CongestionController    string `json:"congestion_controller,omitempty"`
+	Multiplex               string `json:"multiplex,omitempty"`                 // mux, eg: off/low/medium/high
+	PaddingScheme           string `json:"padding_scheme,omitempty"`            // padding scheme
+	UpMbps                  int    `json:"up_mbps,omitempty"`                   // upload speed limit
+	DownMbps                int    `json:"down_mbps,omitempty"`                 // download speed limit
+	Obfs                    string `json:"obfs,omitempty"`                      // obfs, 'none', 'http', 'tls'
+	ObfsHost                string `json:"obfs_host,omitempty"`                 // obfs host
+	ObfsPath                string `json:"obfs_path,omitempty"`                 // obfs path
+	XhttpMode               string `json:"xhttp_mode,omitempty"`                // xhttp mode
+	XhttpExtra              string `json:"xhttp_extra,omitempty"`               // xhttp extra path
+	Encryption              string `json:"encryption,omitempty"`                // encryption，'none', 'mlkem768x25519plus'
+	EncryptionMode          string `json:"encryption_mode,omitempty"`           // encryption mode，'native', 'xorpub', 'random'
+	EncryptionRtt           string `json:"encryption_rtt,omitempty"`            // encryption rtt，'0rtt', '1rtt'
+	EncryptionTicket        string `json:"encryption_ticket,omitempty"`         // encryption ticket
+	EncryptionServerPadding string `json:"encryption_server_padding,omitempty"` // encryption server padding
+	EncryptionPrivateKey    string `json:"encryption_private_key,omitempty"`    // encryption private key
+	EncryptionClientPadding string `json:"encryption_client_padding,omitempty"` // encryption client padding
+	EncryptionPassword      string `json:"encryption_password,omitempty"`       // encryption password
+
+	Ratio           float64 `json:"ratio,omitempty"`             // Traffic ratio, default is 1
+	CertMode        string  `json:"cert_mode,omitempty"`         // Certificate mode, `none`｜`http`｜`dns`｜`self`
+	CertDNSProvider string  `json:"cert_dns_provider,omitempty"` // DNS provider for certificate
+	CertDNSEnv      string  `json:"cert_dns_env"`                // Environment for DNS provider
+}
+
+// Marshal protocol to json
+func (m *Protocol) Marshal() ([]byte, error) {
+	type Alias Protocol
+	return json.Marshal(&struct {
+		*Alias
+	}{
+		Alias: (*Alias)(m),
+	})
+}
+
+// Unmarshal json to protocol
+func (m *Protocol) Unmarshal(data []byte) error {
+	type Alias Protocol
+	aux := &struct {
+		*Alias
+	}{
+		Alias: (*Alias)(m),
+	}
+	return json.Unmarshal(data, &aux)
+}
+
+func reorderSortWithServer(tx *gorm.DB) error {
+	var servers []Server
+	if err := tx.Order("sort, id").Find(&servers).Error; err != nil {
+		return err
+	}
+	for i, server := range servers {
+		if server.Sort != i+1 {
+			if err := tx.Exec("UPDATE `servers` SET sort = ? WHERE id = ?", i+1, server.Id).Error; err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}