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>

internal/model/subscribe/default.go

@@ -4,12 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"strconv"
 	"strings"
 
-	"github.com/perfect-panel/server/internal/config"
-	"github.com/perfect-panel/server/internal/model/server"
+	"github.com/perfect-panel/server/internal/model/node"
 	"github.com/perfect-panel/server/pkg/cache"
+	"github.com/perfect-panel/server/pkg/tool"
 	"github.com/redis/go-redis/v9"
 	"gorm.io/gorm"
 )
@@ -61,42 +60,34 @@ func (m *defaultSubscribeModel) getCacheKeys(data *Subscribe) []string {
 	if data == nil {
 		return []string{}
 	}
-	SubscribeIdKey := fmt.Sprintf("%s%v", cacheSubscribeIdPrefix, data.Id)
-	serverKey := make([]string, 0)
-	if data.Server != "" {
-		cacheKey := strings.Split(data.Server, ",")
-		for _, v := range cacheKey {
-			if v != "" {
-				serverKey = append(serverKey, fmt.Sprintf("%s%v", config.ServerUserListCacheKey, v))
+	var keys []string
+	if data.Nodes != "" {
+		var nodes []*node.Node
+		ids := strings.Split(data.Nodes, ",")
+
+		err := m.QueryNoCacheCtx(context.Background(), &nodes, func(conn *gorm.DB, v interface{}) error {
+			return conn.Model(&node.Node{}).Where("id IN (?)", tool.StringSliceToInt64Slice(ids)).Find(&nodes).Error
+		})
+		if err == nil {
+			for _, n := range nodes {
+				keys = append(keys, fmt.Sprintf("%s%d", node.ServerUserListCacheKey, n.ServerId))
 			}
 		}
 	}
-	// Temporary solution waiting for refactoring
-	if data.ServerGroup != "" {
-		cacheKey := strings.Split(data.ServerGroup, ",")
-		groupIds := make([]int64, 0)
-		for _, v := range cacheKey {
-			if v != "" {
-				id, _ := strconv.ParseInt(v, 10, 64)
-				if id > 0 {
-					groupIds = append(groupIds, id)
-				}
-			}
-		}
-		var ids []int64
-		_ = m.Transaction(context.Background(), func(tx *gorm.DB) error {
-			return tx.Model(&server.Server{}).Where("group_id IN ?", groupIds).Pluck("id", &ids).Error
+	if data.NodeTags != "" {
+		var nodes []*node.Node
+		tags := tool.RemoveDuplicateElements(strings.Split(data.NodeTags, ",")...)
+		err := m.QueryNoCacheCtx(context.Background(), &nodes, func(conn *gorm.DB, v interface{}) error {
+			return conn.Model(&node.Node{}).Scopes(InSet("tags", tags)).Find(&nodes).Error
 		})
-		for _, id := range ids {
-			serverKey = append(serverKey, fmt.Sprintf("%s%v", config.ServerUserListCacheKey, id))
+		if err == nil {
+			for _, n := range nodes {
+				keys = append(keys, fmt.Sprintf("%s%d", node.ServerUserListCacheKey, n.ServerId))
+			}
 		}
 	}
 
-	cacheKeys := []string{SubscribeIdKey}
-	if len(serverKey) > 0 {
-		cacheKeys = append(cacheKeys, serverKey...)
-	}
-	return cacheKeys
+	return append(keys, fmt.Sprintf("%s%v", cacheSubscribeIdPrefix, data.Id))
 }
 
 func (m *defaultSubscribeModel) Insert(ctx context.Context, data *Subscribe, tx ...*gorm.DB) error {

internal/model/subscribe/model.go

@@ -3,39 +3,37 @@ package subscribe
 import (
 	"context"
 
+	"github.com/perfect-panel/server/pkg/tool"
 	"github.com/redis/go-redis/v9"
 	"gorm.io/gorm"
 )
 
-//	type Details struct {
-//		Id                   int64  `gorm:"primaryKey"`
-//		Name                 string `gorm:"type:varchar(255);not null;default:'';comment:Subscribe Name"`
-//		Description          string `gorm:"type:text;comment:Subscribe Description"`
-//		UnitPrice            int64  `gorm:"type:int;not null;default:0;comment:Unit Price"`
-//		UnitTime             string `gorm:"type:varchar(255);not null;default:'';comment:Unit Time"`
-//		Discount             string `gorm:"type:text;comment:Discount"`
-//		Replacement          int64  `gorm:"type:int;not null;default:0;comment:Replacement"`
-//		Inventory            int64  `gorm:"type:int;not null;default:0;comment:Inventory"`
-//		Traffic              int64  `gorm:"type:int;not null;default:0;comment:Traffic"`
-//		SpeedLimit           int64  `gorm:"type:int;not null;default:0;comment:Speed Limit"`
-//		DeviceLimit          int64  `gorm:"type:int;not null;default:0;comment:Device Limit"`
-//		GroupId              int64  `gorm:"type:bigint;comment:Group Id"`
-//		Quota                int64  `gorm:"type:int;not null;default:0;comment:Quota"`
-//		Show                 *bool  `gorm:"type:tinyint(1);not null;default:0;comment:Show"`
-//		Sell                 *bool  `gorm:"type:tinyint(1);not null;default:0;comment:Sell"`
-//		DeductionRatio       int64  `gorm:"type:int;default:0;comment:Deduction Ratio"`
-//		PurchaseWithDiscount bool   `gorm:"type:tinyint(1);default:0;comment:PurchaseWithDiscount"`
-//		ResetCycle           int64  `gorm:"type:int;default:0;comment:Reset Cycle"`
-//		RenewalReset         bool   `gorm:"type:tinyint(1);default:0;comment:Renew Reset"`
-//	}
+type FilterParams struct {
+	Page            int      // Page Number
+	Size            int      // Page Size
+	Ids             []int64  // Subscribe IDs
+	Node            []int64  // Node IDs
+	Tags            []string // Node Tags
+	Show            bool     // Show Portal Page
+	Sell            bool     // Sell
+	Language        string   // Language
+	DefaultLanguage bool     // Default Subscribe Language Data
+	Search          string   // Search Keywords
+}
+
+func (p *FilterParams) Normalize() {
+	if p.Page <= 0 {
+		p.Page = 1
+	}
+	if p.Size <= 0 {
+		p.Size = 10
+	}
+}
+
 type customSubscribeLogicModel interface {
-	QuerySubscribeListByPage(ctx context.Context, page, size int, group int64, search string) (total int64, list []*Subscribe, err error)
-	QuerySubscribeList(ctx context.Context) ([]*Subscribe, error)
-	QuerySubscribeListByShow(ctx context.Context) ([]*Subscribe, error)
-	QuerySubscribeIdsByServerIdAndServerGroupId(ctx context.Context, serverId, serverGroupId int64) ([]*Subscribe, error)
-	QuerySubscribeMinSortByIds(ctx context.Context, ids []int64) (int64, error)
-	QuerySubscribeListByIds(ctx context.Context, ids []int64) ([]*Subscribe, error)
+	FilterList(ctx context.Context, params *FilterParams) (int64, []*Subscribe, error)
 	ClearCache(ctx context.Context, id ...int64) error
+	QuerySubscribeMinSortByIds(ctx context.Context, ids []int64) (int64, error)
 }
 
 // NewModel returns a model for the database table.
@@ -45,54 +43,6 @@ func NewModel(conn *gorm.DB, c *redis.Client) Model {
 	}
 }
 
-// QuerySubscribeListByPage  Get Subscribe List
-func (m *customSubscribeModel) QuerySubscribeListByPage(ctx context.Context, page, size int, group int64, search string) (total int64, list []*Subscribe, err error) {
-	err = m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
-		// About to be abandoned
-		_ = conn.Model(&Subscribe{}).
-			Where("sort = ?", 0).
-			Update("sort", gorm.Expr("id"))
-
-		conn = conn.Model(&Subscribe{})
-		if group > 0 {
-			conn = conn.Where("group_id = ?", group)
-		}
-		if search != "" {
-			conn = conn.Where("`name` like ? or `description` like ?", "%"+search+"%", "%"+search+"%")
-		}
-		return conn.Count(&total).Order("sort ASC").Limit(size).Offset((page - 1) * size).Find(v).Error
-	})
-	return total, list, err
-}
-
-// QuerySubscribeList Get Subscribe List
-func (m *customSubscribeModel) QuerySubscribeList(ctx context.Context) ([]*Subscribe, error) {
-	var list []*Subscribe
-	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
-		conn = conn.Model(&Subscribe{})
-		return conn.Where("`sell` = true").Order("sort ").Find(v).Error
-	})
-	return list, err
-}
-
-func (m *customSubscribeModel) QuerySubscribeIdsByServerIdAndServerGroupId(ctx context.Context, serverId, serverGroupId int64) ([]*Subscribe, error) {
-	var data []*Subscribe
-	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
-		return conn.Model(&Subscribe{}).Where("FIND_IN_SET(?, server)", serverId).Or("FIND_IN_SET(?, server_group)", serverGroupId).Find(v).Error
-	})
-	return data, err
-}
-
-// QuerySubscribeListByShow Get Subscribe List By Show
-func (m *customSubscribeModel) QuerySubscribeListByShow(ctx context.Context) ([]*Subscribe, error) {
-	var list []*Subscribe
-	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
-		conn = conn.Model(&Subscribe{})
-		return conn.Where("`show` = true").Find(v).Error
-	})
-	return list, err
-}
-
 func (m *customSubscribeModel) QuerySubscribeMinSortByIds(ctx context.Context, ids []int64) (int64, error) {
 	var minSort int64
 	err := m.QueryNoCacheCtx(ctx, &minSort, func(conn *gorm.DB, v interface{}) error {
@@ -101,14 +51,6 @@ func (m *customSubscribeModel) QuerySubscribeMinSortByIds(ctx context.Context, i
 	return minSort, err
 }
 
-func (m *customSubscribeModel) QuerySubscribeListByIds(ctx context.Context, ids []int64) ([]*Subscribe, error) {
-	var list []*Subscribe
-	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
-		return conn.Model(&Subscribe{}).Where("id IN ?", ids).Find(v).Error
-	})
-	return list, err
-}
-
 func (m *customSubscribeModel) ClearCache(ctx context.Context, ids ...int64) error {
 	if len(ids) <= 0 {
 		return nil
@@ -124,3 +66,91 @@ func (m *customSubscribeModel) ClearCache(ctx context.Context, ids ...int64) err
 	}
 	return m.CachedConn.DelCacheCtx(ctx, cacheKeys...)
 }
+
+// FilterList Filter Subscribe List
+func (m *customSubscribeModel) FilterList(ctx context.Context, params *FilterParams) (int64, []*Subscribe, error) {
+	if params == nil {
+		params = &FilterParams{}
+	}
+	params.Normalize()
+
+	var list []*Subscribe
+	var total int64
+
+	// 构建查询函数
+	buildQuery := func(conn *gorm.DB, lang string) *gorm.DB {
+		query := conn.Model(&Subscribe{})
+
+		if params.Search != "" {
+			s := "%" + params.Search + "%"
+			query = query.Where("`name` LIKE ? OR `description` LIKE ?", s, s)
+		}
+		if params.Show {
+			query = query.Where("`show` = true")
+		}
+		if params.Sell {
+			query = query.Where("`sell` = true")
+		}
+
+		if len(params.Ids) > 0 {
+			query = query.Where("id IN ?", params.Ids)
+		}
+		if len(params.Node) > 0 {
+			query = query.Scopes(InSet("nodes", tool.Int64SliceToStringSlice(params.Node)))
+		}
+
+		if len(params.Tags) > 0 {
+			query = query.Scopes(InSet("node_tags", params.Tags))
+		}
+		if lang != "" {
+			query = query.Where("language = ?", lang)
+		} else if params.DefaultLanguage {
+			query = query.Where("language = ''")
+		}
+
+		return query
+	}
+
+	// 查询数据
+	queryFunc := func(lang string) error {
+		return m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
+			query := buildQuery(conn, lang)
+			if err := query.Count(&total).Error; err != nil {
+				return err
+			}
+			return query.Order("sort ASC").
+				Limit(params.Size).
+				Offset((params.Page - 1) * params.Size).
+				Find(v).Error
+		})
+	}
+
+	err := queryFunc(params.Language)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	// fallback 默认语言
+	if params.DefaultLanguage && total == 0 {
+		err = queryFunc("")
+		if err != nil {
+			return 0, nil, err
+		}
+	}
+
+	return total, list, nil
+}
+
+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
+		}
+
+		query := db.Where("1=0")
+		for _, v := range values {
+			query = query.Or("FIND_IN_SET(?, "+field+")", v)
+		}
+		return query
+	}
+}

