Develop (#76)

* refactor: rename queryannouncementhandler.go to queryAnnouncementLogic.go for clarity * feat(panDomain): update subscription logic to use V2 handler for improved functionality * refactor(subscribe): replace V2 handler with a unified Handler method for subscription logic * feat(subscribe): implement user agent limit feature with configurable list * fix(subscribe): improve error handling and logging for subscription requests * feat(subscribe): add user agent limit configuration to system settings * refactor(api): remove deprecated application-related endpoints and types * refactor(swagger): remove deprecated app.json generation from swagger configuration * refactor(swagger): remove deprecated app.json check from swagger configuration * fix(subscribe): update delete method to use Where clause for improved query accuracy * fix(subscribe): update Id field tag to use primaryKey and improve save method query * fix(subscribe): update Id field tag to use primaryKey and improve model queries * fix(subscribe): rename variable for clarity and add special handling for Stash user agent * fix(email): convert RegisterStartTime and RegisterEndTime to time.Time for accurate query filtering * refactor(log): consolidate logging models and update related logic for improved clarity and functionality * fix(types): change Content field type in MessageLog to interface{} for improved flexibility * fix(log): change MessageLog list to use value type for improved performance and memory efficiency * fix(email): set EmailTypeVerify in task payload and update content type conversion for verification email * fix(log): remove unused Id field from SystemLog during login log insertion * fix(login): remove debug logs and error logging during user login process * fix(log): add traffic reset logging for subscription resets * fix(log): insert reset traffic log during subscription activation * feat(log): add endpoints for retrieving and resetting subscribe traffic logs * refactor(log): remove Reset Subscribe Traffic Log endpoint and related types * feat(traffic): add traffic statistics logging and scheduling * fix(subscribe): ensure active status and reset timestamps during traffic resets * feat(api): enhance server and node management with new request/response structures * refactor(api): rename OnlineUser to ServerOnlineUser for clarity * feat(api): define OnlineUser type with SID and IP fields * feat(server): implement server management handlers and database schema * feat(api): add traffic log details filtering and enhance traffic log structures * feat(api): migrate server and node data handling, update related structures and logic * feat(server): implement server deletion logic with error handling * feat(api): update log filtering to use ResetSubscribe type for subscription logs * feat(api): standardize timestamp field across log structures * feat(api): refactor cache key handling for server and user lists * feat(api): enhance server status handling with protocol support and refactor related logic * fix(traffic): adjust start date for traffic statistics and improve log deletion comment * feat(api): implement daily traffic ranking for users and servers with error handling * feat(api): update server total data response to use 'OnlineUsers' and implement daily traffic statistics logging * feat(api): add log settings management with auto-clear and clear days configuration * fix(log): correct category in log settings update query * feat(routes): add handler for scheduled traffic statistics * feat(model): add user counts struct and update queries for new and renewal users * feat(api): add referral percentage and only first purchase fields to user model and requests * feat(database): update user table to add referral percentage and only first purchase fields * feat(api): add reset sort endpoints for server and node * feat(api): add sort field to server model * feat(api): implement sorting functionality for nodes and servers * fix(database): add sort column to nodes table * fix(model): enhance user statistics queries with new order and renewal order counts * fix(log): update timestamp handling in login and registration logs * fix(log): update sorting logic for server and user subscribe traffic logs * fix(server): add server status handling based on last reported time * fix(model): correct filter condition to use 'date' instead of 'data' * fix(migration): add index for traffic log on timestamp, user_id, and subscribe_id * fix(log): optimize user traffic rank data handling by using append instead of index assignment * fix(filter): refactor node list creation to use append and remove duplicates from tags * fix(node): add ServerId and Enabled fields to node update logic * feat(tags): add endpoint to query all node tags * fix(preview): add Preload parameter to FilterNodeList for improved data retrieval * fix(log): date is empty * feat(subscribe): add Language field to subscription models and update query logic * feat(subscription): add Language parameter to GetSubscription request and update query logic * fix(server): encode ServerKey in base64 and update last reported time for nodes * feat: delete common GetSubscription * feat(subscription): implement FilterList method for subscription queries and update related logic * fix(subscribe): remove duplicate user agents in SubscribeHandler * fix(push): initialize onlineUsers as a map in pushOnlineUsersLogic * fix(reset): initialize subs as a map in clearCache method * refactor(query): simplify node and tag filtering using InSet function * feat(userlist): enhance GetServerUserListLogic with improved node and tag handling * fix(userlist): correct node ID assignment and update query logic for tag filtering * fix(userlist): correct node ID assignment in getServerUserListLogic * refactor(query): streamline query construction for tag filtering * fix(statistics): optimize server ranking data handling in QueryServerTotalDataLogic * refactor(statistics): simplify server ranking data construction in QueryServerTotalDataLogic * fix(statistics): correct server traffic data assignment in QueryServerTotalDataLogic * fix(statistics): optimize yesterday's top 10 server traffic data assignment in QueryServerTotalDataLogic * fix(middleware): remove duplicate elements from user agent list in PanDomainMiddleware * feat(middleware): enhance user agent handling by querying client list in PanDomainMiddleware * feat(client): subscribe_template * feat(oauth): add user agent and IP logging to registration and login processes * fix(balance): add timestamp to balance logs for payment, refund, and recharge transactions * fix(log): correct comment for CommissionTypeRefund to improve clarity * fix(log): replace magic number with constant for gift type in purchase checkout logic * fix(log): rename OrderId to OrderNo for consistency in balance logging * feat(log): add logging for balance, gift amount, and commission adjustments * fix(user): correct placement of DeepCopy for user info update logic * feat(log): add UserSubscribeId to FilterSubscribeLogRequest for enhanced filtering * fix(purchase): streamline error handling and improve JSON marshaling for temporary orders * fix(order): simplify commission handling and improve payload parsing logic * fix(order): update commission calculation to actual payment amount minus gateway handling fee * feat(payment): add support for CryptoSaaS payment platform and enhance configuration handling * fix(balance): update QueryUserBalanceLog response structure to include balance log list * fix(email): update task progress handling to use specific task ID for updates * feat(quota): add quota task creation and querying endpoints with updated data structures * fix(email): update task handling to use generic task model and improve error logging * fix(order): improve error logging for database transaction and user cache updates * feat(quota): enhance quota task management with new request structures and processing logic * fix(quota): remove redundant quota task status endpoint from admin marketing routes * fix(worker): update task completion status handling in worker logic * fix(quota): update taskInfo to include current subscription count in quota logic * doc(log): rename function for clarity and add cache cleanup comment * fix(quota): update time handling in quota logic and correct subscriber ID query * fix(quota): update time handling to use UnixMilli for start time in quota logic * feat(protocol): add server protocol configuration query and enhance protocol options * fix(quota): correct time range queries for start and expire times in quota logic * fix(types): update plugin options to include 'none' in the plugin field --------- Co-authored-by: Chang lue Tsen <tension@ppanel.dev>
2025-09-14 22:50:22 +09:00
parent b5e244d83d
commit e895180388
359 changed files with 9213 additions and 12125 deletions
@@ -0,0 +1,146 @@
+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()
+
+}
+
+// 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()
+}
+
+// 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
+}
@@ -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).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).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)
+}
@@ -0,0 +1,157 @@
+package node
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/perfect-panel/server/pkg/tool"
+)
+
+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
+	ServerId []int64  // Server IDs
+	Tag      []string // Tags
+	Search   string   // Search Address or Name
+	Protocol string   // Protocol
+	Preload  bool     // Preload Server
+}
+
+// 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).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.ServerId) > 0 {
+		query = query.Where("server_id IN ?", params.ServerId)
+	}
+	if len(params.Tag) > 0 {
+		for _, tag := range params.Tag {
+			query = query.Or("FIND_IN_SET(?,tags)", tag)
+		}
+	}
+	if params.Protocol != "" {
+		query = query.Where("protocol = ?", params.Protocol)
+	}
+
+	if params.Preload {
+		query = query.Preload("Server")
+	}
+
+	err := query.Count(&total).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
+}
@@ -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
+}
@@ -0,0 +1,171 @@
+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"`
+	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"`
+	Plugin               string `json:"plugin,omitempty"`         // obfs, v2ray-plugin, simple-obfs
+	PluginOptions        string `json:"plugin_options,omitempty"` // plugin options, eg: obfs=http;obfs-host=www.bing.com
+	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
+}
+
+// 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
+}