HI-VPN/hi-server
4
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

Develop (#76)

Browse Source 
* 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>
This commit is contained in:
Leif Draven
2025-09-14 22:50:22 +09:00
committed by GitHub
parent b5e244d83d
commit e895180388
359 changed files with 9213 additions and 12125 deletions
Download Patch File Download Diff File Expand all files Collapse all files
queue/handler/routes.go
+7
View File
@@ -7,6 +7,7 @@ import (
orderLogic "github.com/perfect-panel/server/queue/logic/order"
smslogic "github.com/perfect-panel/server/queue/logic/sms"
"github.com/perfect-panel/server/queue/logic/subscription"
"github.com/perfect-panel/server/queue/logic/task"
"github.com/perfect-panel/server/queue/logic/traffic"
"github.com/perfect-panel/server/queue/types"
@@ -39,4 +40,10 @@ func RegisterHandlers(mux *asynq.ServeMux, serverCtx *svc.ServiceContext) {
// ScheduledBatchSendEmail
mux.Handle(types.ScheduledBatchSendEmail, emailLogic.NewBatchEmailLogic(serverCtx))
// ScheduledTrafficStat
mux.Handle(types.SchedulerTrafficStat, traffic.NewStatLogic(serverCtx))
// ForthwithQuotaTask
mux.Handle(types.ForthwithQuotaTask, task.NewQuotaTaskLogic(serverCtx))
}
queue/logic/country/getCountryLogic.go
-38
View File
@@ -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
+2 -2
View File
@@ -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
+101 -6
View File
@@ -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
+132 -63
View File
@@ -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
+13 -6
View File
@@ -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
+48 -27
View File
@@ -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
+450
View File
@@ -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
+88 -44
View File
@@ -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
+2 -2
View File
@@ -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
+176
View File
@@ -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
+11 -12
View File
@@ -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()),
)
}
queue/types/email.go
+12 -6
View File
@@ -3,15 +3,21 @@ package types
const (
// ForthwithSendEmail forthwith send email
ForthwithSendEmail = "forthwith:email:send"
// ScheduledBatchSendEmail scheduled batch send email
ScheduledBatchSendEmail = "scheduled:email:batch"
)
const (
EmailTypeVerify = "verify"
EmailTypeMaintenance = "maintenance"
EmailTypeExpiration = "expiration"
EmailTypeTrafficExceed = "traffic_exceed"
EmailTypeCustom = "custom"
)
type (
SendEmailPayload struct {
Type string `json:"type"`
Email string `json:"to"`
Subject string `json:"subject"`
Content string `json:"content"`
Type string `json:"type"`
Email string `json:"to"`
Subject string `json:"subject"`
Content map[string]interface{} `json:"content"`
}
)
queue/types/scheduler.go
+1
View File
@@ -4,4 +4,5 @@ const (
SchedulerCheckSubscription = "scheduler:check:subscription"
SchedulerTotalServerData = "scheduler:total:server"
SchedulerResetTraffic = "scheduler:reset:traffic"
SchedulerTrafficStat = "scheduler:traffic:stat"
)
queue/types/sms.go
+1 -1
View File
@@ -1,7 +1,7 @@
package types
const (
// ForthwithSendEmail forthwith send email
// ForthwithSendSms forthwith send email
ForthwithSendSms = "forthwith:sms:send"
)
queue/types/task.go
+9
View File
@@ -0,0 +1,9 @@
package types
const (
// ScheduledBatchSendEmail scheduled batch send email
ScheduledBatchSendEmail = "scheduled:email:batch"
// ForthwithQuotaTask create quota task immediately
ForthwithQuotaTask = "forthwith:quota:task"
)