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>

queue/logic/country/getCountryLogic.go

@@ -2,14 +2,9 @@ package countrylogic
 
 import (
 	"context"
-	"encoding/json"
-
-	"github.com/perfect-panel/server/pkg/logger"
 
 	"github.com/hibiken/asynq"
 	"github.com/perfect-panel/server/internal/svc"
-	"github.com/perfect-panel/server/pkg/ip"
-	"github.com/perfect-panel/server/queue/types"
 )
 
 type GetNodeCountryLogic struct {
@@ -22,39 +17,6 @@ func NewGetNodeCountryLogic(svcCtx *svc.ServiceContext) *GetNodeCountryLogic {
 	}
 }
 func (l *GetNodeCountryLogic) ProcessTask(ctx context.Context, task *asynq.Task) error {
-	var payload types.GetNodeCountry
-	if err := json.Unmarshal(task.Payload(), &payload); err != nil {
-		logger.WithContext(ctx).Error("[GetNodeCountryLogic] Unmarshal payload failed",
-			logger.Field("error", err.Error()),
-			logger.Field("payload", task.Payload()),
-		)
-		return nil
-	}
-	serverAddr := payload.ServerAddr
-	resp, err := ip.GetRegionByIp(serverAddr)
-	if err != nil {
-		logger.WithContext(ctx).Error("[GetNodeCountryLogic] ", logger.Field("error", err.Error()), logger.Field("serverAddr", serverAddr))
-		return nil
-	}
 
-	servers, err := l.svcCtx.ServerModel.FindNodeByServerAddrAndProtocol(ctx, payload.ServerAddr, payload.Protocol)
-	if err != nil {
-		logger.WithContext(ctx).Error("[GetNodeCountryLogic] FindNodeByServerAddrAnd", logger.Field("error", err.Error()), logger.Field("serverAddr", serverAddr))
-		return err
-	}
-	if len(servers) == 0 {
-		return nil
-	}
-	for _, ser := range servers {
-		ser.Country = resp.Country
-		ser.City = resp.City
-		ser.Latitude = resp.Latitude
-		ser.Longitude = resp.Longitude
-		err := l.svcCtx.ServerModel.Update(ctx, ser)
-		if err != nil {
-			logger.WithContext(ctx).Error("[GetNodeCountryLogic] ", logger.Field("error", err.Error()), logger.Field("id", ser.Id))
-		}
-	}
-	logger.WithContext(ctx).Info("[GetNodeCountryLogic] ", logger.Field("country", resp.Country), logger.Field("city", resp.Country))
 	return nil
 }

queue/logic/email/batchEmailLogic.go

@@ -44,8 +44,8 @@ func (l *BatchEmailLogic) ProcessTask(ctx context.Context, task *asynq.Task) err
 		return asynq.SkipRetry
 	}
 	tx := l.svcCtx.DB.WithContext(ctx)