internal/model/subscribe/subscribe.go

@@ -9,6 +9,7 @@ import (
 type Subscribe struct {
 	Id             int64     `gorm:"primaryKey"`
 	Name           string    `gorm:"type:varchar(255);not null;default:'';comment:Subscribe Name"`
+	Language       string    `gorm:"type:varchar(255);not null;default:'';comment:Language"`
 	Description    string    `gorm:"type:text;comment:Subscribe Description"`
 	UnitPrice      int64     `gorm:"type:int;not null;default:0;comment:Unit Price"`
 	UnitTime       string    `gorm:"type:varchar(255);not null;default:'';comment:Unit Time"`
@@ -19,9 +20,8 @@ type Subscribe struct {
 	SpeedLimit     int64     `gorm:"type:int;not null;default:0;comment:Speed Limit"`
 	DeviceLimit    int64     `gorm:"type:int;not null;default:0;comment:Device Limit"`
 	Quota          int64     `gorm:"type:int;not null;default:0;comment:Quota"`
-	GroupId        int64     `gorm:"type:bigint;comment:Group Id"`
-	ServerGroup    string    `gorm:"type:varchar(255);comment:Server Group"`
-	Server         string    `gorm:"type:varchar(255);comment:Server"`
+	Nodes          string    `gorm:"type:varchar(255);comment:Node Ids"`
+	NodeTags       string    `gorm:"type:varchar(255);comment:Node Tags"`
 	Show           *bool     `gorm:"type:tinyint(1);not null;default:0;comment:Show portal page"`
 	Sell           *bool     `gorm:"type:tinyint(1);not null;default:0;comment:Sell"`
 	Sort           int64     `gorm:"type:int;not null;default:0;comment:Sort"`