-	var taskInfo taskModel.EmailTask
-	if err = tx.Model(&taskModel.EmailTask{}).Where("id = ?", taskID).First(&taskInfo).Error; err != nil {
+	var taskInfo taskModel.Task
+	if err = tx.Model(&taskModel.Task{}).Where("id = ?", taskID).First(&taskInfo).Error; err != nil {
 		logger.WithContext(ctx).Error("[BatchEmailLogic] ProcessTask failed",
 			logger.Field("error", err.Error()),
 			logger.Field("taskID", taskID),

queue/logic/email/sendEmailLogic.go

@@ -1,8 +1,11 @@
 package emailLogic
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
+	"text/template"
+	"time"
 
 	"github.com/perfect-panel/server/pkg/logger"
 
@@ -31,8 +34,7 @@ func (l *SendEmailLogic) ProcessTask(ctx context.Context, task *asynq.Task) erro
 		)
 		return nil
 	}
-	messageLog := log.MessageLog{
-		Type:     log.Email.String(),
+	messageLog := log.Message{
 		Platform: l.svcCtx.Config.Email.Platform,
 		To:       payload.Email,
 		Subject:  payload.Subject,
@@ -43,18 +45,111 @@ func (l *SendEmailLogic) ProcessTask(ctx context.Context, task *asynq.Task) erro
 		logger.WithContext(ctx).Error("[SendEmailLogic] NewSender failed", logger.Field("error", err.Error()))
 		return nil
 	}
-	err = sender.Send([]string{payload.Email}, payload.Subject, payload.Content)
+	var content string
+	switch payload.Type {
+	case types.EmailTypeVerify:
+		tpl, _ := template.New("verify").Parse(l.svcCtx.Config.Email.VerifyEmailTemplate)
+		var result bytes.Buffer
+
+		payload.Content["Type"] = uint8(payload.Content["Type"].(float64))
+
+		err = tpl.Execute(&result, payload.Content)
+		if err != nil {
+			logger.WithContext(ctx).Error("[SendEmailLogic] Execute template failed",
+				logger.Field("error", err.Error()),
+				logger.Field("data", payload.Content),
+			)
+			return nil
+		}
+		content = result.String()
+	case types.EmailTypeMaintenance:
+		tpl, _ := template.New("maintenance").Parse(l.svcCtx.Config.Email.MaintenanceEmailTemplate)
+		var result bytes.Buffer
+		err = tpl.Execute(&result, payload.Content)
+		if err != nil {
+			logger.WithContext(ctx).Error("[SendEmailLogic] Execute template failed",
+				logger.Field("error", err.Error()),
+				logger.Field("template", l.svcCtx.Config.Email.MaintenanceEmailTemplate),
+				logger.Field("data", payload.Content),
+			)
+			return nil
+		}
+		content = result.String()
+	case types.EmailTypeExpiration:
+		tpl, _ := template.New("expiration").Parse(l.svcCtx.Config.Email.ExpirationEmailTemplate)
+		var result bytes.Buffer
+		err = tpl.Execute(&result, payload.Content)
+		if err != nil {
+			logger.WithContext(ctx).Error("[SendEmailLogic] Execute template failed",
+				logger.Field("error", err.Error()),
+				logger.Field("template", l.svcCtx.Config.Email.ExpirationEmailTemplate),
+				logger.Field("data", payload.Content),
+			)
+			return nil
+		}
+		content = result.String()
+	case types.EmailTypeTrafficExceed:
+		tpl, _ := template.New("traffic_exceed").Parse(l.svcCtx.Config.Email.TrafficExceedEmailTemplate)
+		var result bytes.Buffer
+		err = tpl.Execute(&result, payload.Content)
+		if err != nil {
+			logger.WithContext(ctx).Error("[SendEmailLogic] Execute template failed",
+				logger.Field("error", err.Error()),
+				logger.Field("template", l.svcCtx.Config.Email.TrafficExceedEmailTemplate),
+				logger.Field("data", payload.Content),
+			)
+			return nil
+		}
+		content = result.String()
+	case types.EmailTypeCustom:
+		if payload.Content == nil {
+			logger.WithContext(ctx).Error("[SendEmailLogic] Custom email content is empty",
+				logger.Field("payload", payload),
+			)
+			return nil
+		}
+		if tpl, ok := payload.Content["content"].(string); !ok {
+			logger.WithContext(ctx).Error("[SendEmailLogic] Custom email content is not a string",
+				logger.Field("payload", payload),
+			)
+			return nil
+		} else {
+			content = tpl
+		}
+	default:
+		logger.WithContext(ctx).Error("[SendEmailLogic] Unsupported email type",
+			logger.Field("type", payload.Type),
+			logger.Field("payload", payload),
+		)
+		return nil
+	}
+
+	err = sender.Send([]string{payload.Email}, payload.Subject, content)
 	if err != nil {
 		logger.WithContext(ctx).Error("[SendEmailLogic] Send email failed", logger.Field("error", err.Error()))
 		return nil
 	}
 	messageLog.Status = 1
-	if err = l.svcCtx.LogModel.InsertMessageLog(ctx, &messageLog); err != nil {
-		logger.WithContext(ctx).Error("[SendEmailLogic] InsertMessageLog failed",
+	emailLog, err := messageLog.Marshal()
+	if err != nil {
+		logger.WithContext(ctx).Error("[SendEmailLogic] Marshal message log failed",
 			logger.Field("error", err.Error()),
 			logger.Field("messageLog", messageLog),
 		)
+		return nil
+	}
+
+	if err = l.svcCtx.LogModel.Insert(ctx, &log.SystemLog{
+		Type:     log.TypeEmailMessage.Uint8(),
+		Date:     time.Now().Format("2006-01-02"),
+		ObjectID: 0,
+		Content:  string(emailLog),
+	}); err != nil {
+		logger.WithContext(ctx).Error("[SendEmailLogic] Insert email log failed",
+			logger.Field("error", err.Error()),
+			logger.Field("emailLog", string(emailLog)),
+		)
+		return nil
 	}
-	logger.WithContext(ctx).Info("[SendEmailLogic] Send email", logger.Field("email", payload.Email), logger.Field("content", payload.Content))
 	return nil
 }

queue/logic/order/activateOrderLogic.go

@@ -7,15 +7,17 @@ import (
 	"encoding/json"
 	"fmt"
 	"strconv"
+	"strings"
 	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/internal/model/node"
 	"github.com/perfect-panel/server/pkg/constant"
 	"github.com/perfect-panel/server/pkg/logger"
 
 	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
 	"github.com/google/uuid"
 	"github.com/hibiken/asynq"
-	"github.com/perfect-panel/server/internal/config"
 	"github.com/perfect-panel/server/internal/logic/telegram"
 	"github.com/perfect-panel/server/internal/model/order"
 	"github.com/perfect-panel/server/internal/model/subscribe"
@@ -44,11 +46,6 @@ const (
 	OrderStatusFinished = 5 // Order successfully completed
 )
 
-// Commission type constants define the types of commission transactions
-const (
-	CommissionTypeRecharge = 1 // Commission from balance recharge
-)
-
 // Predefined error variables for common error conditions
 var (
 	ErrInvalidOrderStatus = fmt.Errorf("invalid order status")
@@ -81,7 +78,7 @@ func (l *ActivateOrderLogic) ProcessTask(ctx context.Context, task *asynq.Task)
 		return nil // Log and continue
 	}
 
-	if err := l.processOrderByType(ctx, orderInfo); err != nil {
+	if err = l.processOrderByType(ctx, orderInfo); err != nil {
 		logger.WithContext(ctx).Error("[ActivateOrderLogic] Process task failed", logger.Field("error", err.Error()))
 		return nil
 	}
@@ -90,7 +87,7 @@ func (l *ActivateOrderLogic) ProcessTask(ctx context.Context, task *asynq.Task)
 	return nil
 }
 
-// parsePayload unmarshals the task payload into a structured format
+// parsePayload unMarshals the task payload into a structured format
 func (l *ActivateOrderLogic) parsePayload(ctx context.Context, payload []byte) (*types.ForthwithActivateOrderPayload, error) {
 	var p types.ForthwithActivateOrderPayload
 	if err := json.Unmarshal(payload, &p); err != nil {
@@ -185,7 +182,7 @@ func (l *ActivateOrderLogic) NewPurchase(ctx context.Context, orderInfo *order.O
 	}
 
 	// Handle commission in separate goroutine to avoid blocking
-	go l.handleCommission(context.Background(), userInfo, orderInfo, true)
+	go l.handleCommission(context.Background(), userInfo, orderInfo)
 
 	// Clear cache
 	l.clearServerCache(ctx, sub)
@@ -280,8 +277,12 @@ func (l *ActivateOrderLogic) getTempOrderInfo(ctx context.Context, orderNo strin
 	}
 
 	var tempOrder constant.TemporaryOrderInfo
-	if err = json.Unmarshal([]byte(data), &tempOrder); err != nil {
-		logger.WithContext(ctx).Error("Unmarshal temp order failed", logger.Field("error", err.Error()))
+	if err = tempOrder.Unmarshal([]byte(data)); err != nil {
+		logger.WithContext(ctx).Error("Unmarshal temp order cache failed",
+			logger.Field("error", err.Error()),
+			logger.Field("cache_key", cacheKey),
+			logger.Field("data", data),
+		)
 		return nil, err
 	}
 
@@ -352,8 +353,8 @@ func (l *ActivateOrderLogic) createUserSubscription(ctx context.Context, orderIn
 
 // handleCommission processes referral commission for the referrer if applicable.
 // This runs asynchronously to avoid blocking the main order processing flow.
-func (l *ActivateOrderLogic) handleCommission(ctx context.Context, userInfo *user.User, orderInfo *order.Order, isNewPurchase bool) {
-	if !l.shouldProcessCommission(userInfo, orderInfo, isNewPurchase) {
+func (l *ActivateOrderLogic) handleCommission(ctx context.Context, userInfo *user.User, orderInfo *order.Order) {
+	if !l.shouldProcessCommission(userInfo, orderInfo.IsNew) {
 		return
 	}
 
@@ -366,21 +367,45 @@ func (l *ActivateOrderLogic) handleCommission(ctx context.Context, userInfo *use
 		return
 	}
 
-	amount := l.calculateCommission(orderInfo.Price)
+	var referralPercentage uint8
+	if referer.ReferralPercentage != 0 {
+		referralPercentage = referer.ReferralPercentage
+	} else {
+		referralPercentage = uint8(l.svc.Config.Invite.ReferralPercentage)
+	}
+
+	// Order commission calculation： (Order Amount - Order Fee) * Referral Percentage
+	amount := l.calculateCommission(orderInfo.Amount-orderInfo.FeeAmount, referralPercentage)
 
 	// Use transaction for commission updates
 	err = l.svc.DB.Transaction(func(tx *gorm.DB) error {
 		referer.Commission += amount
-		if err := l.svc.UserModel.Update(ctx, referer, tx); err != nil {
+		if err = l.svc.UserModel.Update(ctx, referer, tx); err != nil {
 			return err
 		}
 
-		commissionLog := &user.CommissionLog{
-			UserId:  referer.Id,
-			OrderNo: orderInfo.OrderNo,
-			Amount:  amount,
+		var commissionType uint16
+		switch orderInfo.Type {
+		case OrderTypeSubscribe:
+			commissionType = log.CommissionTypePurchase
+		case OrderTypeRenewal:
+			commissionType = log.CommissionTypeRenewal
 		}
-		return l.svc.UserModel.InsertCommissionLog(ctx, commissionLog, tx)
+
+		commissionLog := &log.Commission{
+			Type:      commissionType,
+			Amount:    amount,
+			OrderNo:   orderInfo.OrderNo,
+			Timestamp: orderInfo.CreatedAt.UnixMilli(),
+		}
+
+		content, _ := commissionLog.Marshal()
+		return tx.Model(&log.SystemLog{}).Create(&log.SystemLog{
+			Type:     log.TypeCommission.Uint8(),
+			Date:     time.Now().Format("2006-01-02"),
+			ObjectID: referer.Id,
+			Content:  string(content),
+		}).Error
 	})
 
 	if err != nil {
@@ -389,7 +414,7 @@ func (l *ActivateOrderLogic) handleCommission(ctx context.Context, userInfo *use
 	}
 
 	// Update cache
-	if err := l.svc.UserModel.UpdateUserCache(ctx, referer); err != nil {
+	if err = l.svc.UserModel.UpdateUserCache(ctx, referer); err != nil {
 		logger.WithContext(ctx).Error("Update referer cache failed",
 			logger.Field("error", err.Error()),
 			logger.Field("user_id", referer.Id),
@@ -399,47 +424,60 @@ func (l *ActivateOrderLogic) handleCommission(ctx context.Context, userInfo *use
 
 // shouldProcessCommission determines if commission should be processed based on
 // referrer existence, commission settings, and order type
-func (l *ActivateOrderLogic) shouldProcessCommission(userInfo *user.User, orderInfo *order.Order, isNewPurchase bool) bool {
-	return userInfo.RefererId != 0 &&
-		l.svc.Config.Invite.ReferralPercentage != 0 &&
-		(!l.svc.Config.Invite.OnlyFirstPurchase || (isNewPurchase && orderInfo.IsNew))
+func (l *ActivateOrderLogic) shouldProcessCommission(userInfo *user.User, isFirstPurchase bool) bool {
+	if userInfo == nil || userInfo.RefererId == 0 {
+		return false
+	}
+
+	referer, err := l.svc.UserModel.FindOne(context.Background(), userInfo.RefererId)
+	if err != nil {
+		logger.Errorw("Find referer failed",
+			logger.Field("error", err.Error()),
+			logger.Field("referer_id", userInfo.RefererId))
+		return false
+	}
+	if referer == nil {
+		return false
+	}
+
+	// use referer's custom settings if set
+	if referer.ReferralPercentage > 0 {
+		if referer.OnlyFirstPurchase != nil && *referer.OnlyFirstPurchase && !isFirstPurchase {
+			return false
+		}
+		return true
+	}
+
+	// use global settings
+	if l.svc.Config.Invite.ReferralPercentage == 0 {
+		return false
+	}
+	if l.svc.Config.Invite.OnlyFirstPurchase && !isFirstPurchase {
+		return false
+	}
+
+	return true
 }
 
 // calculateCommission computes the commission amount based on order price and referral percentage
-func (l *ActivateOrderLogic) calculateCommission(price int64) int64 {
-	return int64(float64(price) * (float64(l.svc.Config.Invite.ReferralPercentage) / 100))
+func (l *ActivateOrderLogic) calculateCommission(price int64, percentage uint8) int64 {
+	return int64(float64(price) * (float64(percentage) / 100))
 }
 
 // clearServerCache clears user list cache for all servers associated with the subscription
 func (l *ActivateOrderLogic) clearServerCache(ctx context.Context, sub *subscribe.Subscribe) {
-	serverIds := tool.StringToInt64Slice(sub.Server)
-	groupServerIds := l.getServerIdsByGroups(ctx, sub.ServerGroup)
-	allServerIds := append(serverIds, groupServerIds...)
+	nodeIds := tool.StringToInt64Slice(sub.Nodes)
+	tags := strings.Split(sub.NodeTags, ",")
 
-	for _, id := range allServerIds {
-		cacheKey := fmt.Sprintf("%s%d", config.ServerUserListCacheKey, id)
-		if err := l.svc.Redis.Del(ctx, cacheKey).Err(); err != nil {
-			logger.WithContext(ctx).Error("Del server user list cache failed",
-				logger.Field("error", err.Error()),
-				logger.Field("cache_key", cacheKey),
-			)
-		}
-	}
-}
-
-// getServerIdsByGroups retrieves server IDs from server groups
-func (l *ActivateOrderLogic) getServerIdsByGroups(ctx context.Context, serverGroup string) []int64 {
-	data, err := l.svc.ServerModel.FindServerListByGroupIds(ctx, tool.StringToInt64Slice(serverGroup))
+	err := l.svc.NodeModel.ClearNodeCache(ctx, &node.FilterNodeParams{
+		Page:     1,
+		Size:     1000,
+		ServerId: nodeIds,
+		Tag:      tags,
+	})
 	if err != nil {
-		logger.WithContext(ctx).Error("Find server list failed", logger.Field("error", err.Error()))
-		return nil
+		logger.WithContext(ctx).Error("[Order Queue] Clear node cache failed", logger.Field("error", err.Error()))
 	}
-
-	serverIds := make([]int64, len(data))
-	for i, item := range data {
-		serverIds[i] = item.Id
-	}
-	return serverIds
 }
 
 // Renewal handles subscription renewal including subscription extension,
@@ -460,7 +498,7 @@ func (l *ActivateOrderLogic) Renewal(ctx context.Context, orderInfo *order.Order
 		return err
 	}
 
-	if err := l.updateSubscriptionForRenewal(ctx, userSub, sub, orderInfo); err != nil {
+	if err = l.updateSubscriptionForRenewal(ctx, userSub, sub, orderInfo); err != nil {
 		return err
 	}
 
@@ -478,7 +516,7 @@ func (l *ActivateOrderLogic) Renewal(ctx context.Context, orderInfo *order.Order
 	l.clearServerCache(ctx, sub)
 
 	// Handle commission
-	go l.handleCommission(context.Background(), userInfo, orderInfo, false)
+	go l.handleCommission(context.Background(), userInfo, orderInfo)
 
 	// Send notifications
 	l.sendNotifications(ctx, orderInfo, userInfo, sub, userSub, telegram.RenewalNotify)
@@ -573,6 +611,24 @@ func (l *ActivateOrderLogic) ResetTraffic(ctx context.Context, orderInfo *order.
 	// Clear cache
 	l.clearServerCache(ctx, sub)
 
+	// insert reset traffic log
+	resetLog := &log.ResetSubscribe{
+		Type:      log.ResetSubscribeTypePaid,
+		UserId:    userInfo.Id,
+		OrderNo:   orderInfo.OrderNo,
+		Timestamp: time.Now().UnixMilli(),
+	}
+
+	content, _ := resetLog.Marshal()
+	if err = l.svc.LogModel.Insert(ctx, &log.SystemLog{
+		Type:     log.TypeResetSubscribe.Uint8(),
+		Date:     time.Now().Format(time.DateOnly),
+		ObjectID: userSub.Id,
+		Content:  string(content),
+	}); err != nil {
+		logger.WithContext(ctx).Error("[Order Queue]Insert reset subscribe log failed", logger.Field("error", err.Error()))
+	}
+
 	// Send notifications
 	l.sendNotifications(ctx, orderInfo, userInfo, sub, userSub, telegram.ResetTrafficNotify)
 
@@ -590,22 +646,35 @@ func (l *ActivateOrderLogic) Recharge(ctx context.Context, orderInfo *order.Orde
 	// Update balance in transaction
 	err = l.svc.DB.Transaction(func(tx *gorm.DB) error {
 		userInfo.Balance += orderInfo.Price
-		if err := l.svc.UserModel.Update(ctx, userInfo, tx); err != nil {
+		if err = l.svc.UserModel.Update(ctx, userInfo, tx); err != nil {
 			return err
 		}
 
-		balanceLog := &user.BalanceLog{
-			UserId:  orderInfo.UserId,
-			Amount:  orderInfo.Price,
-			Type:    CommissionTypeRecharge,
-			OrderId: orderInfo.Id,
-			Balance: userInfo.Balance,
+		balanceLog := &log.Balance{
+			Amount:    orderInfo.Price,
+			Type:      log.BalanceTypeRecharge,
+			OrderNo:   orderInfo.OrderNo,
+			Balance:   userInfo.Balance,
+			Timestamp: time.Now().UnixMilli(),
 		}
-		return l.svc.UserModel.InsertBalanceLog(ctx, balanceLog, tx)
+		content, _ := balanceLog.Marshal()
+
+		return tx.Model(&log.Balance{}).Create(&log.SystemLog{
+			Type:     log.TypeBalance.Uint8(),
+			Date:     time.Now().Format("2006-01-02"),
+			ObjectID: userInfo.Id,
+			Content:  string(content),
+		}).Error
 	})
 
 	if err != nil {
-		logger.WithContext(ctx).Error("Database transaction failed", logger.Field("error", err.Error()))
+		logger.WithContext(ctx).Error("[Recharge] Database transaction failed", logger.Field("error", err.Error()))
+		return err
+	}
+
+	// clear user cache
+	if err = l.svc.UserModel.UpdateUserCache(ctx, userInfo); err != nil {
+		logger.WithContext(ctx).Error("[Recharge] Update user cache failed", logger.Field("error", err.Error()))
 		return err
 	}
 

queue/logic/sms/sendSmsLogic.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"time"
 
 	"github.com/perfect-panel/server/pkg/logger"
 
@@ -43,17 +44,16 @@ func (l *SendSmsLogic) ProcessTask(ctx context.Context, task *asynq.Task) error
 		logger.WithContext(ctx).Error("[SendSmsLogic] New send sms client failed", logger.Field("error", err.Error()), logger.Field("payload", payload))
 		return err
 	}
-	createSms := &log.MessageLog{
-		Type:     log.Mobile.String(),
+	createSms := &log.Message{
 		Platform: l.svcCtx.Config.Mobile.Platform,
 		To:       fmt.Sprintf("+%s%s", payload.TelephoneArea, payload.Telephone),
 		Subject:  constant.ParseVerifyType(payload.Type).String(),
-		Content:  "",
+		Content: map[string]interface{}{
+			"content": client.GetSendCodeContent(payload.Content),
+		},
 	}
 	err = client.SendCode(payload.TelephoneArea, payload.Telephone, payload.Content)
 
-	createSms.Content = client.GetSendCodeContent(payload.Content)
-
 	if err != nil {
 		logger.WithContext(ctx).Error("[SendSmsLogic] Send sms failed", logger.Field("error", err.Error()), logger.Field("payload", payload))
 		if l.svcCtx.Config.Model != constant.DevMode {
@@ -64,7 +64,14 @@ func (l *SendSmsLogic) ProcessTask(ctx context.Context, task *asynq.Task) error
 	}
 	createSms.Status = 1
 	logger.WithContext(ctx).Info("[SendSmsLogic] Send sms", logger.Field("telephone", payload.Telephone), logger.Field("content", createSms.Content))
-	err = l.svcCtx.LogModel.InsertMessageLog(ctx, createSms)
+
+	content, _ := createSms.Marshal()
+	err = l.svcCtx.LogModel.Insert(ctx, &log.SystemLog{
+		Type:     log.TypeMobileMessage.Uint8(),
+		Date:     time.Now().Format("2006-01-02"),
+		ObjectID: 0,
+		Content:  string(content),
+	})
 	if err != nil {
 		logger.WithContext(ctx).Error("[SendSmsLogic] Send sms failed", logger.Field("error", err.Error()), logger.Field("payload", payload))
 		return nil

queue/logic/subscription/checkSubscriptionLogic.go

@@ -1,12 +1,13 @@
 package subscription
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
-	"text/template"
+	"strings"
 	"time"
 
+	"github.com/perfect-panel/server/internal/model/node"
+	"github.com/perfect-panel/server/pkg/tool"
 	queue "github.com/perfect-panel/server/queue/types"
 
 	"github.com/perfect-panel/server/pkg/logger"
@@ -62,7 +63,7 @@ func (l *CheckSubscriptionLogic) ProcessTask(ctx context.Context, _ *asynq.Task)
 					return err
 				}
 			}
-
+			l.clearServerCache(ctx, list...)
 			logger.Infow("[Check Subscription Traffic] Update subscribe status", logger.Field("user_ids", ids), logger.Field("count", int64(len(ids))))
 
 		} else {
@@ -104,6 +105,8 @@ func (l *CheckSubscriptionLogic) ProcessTask(ctx context.Context, _ *asynq.Task)
 				logger.Errorw("[Check Subscription Traffic] Clear subscribe cache failed", logger.Field("error", err.Error()))
 				return err
 			}
+			l.clearServerCache(ctx, list...)
+
 			logger.Info("[Check Subscription Expire] Update subscribe status", logger.Field("user_ids", ids), logger.Field("count", int64(len(ids))))
 		} else {
 			logger.Info("[Check Subscription Expire] No subscribe need to update")
@@ -129,24 +132,14 @@ func (l *CheckSubscriptionLogic) sendExpiredNotify(ctx context.Context, subs []i
 			continue
 		}
 		var taskPayload queue.SendEmailPayload
+		taskPayload.Type = queue.EmailTypeExpiration
 		taskPayload.Email = method.AuthIdentifier
 		taskPayload.Subject = "Subscription Expired"
-		tpl, err := template.New("Expired").Parse(l.svc.Config.Email.ExpirationEmailTemplate)
-		if err != nil {
-			logger.Errorw("[CheckSubscription] Parse template failed", logger.Field("error", err.Error()))
-			continue
-		}
-		var result bytes.Buffer
-		err = tpl.Execute(&result, map[string]interface{}{
+		taskPayload.Content = map[string]interface{}{
 			"SiteLogo":   l.svc.Config.Site.SiteLogo,
 			"SiteName":   l.svc.Config.Site.SiteName,
 			"ExpireDate": sub.ExpireTime.Format("2006-01-02 15:04:05"),
-		})
-		if err != nil {
-			logger.Errorw("[CheckSubscription] Execute template failed", logger.Field("error", err.Error()))
-			continue
 		}
-		taskPayload.Content = result.String()
 		payloadBuy, err := json.Marshal(taskPayload)
 		if err != nil {
 			logger.Errorw("[CheckSubscription] Marshal payload failed", logger.Field("error", err.Error()))
@@ -179,23 +172,13 @@ func (l *CheckSubscriptionLogic) sendTrafficNotify(ctx context.Context, subs []i
 			continue
 		}
 		var taskPayload queue.SendEmailPayload
+		taskPayload.Type = queue.EmailTypeTrafficExceed
 		taskPayload.Email = method.AuthIdentifier
 		taskPayload.Subject = "Subscription Traffic Exceed"
-		tpl, err := template.New("Traffic").Parse(l.svc.Config.Email.TrafficExceedEmailTemplate)
-		if err != nil {
-			logger.Errorw("[CheckSubscription] Parse template failed", logger.Field("error", err.Error()))
-			continue
-		}
-		var result bytes.Buffer
-		err = tpl.Execute(&result, map[string]interface{}{
+		taskPayload.Content = map[string]interface{}{
 			"SiteLogo": l.svc.Config.Site.SiteLogo,
 			"SiteName": l.svc.Config.Site.SiteName,
-		})
-		if err != nil {
-			logger.Errorw("[CheckSubscription] Execute template failed", logger.Field("error", err.Error()))
-			continue
 		}
-		taskPayload.Content = result.String()
 		payloadBuy, err := json.Marshal(taskPayload)
 		if err != nil {
 			logger.Errorw("[CheckSubscription] Marshal payload failed", logger.Field("error", err.Error()))
@@ -214,3 +197,41 @@ func (l *CheckSubscriptionLogic) sendTrafficNotify(ctx context.Context, subs []i
 	}
 	return nil
 }
+
+func (l *CheckSubscriptionLogic) clearServerCache(ctx context.Context, userSubs ...*user.Subscribe) {
+	subs := make(map[int64]bool)
+	for _, sub := range userSubs {
+		if _, ok := subs[sub.SubscribeId]; !ok {
+			subs[sub.SubscribeId] = true
+		}
+	}
+
+	for sub, _ := range subs {
+		info, err := l.svc.SubscribeModel.FindOne(ctx, sub)
+		if err != nil {
+			logger.Errorw("[CheckSubscription] FindOne subscribe failed", logger.Field("error", err.Error()), logger.Field("subscribe_id", sub))
+			continue
+		}
+		if info != nil && info.Id == sub {
+			var nodes []int64
+			if info.Nodes != "" {
+				nodes = tool.StringToInt64Slice(info.Nodes)
+			}
+			var tag []string
+			if info.NodeTags != "" {
+				tag = strings.Split(info.NodeTags, ",")
+			}
+
+			err = l.svc.NodeModel.ClearNodeCache(ctx, &node.FilterNodeParams{
+				Page:     1,
+				Size:     1000,
+				Tag:      tag,
+				ServerId: nodes,
+			})
+			if err != nil {
+				logger.Errorw("[CheckSubscription] ClearNodeCache failed", logger.Field("error", err.Error()), logger.Field("subscribe_id", sub))
+				continue
+			}
+		}
+	}
+}

queue/logic/task/quotaLogic.go

@@ -0,0 +1,450 @@
+package task
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/hibiken/asynq"
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/internal/model/order"
+	"github.com/perfect-panel/server/internal/model/subscribe"
+	"github.com/perfect-panel/server/internal/model/task"
+	"github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/tool"
+	"gorm.io/gorm"
+)
+
+const (
+	UnitTimeNoLimit = "NoLimit" // Unlimited time subscription
+	UnitTimeYear    = "Year"    // Annual subscription
+	UnitTimeMonth   = "Month"   // Monthly subscription
+	UnitTimeDay     = "Day"     // Daily subscription
+	UnitTimeHour    = "Hour"    // Hourly subscription
+	UnitTimeMinute  = "Minute"  // Per-minute subscription
+
+)
+
+type QuotaTaskLogic struct {
+	svcCtx *svc.ServiceContext
+}
+
+type ErrorInfo struct {
+	UserSubscribeId int64  `json:"user_subscribe_id"`
+	Error           string `json:"error"`
+}
+
+func NewQuotaTaskLogic(svcCtx *svc.ServiceContext) *QuotaTaskLogic {
+	return &QuotaTaskLogic{
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QuotaTaskLogic) ProcessTask(ctx context.Context, t *asynq.Task) error {
+	taskID, err := l.parseTaskID(ctx, t.Payload())
+	if err != nil {
+		return err
+	}
+
+	taskInfo, err := l.getTaskInfo(ctx, taskID)
+	if err != nil {
+		return err
+	}
+
+	if taskInfo.Status != 0 {
+		logger.WithContext(ctx).Info("[QuotaTaskLogic.ProcessTask] task already processed",
+			logger.Field("taskID", taskID),
+			logger.Field("status", taskInfo.Status),
+		)
+		return nil
+	}
+
+	scope, content, err := l.parseTaskData(ctx, taskInfo)
+	if err != nil {
+		return err
+	}
+
+	subscribes, err := l.getSubscribes(ctx, scope.Objects)
+	if err != nil {
+		return err
+	}
+	if err = l.processSubscribes(ctx, subscribes, content, taskInfo); err != nil {
+		return err
+	}
+	// 清理用户缓存（仅在有赠送金时清理）
+	if content.GiftValue != 0 {
+		var userIds []int64
+		for _, sub := range subscribes {
+			userIds = append(userIds, sub.UserId)
+		}
+		userIds = tool.RemoveDuplicateElements(userIds...)
+		var users []*user.User
+		if err = l.svcCtx.DB.WithContext(ctx).Model(&user.User{}).Where("id IN ?", userIds).Find(&users).Error; err != nil {
+			logger.WithContext(ctx).Error("[QuotaTaskLogic.ProcessTask] find users error",
+				logger.Field("error", err.Error()),
+				logger.Field("userIDs", userIds))
+		}
+		err = l.svcCtx.UserModel.ClearUserCache(ctx, users...)
+		if err != nil {
+			logger.WithContext(ctx).Error("[QuotaTaskLogic.ProcessTask] clear user cache error",
+				logger.Field("error", err.Error()),
+				logger.Field("userIDs", userIds))
+		}
+	}
+
+	// 清理用户订阅缓存
+	err = l.svcCtx.UserModel.ClearSubscribeCache(ctx, subscribes...)
+	if err != nil {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.ProcessTask] clear subscribe cache error",
+			logger.Field("error", err.Error()))
+	}
+
+	return nil
+}
+
+func (l *QuotaTaskLogic) parseTaskID(ctx context.Context, payload []byte) (int64, error) {
+	if len(payload) == 0 {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.parseTaskID] empty payload")
+		return 0, asynq.SkipRetry
+	}
+
+	taskID, err := strconv.ParseInt(string(payload), 10, 64)
+	if err != nil {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.parseTaskID] invalid task ID",
+			logger.Field("error", err.Error()),
+			logger.Field("payload", string(payload)),
+		)
+		return 0, asynq.SkipRetry
+	}
+	return taskID, nil
+}
+
+func (l *QuotaTaskLogic) getTaskInfo(ctx context.Context, taskID int64) (*task.Task, error) {
+	var taskInfo *task.Task
+	if err := l.svcCtx.DB.WithContext(ctx).Model(&task.Task{}).Where("id = ?", taskID).First(&taskInfo).Error; err != nil {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.getTaskInfo] find task error",
+			logger.Field("error", err.Error()),
+			logger.Field("taskID", taskID),
+		)
+		return nil, asynq.SkipRetry
+	}
+	return taskInfo, nil
+}
+
+func (l *QuotaTaskLogic) parseTaskData(ctx context.Context, taskInfo *task.Task) (task.QuotaScope, task.QuotaContent, error) {
+	var scope task.QuotaScope
+	if err := scope.Unmarshal([]byte(taskInfo.Scope)); err != nil {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.parseTaskData] unmarshal scope error",
+			logger.Field("error", err.Error()),
+		)
+		return scope, task.QuotaContent{}, asynq.SkipRetry
+	}
+
+	var content task.QuotaContent
+	if err := content.Unmarshal([]byte(taskInfo.Content)); err != nil {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.parseTaskData] unmarshal content error",
+			logger.Field("error", err.Error()),
+		)
+		return scope, content, asynq.SkipRetry
+	}
+	return scope, content, nil
+}
+
+func (l *QuotaTaskLogic) getSubscribes(ctx context.Context, subscriberIDs []int64) ([]*user.Subscribe, error) {
+	var subscribes []*user.Subscribe
+	if err := l.svcCtx.DB.WithContext(ctx).Model(&user.Subscribe{}).Where("id IN ?", subscriberIDs).Find(&subscribes).Error; err != nil {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.getSubscribes] find subscribes error",
+			logger.Field("error", err.Error()),
+			logger.Field("subscribers", subscriberIDs),
+		)
+		return nil, asynq.SkipRetry
+	}
+	return subscribes, nil
+}
+
+func (l *QuotaTaskLogic) processSubscribes(ctx context.Context, subscribes []*user.Subscribe, content task.QuotaContent, taskInfo *task.Task) error {
+	tx := l.svcCtx.DB.WithContext(ctx).Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+			logger.WithContext(ctx).Error("[QuotaTaskLogic.processSubscribes] transaction panic",
+				logger.Field("panic", r),
+			)
+		}
+	}()
+
+	var errors []ErrorInfo
+	now := time.Now()
+
+	for _, sub := range subscribes {
+		if err := l.processSubscription(tx, sub, content, now, &errors); err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+
+	// 根据错误情况决定任务状态
+	status := int8(2) // Completed
+	if len(errors) > 0 {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.processSubscribes] some subscriptions failed",
+			logger.Field("total", len(subscribes)),
+			logger.Field("failed", len(errors)),
+		)
+		// 如果所有订阅都失败，标记为失败状态
+		if len(errors) == len(subscribes) {
+			status = 3 // Failed
+		}
+		errs, err := json.Marshal(errors)
+		if err != nil {
+			logger.WithContext(ctx).Error("[QuotaTaskLogic.processSubscribes] marshal errors failed",
+				logger.Field("error", err.Error()),
+			)
+			tx.Rollback()
+			return err
+		}
+		taskInfo.Errors = string(errs)
+	}
+
+	taskInfo.Current = uint64(len(subscribes))
+	taskInfo.Status = status
+	err := tx.Where("id = ?", taskInfo.Id).Save(taskInfo).Error
+	if err != nil {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.processSubscribes] update task status error",
+			logger.Field("error", err.Error()),
+			logger.Field("taskID", taskInfo.Id),
+		)
+		tx.Rollback()
+		return err
+	}
+
+	if err = tx.Commit().Error; err != nil {
+		logger.WithContext(ctx).Error("[QuotaTaskLogic.processSubscribes] commit transaction error",
+			logger.Field("error", err.Error()),
+		)
+		return err
+	}
+
+	return nil
+}
+
+func (l *QuotaTaskLogic) processSubscription(tx *gorm.DB, sub *user.Subscribe, content task.QuotaContent, now time.Time, errors *[]ErrorInfo) error {
+	// 验证订阅数据
+	if sub == nil {
+		*errors = append(*errors, ErrorInfo{
+			UserSubscribeId: 0,
+			Error:           "subscription is nil",
+		})
+		return nil
+	}
+
+	updated := false
+
+	// 处理时间延长 - 修复逻辑：只要Days不为0就处理，不管ExpireTime是否为0
+	if content.Days != 0 {
+		if sub.ExpireTime.Unix() == 0 || sub.ExpireTime.Before(now) {
+			// 如果没有过期时间或已过期，从现在开始计算
+			sub.ExpireTime = now.AddDate(0, 0, int(content.Days))
+		} else {
+			// 在原有过期时间基础上延长
+			sub.ExpireTime = sub.ExpireTime.AddDate(0, 0, int(content.Days))
+		}
+		// 如果订阅延长到未来时间，设置为激活状态
+		if sub.ExpireTime.After(now) && sub.Status != 1 {
+			sub.Status = 1 // Active
+		}
+		updated = true
+	}
+
+	// 处理流量重置
+	if content.ResetTraffic {
+		sub.Download = 0
+		sub.Upload = 0
+		updated = true
+		if err := l.createResetTrafficLog(tx, sub.Id, sub.UserId, now); err != nil {
+			// 记录错误但不阻断整个任务,日志失败不影响主流程
+			*errors = append(*errors, ErrorInfo{
+				UserSubscribeId: sub.Id,
+				Error:           "create reset traffic log error: " + err.Error(),
+			})
+		}
+	}
+
+	// 处理赠送金
+	if content.GiftValue != 0 {
+		if err := l.processGift(tx, sub, content, now, errors); err != nil {
+			return err
+		}
+	}
+
+	// 只有在有更新时才保存订阅信息
+	if updated {
+		if err := tx.Where("id = ?", sub.Id).Save(sub).Error; err != nil {
+			*errors = append(*errors, ErrorInfo{
+				UserSubscribeId: sub.Id,
+				Error:           "update subscription error: " + err.Error(),
+			})
+			return nil
+		}
+	}
+
+	return nil
+}
+
+func (l *QuotaTaskLogic) processGift(tx *gorm.DB, sub *user.Subscribe, content task.QuotaContent, now time.Time, errors *[]ErrorInfo) error {
+	// 验证赠送类型
+	if content.GiftType != 1 && content.GiftType != 2 {
+		*errors = append(*errors, ErrorInfo{
+			UserSubscribeId: sub.Id,
+			Error:           fmt.Sprintf("invalid gift type: %d", content.GiftType),
+		})
+		return nil
+	}
+
+	var userInfo user.User
+	if err := tx.Model(&user.User{}).Where("id = ?", sub.UserId).First(&userInfo).Error; err != nil {
+		*errors = append(*errors, ErrorInfo{
+			UserSubscribeId: sub.Id,
+			Error:           "find user error: " + err.Error(),
+		})
+		return nil
+	}
+
+	var giftAmount int64
+	switch content.GiftType {
+	case 1:
+		giftAmount = int64(content.GiftValue)
+	case 2:
+		orderAmount, err := l.calculateOrderAmount(tx, sub, now)
+		if err != nil {
+			*errors = append(*errors, ErrorInfo{
+				UserSubscribeId: sub.Id,
+				Error:           err.Error(),
+			})
+			return nil
+		}
+		if orderAmount > 0 {
+			giftAmount = int64(float64(orderAmount) * (float64(content.GiftValue) / 100))
+		}
+	}
+
+	if giftAmount > 0 {
+		userInfo.GiftAmount += giftAmount
+		// 使用Update而不是Save，更精确地更新单个字段
+		if err := tx.Model(&user.User{}).Where("id = ?", sub.UserId).Update("gift_amount", userInfo.GiftAmount).Error; err != nil {
+			*errors = append(*errors, ErrorInfo{
+				UserSubscribeId: sub.Id,
+				Error:           "update user gift amount error: " + err.Error(),
+			})
+			return nil
+		}
+
+		if err := l.createGiftLog(tx, sub.Id, userInfo.Id, giftAmount, userInfo.GiftAmount, now); err != nil {
+			*errors = append(*errors, ErrorInfo{
+				UserSubscribeId: sub.Id,
+				Error:           "create gift log error: " + err.Error(),
+			})
+			// 回滚用户金额更新
+			userInfo.GiftAmount -= giftAmount
+			tx.Model(&user.User{}).Where("id = ?", sub.UserId).Update("gift_amount", userInfo.GiftAmount)
+			return nil
+		}
+	}
+
+	return nil
+}
+
+func (l *QuotaTaskLogic) getStartTime(sub *user.Subscribe, now time.Time) time.Time {
+	if sub.StartTime.Unix() == 0 {
+		return now
+	}
+	return sub.StartTime
+}
+
+func (l *QuotaTaskLogic) calculateOrderAmount(tx *gorm.DB, sub *user.Subscribe, now time.Time) (int64, error) {
+	if sub.OrderId != 0 {
+		var orderInfo *order.Order
+		if err := tx.Model(&order.Order{}).Where("id = ?", sub.OrderId).First(&orderInfo).Error; err != nil {
+			return 0, fmt.Errorf("find order error: %v", err)
+		}
+		return orderInfo.Amount + orderInfo.GiftAmount, nil
+	}
+
+	var subInfo *subscribe.Subscribe
+	if err := tx.Model(&subscribe.Subscribe{}).Where("id = ?", sub.SubscribeId).First(&subInfo).Error; err != nil {
+		return 0, fmt.Errorf("find subscribe error: %v", err)
+	}
+
+	startTime := l.getStartTime(sub, now)
+	if sub.ExpireTime.Before(startTime) {
+		return subInfo.UnitPrice, nil
+	}
+
+	switch subInfo.UnitTime {
+	case UnitTimeNoLimit:
+		return subInfo.UnitPrice, nil
+	case UnitTimeYear:
+		days := tool.DayDiff(startTime, sub.ExpireTime)
+		return subInfo.UnitPrice / 365 * days, nil
+	case UnitTimeMonth:
+		days := tool.DayDiff(startTime, sub.ExpireTime)
+		return subInfo.UnitPrice / 30 * days, nil
+	case UnitTimeDay:
+		days := tool.DayDiff(startTime, sub.ExpireTime)
+		return subInfo.UnitPrice * days, nil
+	case UnitTimeHour:
+		hours := int(tool.HourDiff(startTime, sub.ExpireTime))
+		return subInfo.UnitPrice * int64(hours), nil
+	case UnitTimeMinute:
+		minutes := tool.HourDiff(startTime, sub.ExpireTime) * 60
+		return subInfo.UnitPrice * minutes, nil
+	default:
+		return subInfo.UnitPrice, nil
+	}
+}
+
+func (l *QuotaTaskLogic) createGiftLog(tx *gorm.DB, subscribeId, userId, amount, balance int64, now time.Time) error {
+	giftLog := &log.Gift{
+		Type:        log.GiftTypeIncrease,
+		OrderNo:     "",
+		SubscribeId: subscribeId,
+		Amount:      amount,
+		Balance:     balance,
+		Remark:      "Quota task gift",
+		Timestamp:   now.UnixMilli(),
+	}
+
+	logString, err := giftLog.Marshal()
+	if err != nil {
+		return fmt.Errorf("marshal gift log error: %v", err)
+	}
+	return tx.Model(&log.SystemLog{}).Create(&log.SystemLog{
+		Type:     log.TypeGift.Uint8(),
+		Content:  string(logString),
+		ObjectID: userId,
+		Date:     now.Format(time.DateOnly),
+	}).Error
+}
+
+func (l *QuotaTaskLogic) createResetTrafficLog(tx *gorm.DB, subscribeId, userId int64, now time.Time) error {
+	trafficLog := &log.ResetSubscribe{
+		Type:      log.ResetSubscribeTypeQuota,
+		UserId:    userId,
+		OrderNo:   "",
+		Timestamp: now.UnixMilli(),
+	}
+
+	logString, err := trafficLog.Marshal()
+	if err != nil {
+		return fmt.Errorf("marshal traffic log error: %v", err)
+	}
+	return tx.Model(&log.SystemLog{}).Create(&log.SystemLog{
+		Type:     log.TypeResetSubscribe.Uint8(),
+		Content:  string(logString),
+		ObjectID: subscribeId,
+		Date:     now.Format(time.DateOnly),
+	}).Error
+}

queue/logic/traffic/resetTrafficLogic.go

@@ -8,10 +8,13 @@ import (
 	"strings"
 	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/internal/model/node"
 	"github.com/perfect-panel/server/internal/model/subscribe"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/tool"
 	"github.com/perfect-panel/server/queue/types"
 
 	"github.com/hibiken/asynq"
@@ -116,13 +119,6 @@ func (l *ResetTrafficLogic) ProcessTask(ctx context.Context, _ *asynq.Task) erro
 		}
 	}()
 
-	// Reset today's traffic data
-	err = l.svc.NodeCache.ResetTodayTrafficData(ctx)
-	if err != nil {
-		logger.Errorw("[ResetTodayTraffic] Failed to reset today traffic data",
-			logger.Field("error", err.Error()))
-	}
-
 	// Load last reset time from cache
 	var cache resetTrafficCache
 	cacheData, err := l.svc.Redis.Get(ctx, cacheKey).Result()
@@ -237,8 +233,10 @@ func (l *ResetTrafficLogic) resetMonth(ctx context.Context) error {
 
 			err = db.Model(&user.Subscribe{}).Where("`id` IN ?", monthlyResetUsers).
 				Updates(map[string]interface{}{
-					"upload":   0,
-					"download": 0,
+					"upload":      0,
+					"download":    0,
+					"status":      1, // Ensure status is active
+					"finished_at": nil,
 				}).Error
 			if err != nil {
 				logger.Errorw("[ResetTraffic] Failed to update monthly reset users", logger.Field("error", err.Error()))
@@ -252,16 +250,7 @@ func (l *ResetTrafficLogic) resetMonth(ctx context.Context) error {
 				return err
 			}
 			// Clear cache for these subscriptions
-			for _, sub := range userSubs {
-				if sub.SubscribeId > 0 {
-					err = l.svc.UserModel.ClearSubscribeCache(ctx, sub)
-					if err != nil {
-						logger.Errorw("[ResetTraffic] Failed to clear cache for subscription",
-							logger.Field("subscribeId", sub.SubscribeId),
-							logger.Field("error", err.Error()))
-					}
-				}
-			}
+			l.clearCache(ctx, userSubs)
 			logger.Infow("[ResetTraffic] Monthly reset completed", logger.Field("count", len(monthlyResetUsers)))
 		} else {
 			logger.Infow("[ResetTraffic] No users found for monthly reset")
@@ -329,8 +318,10 @@ func (l *ResetTrafficLogic) reset1st(ctx context.Context, cache resetTrafficCach
 			// Reset upload and download traffic to zero
 			err = db.Model(&user.Subscribe{}).Where("`id` IN ?", users1stReset).
 				Updates(map[string]interface{}{
-					"upload":   0,
-					"download": 0,
+					"upload":      0,
+					"download":    0,
+					"status":      1, // Ensure status is active
+					"finished_at": nil,
 				}).Error
 			if err != nil {
 				logger.Errorw("[ResetTraffic] Failed to update 1st reset users", logger.Field("error", err.Error()))
@@ -344,17 +335,7 @@ func (l *ResetTrafficLogic) reset1st(ctx context.Context, cache resetTrafficCach
 			}
 
 			// Clear cache for these subscriptions
-			for _, sub := range userSubs {
-				if sub.SubscribeId > 0 {
-					err = l.svc.UserModel.ClearSubscribeCache(ctx, sub)
-					if err != nil {
-						logger.Errorw("[ResetTraffic] Failed to clear cache for subscription",
-							logger.Field("subscribeId", sub.SubscribeId),
-							logger.Field("error", err.Error()))
-					}
-				}
-			}
-
+			l.clearCache(ctx, userSubs)
 			logger.Infow("[ResetTraffic] 1st reset completed", logger.Field("count", len(users1stReset)))
 		} else {
 			logger.Infow("[ResetTraffic] No users found for 1st reset")
@@ -423,8 +404,10 @@ func (l *ResetTrafficLogic) resetYear(ctx context.Context) error {
 			// Reset upload and download traffic to zero
 			err = db.Model(&user.Subscribe{}).Where("`id` IN ?", usersYearReset).
 				Updates(map[string]interface{}{
-					"upload":   0,
-					"download": 0,
+					"upload":      0,
+					"download":    0,
+					"status":      1, // Ensure status is active
+					"finished_at": nil,
 				}).Error
 			if err != nil {
 				logger.Errorw("[ResetTraffic] Failed to update yearly reset users", logger.Field("error", err.Error()))
@@ -438,16 +421,7 @@ func (l *ResetTrafficLogic) resetYear(ctx context.Context) error {
 				return err
 			}
 			// Clear cache for these subscriptions
-			for _, sub := range userSubs {
-				if sub.SubscribeId > 0 {
-					err = l.svc.UserModel.ClearSubscribeCache(ctx, sub)
-					if err != nil {
-						logger.Errorw("[ResetTraffic] Failed to clear cache for subscription",
-							logger.Field("subscribeId", sub.SubscribeId),
-							logger.Field("error", err.Error()))
-					}
-				}
-			}
+			l.clearCache(ctx, userSubs)
 			logger.Infow("[ResetTraffic] Yearly reset completed", logger.Field("count", len(usersYearReset)))
 		} else {
 			logger.Infow("[ResetTraffic] No users found for yearly reset")
@@ -601,3 +575,73 @@ func (l *ResetTrafficLogic) isRetryableError(err error) bool {
 		logger.Field("error", err.Error()))
 	return true
 }
+
+// clearCache clears the reset traffic cache
+func (l *ResetTrafficLogic) clearCache(ctx context.Context, list []*user.Subscribe) {
+	if len(list) != 0 {
+		subs := make(map[int64]bool)
+
+		for _, sub := range list {
+			if sub.SubscribeId > 0 {
+				err := l.svc.UserModel.ClearSubscribeCache(ctx, sub)
+				if err != nil {
+					logger.Errorw("[ResetTraffic] Failed to clear cache for subscription",
+						logger.Field("subscribeId", sub.SubscribeId),
+						logger.Field("error", err.Error()))
+				}
+				if _, ok := subs[sub.SubscribeId]; !ok {
+					subs[sub.SubscribeId] = true
+				}
+			}
+			// Insert traffic reset log
+			l.insertLog(ctx, sub.Id, sub.UserId)
+		}
+
+		for sub, _ := range subs {
+			info, err := l.svc.SubscribeModel.FindOne(ctx, sub)
+			if err != nil {
+				logger.Errorw("[CheckSubscription] FindOne subscribe failed", logger.Field("error", err.Error()), logger.Field("subscribe_id", sub))
+				continue
+			}
+			if info != nil && info.Id == sub {
+				var nodes []int64
+				if info.Nodes != "" {
+					nodes = tool.StringToInt64Slice(info.Nodes)
+				}
+				var tag []string
+				if info.NodeTags != "" {
+					tag = strings.Split(info.NodeTags, ",")
+				}
+
+				err = l.svc.NodeModel.ClearNodeCache(ctx, &node.FilterNodeParams{
+					Page:     1,
+					Size:     1000,
+					Tag:      tag,
+					ServerId: nodes,
+				})
+				if err != nil {
+					logger.Errorw("[CheckSubscription] ClearNodeCache failed", logger.Field("error", err.Error()), logger.Field("subscribe_id", sub))
+					continue
+				}
+			}
+		}
+	}
+}
+
+// insertLog inserts a reset traffic log entry
+func (l *ResetTrafficLogic) insertLog(ctx context.Context, subId, userId int64) {
+	trafficLog := log.ResetSubscribe{
+		Type:      log.ResetSubscribeTypeAuto,
+		UserId:    userId,
+		Timestamp: time.Now().UnixMilli(),
+	}
+	content, _ := trafficLog.Marshal()
+	if err := l.svc.DB.WithContext(ctx).Model(&log.SystemLog{}).Create(&log.SystemLog{
+		Type:     log.TypeResetSubscribe.Uint8(),
+		ObjectID: subId,
+		Date:     time.Now().Format(time.DateOnly),
+		Content:  string(content),
+	}).Error; err != nil {
+		logger.Errorw("[ResetTraffic] Failed to create system log for subscription", logger.Field("error", err.Error()))
+	}
+}

queue/logic/traffic/serverDataLogic.go

@@ -73,7 +73,7 @@ func (l *ServerDataLogic) getRanking(ctx context.Context) (top10ServerToday, top
 			if s.ServerId == 0 {
 				continue
 			}
-			serverInfo, err := l.svc.ServerModel.FindOne(ctx, s.ServerId)
+			serverInfo, err := l.svc.NodeModel.FindOneServer(ctx, s.ServerId)
 			if err != nil {
 				logger.Error("[ServerDataLogic] Find server failed", logger.Field("error", err.Error()))
 				continue
@@ -92,7 +92,7 @@ func (l *ServerDataLogic) getRanking(ctx context.Context) (top10ServerToday, top
 		logger.Error("[ServerDataLogic] Get top servers traffic by day failed", logger.Field("error", err.Error()))
 	} else {
 		for _, s := range serverYesterday {
-			serverInfo, err := l.svc.ServerModel.FindOne(ctx, s.ServerId)
+			serverInfo, err := l.svc.NodeModel.FindOneServer(ctx, s.ServerId)
 			if err != nil {
 				logger.Error("[ServerDataLogic] Find server failed", logger.Field("error", err.Error()))
 				continue

queue/logic/traffic/trafficStatLogic.go

@@ -0,0 +1,176 @@
+package traffic
+
+import (
+	"context"
+	"time"
+
+	"github.com/hibiken/asynq"
+	"github.com/perfect-panel/server/internal/model/log"
+	"github.com/perfect-panel/server/internal/model/traffic"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/pkg/logger"
+)
+
+type StatLogic struct {
+	svc *svc.ServiceContext
+}
+
+func NewStatLogic(svc *svc.ServiceContext) *StatLogic {
+	return &StatLogic{
+		svc: svc,
+	}
+}
+
+func (l *StatLogic) ProcessTask(ctx context.Context, _ *asynq.Task) error {
+	now := time.Now()
+	tx := l.svc.DB.Begin()
+	var err error
+	defer func(err error) {
+		if err != nil {
+			logger.Errorf("[Traffic Stat Queue] Process task failed: %v", err.Error())
+			tx.Rollback()
+		} else {
+			logger.Infof("[Traffic Stat Queue] Process task completed successfully, consuming: %s", time.Since(now).String())
+			// 提交事务
+			if err = tx.Commit().Error; err != nil {
+				logger.Errorf("[Traffic Stat Queue] Commit transaction failed: %v", err.Error())
+			}
+		}
+	}(err)
+
+	// 获取全部有效订阅
+	var userTraffic []log.UserTraffic
+	// 获取统计时间范围
+	start := time.Date(now.Year(), now.Month(), now.Day()-1, 0, 0, 0, 0, time.Local)
+	end := start.Add(24 * time.Hour).Add(-time.Nanosecond)
+
+	// 查询用户流量统计, 按用户和订阅分组
+	err = tx.WithContext(ctx).Model(&traffic.TrafficLog{}).
+		Select("user_id, subscribe_id, SUM(download + upload) AS total, SUM(download) AS download, SUM(upload) AS upload").
+		Where("timestamp BETWEEN ? AND ?", start, end).
+		Group("user_id, subscribe_id").
+		Order("total DESC").
+		Scan(&userTraffic).Error
+	if err != nil {
+		logger.Errorf("[Traffic Stat Queue] Query user traffic failed: %v", err.Error())
+		return err
+	}
+
+	date := start.Format(time.DateOnly)
+
+	userTop10 := log.UserTrafficRank{
+		Rank: make(map[uint8]log.UserTraffic),
+	}
+
+	// 更新用户流量统计
+	for i, trafficData := range userTraffic {
+		if i < 10 {
+			userTop10.Rank[uint8(i+1)] = trafficData
+		}
+		// 更新用户流量统计日志
+		content, _ := trafficData.Marshal()
+		err = tx.WithContext(ctx).Model(&log.SystemLog{}).Create(&log.SystemLog{
+			Type:     log.TypeSubscribeTraffic.Uint8(),
+			Date:     date,
+			ObjectID: trafficData.SubscribeId,
+			Content:  string(content),
+		}).Error
+		if err != nil {
+			logger.Errorf("[Traffic Stat Queue] Create user traffic log failed: %v", err.Error())
+			return err
+		}
+	}
+
+	userTop10Content, _ := userTop10.Marshal()
+
+	// 更新用户排行榜
+	err = tx.WithContext(ctx).Model(&log.SystemLog{}).Create(&log.SystemLog{
+		Type:     log.TypeUserTrafficRank.Uint8(),
+		Date:     date,
+		ObjectID: 0, // 0表示全局用户排行榜
+		Content:  string(userTop10Content),
+	}).Error
+	if err != nil {
+		logger.Errorf("[Traffic Stat Queue] Create user traffic rank log failed: %v", err.Error())
+		return err
+	}
+
+	// 统计服务器流量
+	var serverTraffic []log.ServerTraffic
+	err = tx.WithContext(ctx).Model(&traffic.TrafficLog{}).
+		Select("server_id, SUM(download + upload) AS total, SUM(download) AS download, SUM(upload) AS upload").
+		Where("timestamp BETWEEN ? AND ?", start, end).
+		Group("server_id").
+		Order("total DESC").
+		Scan(&serverTraffic).Error
+	if err != nil {
+		logger.Errorf("[Traffic Stat Queue] Query server traffic failed: %v", err.Error())
+		return err
+	}
+
+	serverTop10 := log.ServerTrafficRank{
+		Rank: make(map[uint8]log.ServerTraffic),
+	}
+	for i, trafficData := range serverTraffic {
+		if i < 10 {
+			serverTop10.Rank[uint8(i+1)] = trafficData
+		}
+		// 更新服务器流量统计日志
+		content, _ := trafficData.Marshal()
+		err = tx.WithContext(ctx).Model(&log.SystemLog{}).Create(&log.SystemLog{
+			Type:     log.TypeServerTraffic.Uint8(),
+			Date:     date,
+			ObjectID: trafficData.ServerId,
+			Content:  string(content),
+		}).Error
+		if err != nil {
+			logger.Errorf("[Traffic Stat Queue] Create server traffic log failed: %v", err.Error())
+			return err
+		}
+	}
+	serverTop10Content, _ := serverTop10.Marshal()
+	// 更新服务器排行榜
+	err = tx.WithContext(ctx).Model(&log.SystemLog{}).Create(&log.SystemLog{
+		Type:     log.TypeServerTrafficRank.Uint8(),
+		Date:     date,
+		ObjectID: 0, // 0表示全局服务器排行榜
+		Content:  string(serverTop10Content),
+	}).Error
+	if err != nil {
+		logger.Errorf("[Traffic Stat Queue] Create server traffic rank log failed: %v", err.Error())
+		return err
+	}
+
+	// traffic stat
+	var stat log.TrafficStat
+	err = tx.WithContext(ctx).Model(&traffic.TrafficLog{}).
+		Select("SUM(download + upload) AS total, SUM(download) AS download, SUM(upload) AS upload").
+		Where("timestamp BETWEEN ? AND ?", start, end).
+		Scan(&stat).Error
+	if err != nil {
+		logger.Errorf("[Traffic Stat Queue] Query traffic stat failed: %v", err.Error())
+		return err
+	}
+
+	// 更新流量统计日志
+	content, _ := stat.Marshal()
+	err = tx.WithContext(ctx).Model(&log.SystemLog{}).Create(&log.SystemLog{
+		Type:     log.TypeTrafficStat.Uint8(),
+		Date:     date,
+		ObjectID: 0,
+		Content:  string(content),
+	}).Error
+	if err != nil {
+		logger.Errorf("[Traffic Stat Queue] Create traffic stat log failed: %v", err.Error())
+		return err
+	}
+
+	// Delete old traffic logs
+	if l.svc.Config.Log.AutoClear {
+		err = tx.WithContext(ctx).Model(&traffic.TrafficLog{}).Where("created_at <= ?", end.AddDate(0, 0, int(-l.svc.Config.Log.ClearDays))).Delete(&traffic.TrafficLog{}).Error
+		if err != nil {
+			logger.Errorf("[Traffic Stat Queue] Delete server traffic log failed: %v", err.Error())
+		}
+	}
+	return nil
+}

queue/logic/traffic/trafficStatisticsLogic.go

@@ -38,7 +38,7 @@ func (l *TrafficStatisticsLogic) ProcessTask(ctx context.Context, task *asynq.Ta
 		return nil
 	}
 	// query server info
-	serverInfo, err := l.svc.ServerModel.FindOne(ctx, payload.ServerId)
+	serverInfo, err := l.svc.NodeModel.FindOneServer(ctx, payload.ServerId)
 	if err != nil {
 		logger.WithContext(ctx).Error("[TrafficStatistics] Find server info failed",
 			logger.Field("serverId", payload.ServerId),
@@ -46,23 +46,22 @@ func (l *TrafficStatisticsLogic) ProcessTask(ctx context.Context, task *asynq.Ta
 		)
 		return nil
 	}
-	if serverInfo.TrafficRatio == 0 {
-		logger.WithContext(ctx).Error("[TrafficStatistics] Server log ratio is 0",
-			logger.Field("serverId", payload.ServerId),
-		)
-		return nil
+	var serverRatio float32 = 1.0
+	if serverInfo.Ratio > 0 {
+		serverRatio = serverInfo.Ratio
 	}
+
 	now := time.Now()
 	realTimeMultiplier := l.svc.NodeMultiplierManager.GetMultiplier(now)
 	for _, log := range payload.Logs {
 		// update user subscribe with log
-		d := int64(float32(log.Download) * serverInfo.TrafficRatio * realTimeMultiplier)
-		u := int64(float32(log.Upload) * serverInfo.TrafficRatio * realTimeMultiplier)
+		d := int64(float32(log.Download) * serverRatio * realTimeMultiplier)
+		u := int64(float32(log.Upload) * serverRatio * realTimeMultiplier)
 		if err := l.svc.UserModel.UpdateUserSubscribeWithTraffic(ctx, log.SID, d, u); err != nil {
 			logger.WithContext(ctx).Error("[TrafficStatistics] Update user subscribe with log failed",
 				logger.Field("sid", log.SID),
-				logger.Field("download", float32(log.Download)*serverInfo.TrafficRatio),
-				logger.Field("upload", float32(log.Upload)*serverInfo.TrafficRatio),
+				logger.Field("download", float32(log.Download)*serverRatio),
+				logger.Field("upload", float32(log.Upload)*serverRatio),
 				logger.Field("error", err.Error()),
 			)
 			continue
@@ -88,8 +87,8 @@ func (l *TrafficStatisticsLogic) ProcessTask(ctx context.Context, task *asynq.Ta
 		}); err != nil {
 			logger.WithContext(ctx).Error("[TrafficStatistics] Create log log failed",
 				logger.Field("uid", log.SID),
-				logger.Field("download", float32(log.Download)*serverInfo.TrafficRatio),
-				logger.Field("upload", float32(log.Upload)*serverInfo.TrafficRatio),
+				logger.Field("download", float32(log.Download)*serverRatio),
+				logger.Field("upload", float32(log.Upload)*serverRatio),
 				logger.Field("error", err.Error()),
 			)
 		}