Develop (#64)

* fix(database): correct name entry for SingBox in initialization script

* fix(purchase): update gift amount deduction logic and handle zero-amount order status

* feat: add type and default fields to rule group requests and update related logic

* feat(rule): implement logic to set a default rule group during creation and update

* fix(rule): add type and default fields to rule group model and update related logic

* feat(proxy): enhance proxy group handling and sorting logic

* refactor(proxy): replace hardcoded group names with constants for better maintainability

* fix(proxy): update group selection logic to skip empty and default names

* feat(proxy): enhance proxy and group handling with new configuration options

* feat(surge): add Surge adapter support and enhance subscription URL handling

* feat(traffic): implement traffic reset logic for subscription cycles

* feat(auth): improve email and mobile config unmarshalling with default values

* fix(auth) upbind email not update

* fix(order) discount set default 1

* fix(order) discount set default 1

* fix: refactor surfboard proxy handling and enhance configuration template

* fix(renewal) discount set default 1

* feat(loon): add Loon configuration template and enhance proxy handling

* feat(subscription): update user subscription status based on expiration time

* fix(renewal): update subscription retrieval method to use token instead of order ID

* feat(order): enhance order processing logic with improved error handling and user subscription management

* fix(order): improve code quality and fix critical bugs in order processing logic

- Fix inconsistent logging calls across all order logic files
- Fix critical gift amount deduction logic bug in renewal process
- Fix variable shadowing errors in database transactions
- Add comprehensive Go-standard documentation comments
- Improve log prefix consistency for better debugging
- Remove redundant discount validation code

* fix(docker): add build argument for version in Docker image build process

* feat(version): add endpoint to retrieve application version information

* fix(auth): improve user authentication method logic and update user cache

* feat(user): add ordering functionality to user list retrieval

* fix(RevenueStatistics) fill list

* fix(UserStatistics) fill list

* fix(user): implement user cache clearing after auth method operations

* fix(auth): enhance OAuth login logic with improved request handling and user registration flow

* fix(user): implement sorting for authentication methods based on priority

* fix(user): correct ordering clause for user retrieval based on filter

* refactor(user): streamline cache management and enhance cache clearing logic

* feat(logs) set logs volume in develop

* fix(handler): implement browser interception to deny access for specific user agents

* fix(resetTraffic) reset daily server

* refactor(trojan): remove unused parameter and clean up logging in slice

* fix(middleware): add domain length check and improve user-agent handling

* fix(middleware): reorder domain processing and enhance user-agent handling

* fix(resetTraffic): update subscription reset logic to use expire_time for monthly and yearly checks

* fix(scheduler): update reset traffic task schedule to run daily at 00:30

* fix(traffic): enhance traffic reset logic for subscriptions and adjust status checks

* fix(activateOrder): update traffic reset logic to include reset day check

* feat(marketing): add batch email task management API and logic

* feat(application): implement CRUD operations for subscribe applications

* feat(types): add user agent limit and list to subscription configuration

* feat(application): update subscription application requests to include structured download links

* feat(application): add scheme field and download link handling to subscribe application

* feat(application): add endpoint to retrieve client information

* feat(application): move DownloadLink and SubscribeApplication types to types.api

* feat(application): add DownloadLink and SubscribeClient types, update client response structure

* feat(application): remove ProxyTemplate field from application API

* feat(application): implement adapter for client configuration and add preview template functionality

* feat(application): move DownloadLink type to types.api and remove from common.api

* feat(application): update PreviewSubscribeTemplate to return structured response

* feat(application): remove ProxyTemplate field from application API

* feat(application): enhance cache key generation for user list and server data

* feat(subscribe): add ClearCache method to manage subscription cache invalidation

* feat(payment): add Description field to PaymentMethodDetail response

* feat(subscribe): update next reset time calculation to use ExpireTime

* feat(purchase): include handling fee in total amount calculation

* feat(subscribe): add V2SubscribeHandler and logic for enhanced subscription management

* feat(subscribe): add output format configuration to subscription adapter

* feat(application): default data

---------

Co-authored-by: Chang lue Tsen <tension@ppanel.dev>
Co-authored-by: NoWay <Bob455668@hotmail.com>

internal/logic/admin/application/createSubscribeApplicationLogic.go

@@ -0,0 +1,61 @@
+package application
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/model/client"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateSubscribeApplicationLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewCreateSubscribeApplicationLogic Create subscribe application
+func NewCreateSubscribeApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateSubscribeApplicationLogic {
+	return &CreateSubscribeApplicationLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateSubscribeApplicationLogic) CreateSubscribeApplication(req *types.CreateSubscribeApplicationRequest) (resp *types.SubscribeApplication, err error) {
+	var link client.DownloadLink
+	tool.DeepCopy(&link, req.DownloadLink)
+	linkData, err := link.Marshal()
+	if err != nil {
+		l.Errorf("Failed to marshal download link: %v", err)
+		return nil, errors.Wrap(xerr.NewErrCode(xerr.ERROR), " Failed to marshal download link")
+	}
+	data := &client.SubscribeApplication{
+		Name:              req.Name,
+		Icon:              req.Icon,
+		Description:       req.Description,
+		Scheme:            req.Scheme,
+		UserAgent:         req.UserAgent,
+		IsDefault:         req.IsDefault,
+		SubscribeTemplate: req.SubscribeTemplate,
+		OutputFormat:      req.OutputFormat,
+		DownloadLink:      string(linkData),
+	}
+
+	err = l.svcCtx.ClientModel.Insert(l.ctx, data)
+	if err != nil {
+		l.Errorf("Failed to create subscribe application: %v", err)
+		return nil, errors.Wrap(xerr.NewErrCode(xerr.DatabaseInsertError), "Failed to create subscribe application")
+	}
+
+	resp = &types.SubscribeApplication{}
+	tool.DeepCopy(resp, data)
+	resp.DownloadLink = req.DownloadLink
+
+	return
+}

internal/logic/admin/application/deleteSubscribeApplicationLogic.go

@@ -0,0 +1,35 @@
+package application
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteSubscribeApplicationLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewDeleteSubscribeApplicationLogic Delete subscribe application
+func NewDeleteSubscribeApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteSubscribeApplicationLogic {
+	return &DeleteSubscribeApplicationLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteSubscribeApplicationLogic) DeleteSubscribeApplication(req *types.DeleteSubscribeApplicationRequest) error {
+	err := l.svcCtx.ClientModel.Delete(l.ctx, req.Id)
+	if err != nil {
+		l.Errorf("Failed to delete subscribe application with ID %d: %v", req.Id, err)
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), err.Error())
+	}
+	return nil
+}

internal/logic/admin/application/getSubscribeApplicationListLogic.go

@@ -0,0 +1,61 @@
+package application
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetSubscribeApplicationListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetSubscribeApplicationListLogic Get subscribe application list
+func NewGetSubscribeApplicationListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSubscribeApplicationListLogic {
+	return &GetSubscribeApplicationListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetSubscribeApplicationListLogic) GetSubscribeApplicationList(req *types.GetSubscribeApplicationListRequest) (resp *types.GetSubscribeApplicationListResponse, err error) {
+	data, err := l.svcCtx.ClientModel.List(l.ctx)
+	if err != nil {
+		l.Errorf("Failed to get subscribe application list: %v", err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Failed to get subscribe application list")
+	}
+	var list []types.SubscribeApplication
+	for _, item := range data {
+		var temp types.DownloadLink
+		if item.DownloadLink != "" {
+			_ = json.Unmarshal([]byte(item.DownloadLink), &temp)
+		}
+		list = append(list, types.SubscribeApplication{
+			Id:                item.Id,
+			Name:              item.Name,
+			Description:       item.Description,
+			Icon:              item.Icon,
+			Scheme:            item.Scheme,
+			UserAgent:         item.UserAgent,
+			IsDefault:         item.IsDefault,
+			SubscribeTemplate: item.SubscribeTemplate,
+			OutputFormat:      item.OutputFormat,
+			DownloadLink:      temp,
+			CreatedAt:         item.CreatedAt.UnixMilli(),
+			UpdatedAt:         item.UpdatedAt.UnixMilli(),
+		})
+	}
+	resp = &types.GetSubscribeApplicationListResponse{
+		Total: int64(len(list)),
+		List:  list,
+	}
+	return
+}

internal/logic/admin/application/previewSubscribeTemplateLogic.go

@@ -0,0 +1,69 @@
+package application
+
+import (
+	"context"
+	"time"
+
+	"github.com/perfect-panel/server/adapter"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type PreviewSubscribeTemplateLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Preview Template
+func NewPreviewSubscribeTemplateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PreviewSubscribeTemplateLogic {
+	return &PreviewSubscribeTemplateLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *PreviewSubscribeTemplateLogic) PreviewSubscribeTemplate(req *types.PreviewSubscribeTemplateRequest) (resp *types.PreviewSubscribeTemplateResponse, err error) {
+	servers, err := l.svcCtx.ServerModel.FindAllServer(l.ctx)
+	if err != nil {
+		l.Errorf("[PreviewSubscribeTemplateLogic] FindAllServer error: %v", err.Error())
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindAllServer error: %v", err.Error())
+	}
+
+	data, err := l.svcCtx.ClientModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorf("[PreviewSubscribeTemplateLogic] FindOne error: %v", err.Error())
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindOneClient error: %v", err.Error())
+	}
+
+	sub := adapter.NewAdapter(data.SubscribeTemplate, adapter.WithServers(servers),
+		adapter.WithSiteName("PerfectPanel"),
+		adapter.WithSubscribeName("Test Subscribe"),
+		adapter.WithOutputFormat(data.OutputFormat),
+		adapter.WithUserInfo(adapter.User{
+			Password:     "test-password",
+			ExpiredAt:    time.Now().AddDate(1, 0, 0),
+			Download:     0,
+			Upload:       0,
+			Traffic:      1000,
+			SubscribeURL: "https://example.com/subscribe",
+		}))
+	// Get client config
+	a, err := sub.Client()
+	if err != nil {
+		l.Errorf("[PreviewSubscribeTemplateLogic] Client error: %v", err.Error())
+		return nil, errors.Wrapf(xerr.NewErrMsg(err.Error()), "Client error: %v", err.Error())
+	}
+	bytes, err := a.Build()
+	if err != nil {
+		l.Errorf("[PreviewSubscribeTemplateLogic] Build error: %v", err.Error())
+		return nil, errors.Wrapf(xerr.NewErrMsg(err.Error()), "Build error: %v", err.Error())
+	}
+	return &types.PreviewSubscribeTemplateResponse{
+		Template: string(bytes),
+	}, nil
+}

internal/logic/admin/application/updateSubscribeApplicationLogic.go

@@ -0,0 +1,62 @@
+package application
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/model/client"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateSubscribeApplicationLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewUpdateSubscribeApplicationLogic Update subscribe application
+func NewUpdateSubscribeApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateSubscribeApplicationLogic {
+	return &UpdateSubscribeApplicationLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateSubscribeApplicationLogic) UpdateSubscribeApplication(req *types.UpdateSubscribeApplicationRequest) (resp *types.SubscribeApplication, err error) {
+	data, err := l.svcCtx.ClientModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorf("Failed to find subscribe application with ID %d: %v", req.Id, err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Failed to find subscribe application with ID %d", req.Id)
+	}
+	var link client.DownloadLink
+	tool.DeepCopy(&link, req.DownloadLink)
+	linkData, err := link.Marshal()
+	if err != nil {
+		l.Errorf("Failed to marshal download link: %v", err)
+		return nil, errors.Wrap(xerr.NewErrCode(xerr.ERROR), " Failed to marshal download link")
+	}
+
+	data.Name = req.Name
+	data.Icon = req.Icon
+	data.Description = req.Description
+	data.Scheme = req.Scheme
+	data.UserAgent = req.UserAgent
+	data.IsDefault = req.IsDefault
+	data.SubscribeTemplate = req.SubscribeTemplate
+	data.OutputFormat = req.OutputFormat
+	data.DownloadLink = string(linkData)
+	err = l.svcCtx.ClientModel.Update(l.ctx, data)
+	if err != nil {
+		l.Errorf("Failed to update subscribe application with ID %d: %v", req.Id, err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Failed to update subscribe application with ID %d", req.Id)
+	}
+	resp = &types.SubscribeApplication{}
+	tool.DeepCopy(&resp, data)
+	resp.DownloadLink = req.DownloadLink
+	return
+}

internal/logic/admin/console/queryRevenueStatisticsLogic.go

@@ -50,8 +50,8 @@ func (l *QueryRevenueStatisticsLogic) QueryRevenueStatistics() (resp *types.Reve
 	// Get monthly's revenue statistics
 	monthlyData, err := l.svcCtx.OrderModel.QueryMonthlyOrders(l.ctx, now)
 	if err != nil {
-		l.Errorw("[QueryRevenueStatisticsLogic] QueryDateOrders error", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "QueryDateOrders error: %v", err)
+		l.Errorw("[QueryRevenueStatisticsLogic] QueryMonthlyOrders error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "QueryMonthlyOrders error: %v", err)
 	} else {
 		monthly = types.OrdersStatistics{
 			AmountTotal:        monthlyData.AmountTotal,
@@ -61,6 +61,24 @@ func (l *QueryRevenueStatisticsLogic) QueryRevenueStatistics() (resp *types.Reve
 		}
 	}
 
+	// Get monthly daily list for the current month (from 1st to current date)
+	monthlyListData, err := l.svcCtx.OrderModel.QueryDailyOrdersList(l.ctx, now)
+	if err != nil {
+		l.Errorw("[QueryRevenueStatisticsLogic] QueryDailyOrdersList error", logger.Field("error", err.Error()))
+		// Don't return error, just log it and continue with empty list
+	} else {
+		monthlyList := make([]types.OrdersStatistics, len(monthlyListData))
+		for i, data := range monthlyListData {
+			monthlyList[i] = types.OrdersStatistics{
+				Date:               data.Date,
+				AmountTotal:        data.AmountTotal,
+				NewOrderAmount:     data.NewOrderAmount,
+				RenewalOrderAmount: data.RenewalOrderAmount,
+			}
+		}
+		monthly.List = monthlyList
+	}
+
 	// Get all revenue statistics
 	allData, err := l.svcCtx.OrderModel.QueryTotalOrders(l.ctx)
 	if err != nil {
@@ -74,6 +92,25 @@ func (l *QueryRevenueStatisticsLogic) QueryRevenueStatistics() (resp *types.Reve
 			List:               make([]types.OrdersStatistics, 0),
 		}
 	}
+
+	// Get all monthly list for the past 6 months
+	allListData, err := l.svcCtx.OrderModel.QueryMonthlyOrdersList(l.ctx, now)
+	if err != nil {
+		l.Errorw("[QueryRevenueStatisticsLogic] QueryMonthlyOrdersList error", logger.Field("error", err.Error()))
+		// Don't return error, just log it and continue with empty list
+	} else {
+		allList := make([]types.OrdersStatistics, len(allListData))
+		for i, data := range allListData {
+			allList[i] = types.OrdersStatistics{
+				Date:               data.Date,
+				AmountTotal:        data.AmountTotal,
+				NewOrderAmount:     data.NewOrderAmount,
+				RenewalOrderAmount: data.RenewalOrderAmount,
+			}
+		}
+		all.List = allList
+	}
+
 	return &types.RevenueStatisticsResponse{
 		Today:   today,
 		Monthly: monthly,
@@ -85,7 +122,7 @@ func (l *QueryRevenueStatisticsLogic) QueryRevenueStatistics() (resp *types.Reve
 func (l *QueryRevenueStatisticsLogic) mockRevenueStatistics() *types.RevenueStatisticsResponse {
 	now := time.Now()
 
-	// Generate daily data for the past 7 days (oldest first)
+	// Generate daily data for the current month (from 1st to current date)
 	monthlyList := make([]types.OrdersStatistics, 7)
 	for i := 0; i < 7; i++ {
 		dayDate := now.AddDate(0, 0, -(6 - i))

internal/logic/admin/console/queryUserStatisticsLogic.go

@@ -61,8 +61,24 @@ func (l *QueryUserStatisticsLogic) QueryUserStatistics() (resp *types.UserStatis
 	} else {
 		resp.Monthly.NewOrderUsers = newMonth
 		resp.Monthly.RenewalOrderUsers = renewalMonth
-		// TODO: Check the purchase status in the past seven days
-		resp.Monthly.List = make([]types.UserStatistics, 0)
+	}
+
+	// Get monthly daily user statistics list for the current month (from 1st to current date)
+	monthlyListData, err := l.svcCtx.UserModel.QueryDailyUserStatisticsList(l.ctx, now)
+	if err != nil {
+		l.Errorw("[QueryUserStatisticsLogic] QueryDailyUserStatisticsList error", logger.Field("error", err.Error()))
+		// Don't return error, just log it and continue with empty list
+	} else {
+		monthlyList := make([]types.UserStatistics, len(monthlyListData))
+		for i, data := range monthlyListData {
+			monthlyList[i] = types.UserStatistics{
+				Date:              data.Date,
+				Register:          data.Register,
+				NewOrderUsers:     data.NewOrderUsers,
+				RenewalOrderUsers: data.RenewalOrderUsers,
+			}
+		}
+		resp.Monthly.List = monthlyList
 	}
 
 	// query all user count
@@ -81,13 +97,32 @@ func (l *QueryUserStatisticsLogic) QueryUserStatistics() (resp *types.UserStatis
 		resp.All.NewOrderUsers = allNewOrderUsers
 		resp.All.RenewalOrderUsers = allRenewalOrderUsers
 	}
+
+	// Get all monthly user statistics list for the past 6 months
+	allListData, err := l.svcCtx.UserModel.QueryMonthlyUserStatisticsList(l.ctx, now)
+	if err != nil {
+		l.Errorw("[QueryUserStatisticsLogic] QueryMonthlyUserStatisticsList error", logger.Field("error", err.Error()))
+		// Don't return error, just log it and continue with empty list
+	} else {
+		allList := make([]types.UserStatistics, len(allListData))
+		for i, data := range allListData {
+			allList[i] = types.UserStatistics{
+				Date:              data.Date,
+				Register:          data.Register,
+				NewOrderUsers:     data.NewOrderUsers,
+				RenewalOrderUsers: data.RenewalOrderUsers,
+			}
+		}
+		resp.All.List = allList
+	}
+
 	return
 }
 
 func (l *QueryUserStatisticsLogic) mockRevenueStatistics() *types.UserStatisticsResponse {
 	now := time.Now()
 
-	// Generate daily user statistics for the past 7 days (oldest first)
+	// Generate daily user statistics for the current month (from 1st to current date)
 	monthlyList := make([]types.UserStatistics, 7)
 	for i := 0; i < 7; i++ {
 		dayDate := now.AddDate(0, 0, -(6 - i))
@@ -100,6 +135,19 @@ func (l *QueryUserStatisticsLogic) mockRevenueStatistics() *types.UserStatistics
 		}
 	}
 
+	// Generate monthly user statistics for the past 6 months (oldest first)
+	allList := make([]types.UserStatistics, 6)
+	for i := 0; i < 6; i++ {
+		monthDate := now.AddDate(0, -(5 - i), 0)
+		baseRegister := int64(1800 + ((5 - i) * 200) + ((5-i)%2)*500)
+		allList[i] = types.UserStatistics{
+			Date:              monthDate.Format("2006-01"),
+			Register:          baseRegister,
+			NewOrderUsers:     int64(float64(baseRegister) * 0.65),
+			RenewalOrderUsers: int64(float64(baseRegister) * 0.35),
+		}
+	}
+
 	return &types.UserStatisticsResponse{
 		Today: types.UserStatistics{
 			Register:          28,
@@ -116,6 +164,7 @@ func (l *QueryUserStatisticsLogic) mockRevenueStatistics() *types.UserStatistics
 			Register:          18888,
 			NewOrderUsers:     0, // This field is not used in All statistics
 			RenewalOrderUsers: 0, // This field is not used in All statistics
+			List:              allList,
 		},
 	}
 }

internal/logic/admin/marketing/createBatchSendEmailTaskLogic.go

@@ -0,0 +1,149 @@
+package marketing
+
+import (
+	"context"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/hibiken/asynq"
+	"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/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
+	types2 "github.com/perfect-panel/server/queue/types"
+	"gorm.io/gorm"
+)
+
+type CreateBatchSendEmailTaskLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create a batch send email task
+func NewCreateBatchSendEmailTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateBatchSendEmailTaskLogic {
+	return &CreateBatchSendEmailTaskLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+func (l *CreateBatchSendEmailTaskLogic) CreateBatchSendEmailTask(req *types.CreateBatchSendEmailTaskRequest) (err error) {
+	tx := l.svcCtx.DB
+
+	var emails []string
+
+	// 通用查询器（含 user JOIN + 注册时间范围过滤）
+	baseQuery := func() *gorm.DB {
+		query := tx.Model(&user.AuthMethods{}).
+			Select("auth_identifier").
+			Joins("JOIN user ON user.id = user_auth_methods.user_id").
+			Where("auth_type = ?", "email")
+
+		if req.RegisterStartTime != 0 {
+			query = query.Where("user.created_at >= ?", req.RegisterStartTime)
+		}
+		if req.RegisterEndTime != 0 {
+			query = query.Where("user.created_at <= ?", req.RegisterEndTime)
+		}
+		return query
+	}
+
+	var query *gorm.DB
+
+	switch req.Scope {
+	case "all":
+		query = baseQuery()
+
+	case "active":
+		query = baseQuery().
+			Joins("JOIN user_subscribe ON user.id = user_subscribe.user_id").
+			Where("user_subscribe.status IN ?", []int64{1, 2})
+
+	case "expired":
+		query = baseQuery().
+			Joins("JOIN user_subscribe ON user.id = user_subscribe.user_id").
+			Where("user_subscribe.status = ?", 3)
+
+	case "none":
+		query = baseQuery().
+			Joins("LEFT JOIN user_subscribe ON user.id = user_subscribe.user_id").
+			Where("user_subscribe.user_id IS NULL")
+
+	}
+	if query != nil {
+		// 执行查询
+		err = query.Pluck("auth_identifier", &emails).Error
+		if err != nil {
+			l.Errorf("[CreateBatchSendEmailTask] Failed to fetch email addresses: %v", err.Error())
+			return xerr.NewErrCode(xerr.DatabaseQueryError)
+		}
+	}
+
+	// 邮箱列表为空，返回错误
+	if len(emails) == 0 && req.Scope != "skip" {
+		l.Errorf("[CreateBatchSendEmailTask] No email addresses found for the specified scope")
+		return xerr.NewErrMsg("No email addresses found for the specified scope")
+	}
+
+	// 邮箱地址去重
+	emails = tool.RemoveDuplicateElements(emails...)
+
+	var additionalEmails []string
+	// 追加额外的邮箱地址（不覆盖）
+	if req.Additional != "" {
+		additionalEmails = strings.Split(req.Additional, "\n")
+	}
+	if len(additionalEmails) == 0 && req.Scope == "skip" {
+		l.Errorf("[CreateBatchSendEmailTask] No additional email addresses provided for skip scope")
+		return xerr.NewErrMsg("No additional email addresses provided for skip scope")
+	}
+
+	var scheduledAt time.Time
+	if req.Scheduled == 0 {
+		scheduledAt = time.Now()
+	} else {
+		scheduledAt = time.Unix(req.Scheduled, 0)
+		if scheduledAt.Before(time.Now()) {
+			scheduledAt = time.Now()
+		}
+	}
+
+	taskInfo := &task.EmailTask{
+		Subject:           req.Subject,
+		Content:           req.Content,
+		Recipients:        strings.Join(emails, "\n"),
+		Scope:             req.Scope,
+		RegisterStartTime: time.Unix(req.RegisterStartTime, 0),
+		RegisterEndTime:   time.Unix(req.RegisterEndTime, 0),
+		Additional:        req.Additional,
+		Scheduled:         scheduledAt,
+		Interval:          req.Interval,
+		Limit:             req.Limit,
+		Status:            0,
+		Errors:            "",
+		Total:             uint64(len(emails) + len(additionalEmails)),
+		Current:           0,
+	}
+
+	if err = l.svcCtx.DB.Model(&task.EmailTask{}).Create(taskInfo).Error; err != nil {
+		l.Errorf("[CreateBatchSendEmailTask] Failed to create email task: %v", err.Error())
+		return xerr.NewErrCode(xerr.DatabaseInsertError)
+	}
+	// create task
+	l.Infof("[CreateBatchSendEmailTask] Successfully created email task with ID: %d", taskInfo.Id)
+
+	t := asynq.NewTask(types2.ScheduledBatchSendEmail, []byte(strconv.FormatInt(taskInfo.Id, 10)))
+	info, err := l.svcCtx.Queue.EnqueueContext(l.ctx, t, asynq.ProcessAt(taskInfo.Scheduled))
+	if err != nil {
+		l.Errorf("[CreateBatchSendEmailTask] Failed to enqueue email task: %v", err.Error())
+		return xerr.NewErrCode(xerr.QueueEnqueueError)
+	}
+	l.Infof("[CreateBatchSendEmailTask] Successfully enqueued email task with ID: %s, scheduled at: %s", info.ID, taskInfo.Scheduled)
+
+	return nil
+}

internal/logic/admin/marketing/getBatchSendEmailTaskListLogic.go

@@ -0,0 +1,56 @@
+package marketing
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/model/task"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/tool"
+	"github.com/perfect-panel/server/pkg/xerr"
+)
+
+type GetBatchSendEmailTaskListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetBatchSendEmailTaskListLogic Get batch send email task list
+func NewGetBatchSendEmailTaskListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetBatchSendEmailTaskListLogic {
+	return &GetBatchSendEmailTaskListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetBatchSendEmailTaskListLogic) GetBatchSendEmailTaskList(req *types.GetBatchSendEmailTaskListRequest) (resp *types.GetBatchSendEmailTaskListResponse, err error) {
+
+	var tasks []*task.EmailTask
+	tx := l.svcCtx.DB.Model(&task.EmailTask{})
+	if req.Status != nil {
+		tx = tx.Where("status = ?", *req.Status)
+	}
+	if req.Scope != "" {
+		tx = tx.Where("scope = ?", req.Scope)
+	}
+	if req.Page == 0 {
+		req.Page = 1
+	}
+	if req.Size == 0 {
+		req.Size = 10
+	}
+	err = tx.Offset((req.Page - 1) * req.Size).Limit(req.Size).Order("created_at DESC").Find(&tasks).Error
+	if err != nil {
+		l.Errorf("failed to get email tasks: %v", err)
+		return nil, xerr.NewErrCode(xerr.DatabaseQueryError)
+	}
+
+	list := make([]types.BatchSendEmailTask, 0)
+	tool.DeepCopy(&list, tasks)
+	return &types.GetBatchSendEmailTaskListResponse{
+		List: list,
+	}, nil
+}

internal/logic/admin/marketing/getBatchSendEmailTaskStatusLogic.go

@@ -0,0 +1,44 @@
+package marketing
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/model/task"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+)
+
+type GetBatchSendEmailTaskStatusLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetBatchSendEmailTaskStatusLogic Get batch send email task status
+func NewGetBatchSendEmailTaskStatusLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetBatchSendEmailTaskStatusLogic {
+	return &GetBatchSendEmailTaskStatusLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetBatchSendEmailTaskStatusLogic) GetBatchSendEmailTaskStatus(req *types.GetBatchSendEmailTaskStatusRequest) (resp *types.GetBatchSendEmailTaskStatusResponse, err error) {
+	tx := l.svcCtx.DB
+
+	var taskInfo *task.EmailTask
+	err = tx.Model(&task.EmailTask{}).Where("id = ?", req.Id).First(&taskInfo).Error
+	if err != nil {
+		l.Errorf("failed to get email task status, error: %v", err)
+		return nil, xerr.NewErrCode(xerr.DatabaseQueryError)
+	}
+
+	return &types.GetBatchSendEmailTaskStatusResponse{
+		Status:  taskInfo.Status,
+		Total:   int64(taskInfo.Total),
+		Current: int64(taskInfo.Current),
+		Errors:  taskInfo.Errors,
+	}, nil
+}

internal/logic/admin/marketing/getPreSendEmailCountLogic.go

@@ -0,0 +1,86 @@
+package marketing
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"gorm.io/gorm"
+)
+
+type GetPreSendEmailCountLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetPreSendEmailCountLogic Get pre-send email count
+func NewGetPreSendEmailCountLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPreSendEmailCountLogic {
+	return &GetPreSendEmailCountLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPreSendEmailCountLogic) GetPreSendEmailCount(req *types.GetPreSendEmailCountRequest) (resp *types.GetPreSendEmailCountResponse, err error) {
+	tx := l.svcCtx.DB
+	var count int64
+	// 通用查询器（含 user JOIN + 注册时间范围过滤）
+	baseQuery := func() *gorm.DB {
+		query := tx.Model(&user.AuthMethods{}).
+			Select("auth_identifier").
+			Joins("JOIN user ON user.id = user_auth_methods.user_id").
+			Where("auth_type = ?", "email")
+
+		if req.RegisterStartTime != 0 {
+			query = query.Where("user.created_at >= ?", req.RegisterStartTime)
+		}
+		if req.RegisterEndTime != 0 {
+			query = query.Where("user.created_at <= ?", req.RegisterEndTime)
+		}
+		return query
+	}
+	var query *gorm.DB
+	switch req.Scope {
+	case "all":
+		query = baseQuery()
+
+	case "active":
+		query = baseQuery().
+			Joins("JOIN user_subscribe ON user.id = user_subscribe.user_id").
+			Where("user_subscribe.status IN ?", []int64{1, 2})
+
+	case "expired":
+		query = baseQuery().
+			Joins("JOIN user_subscribe ON user.id = user_subscribe.user_id").
+			Where("user_subscribe.status = ?", 3)
+
+	case "none":
+		query = baseQuery().
+			Joins("LEFT JOIN user_subscribe ON user.id = user_subscribe.user_id").
+			Where("user_subscribe.user_id IS NULL")
+	case "skip":
+		// Skip scope does not require a count
+		query = nil
+
+	default:
+		l.Errorf("[CreateBatchSendEmailTask] Invalid scope: %v", req.Scope)
+		return nil, xerr.NewErrMsg("Invalid email scope")
+
+	}
+
+	if query != nil {
+		if err = query.Count(&count).Error; err != nil {
+			l.Errorf("[GetPreSendEmailCount] Count error: %v", err)
+			return nil, xerr.NewErrMsg("Failed to count emails")
+		}
+	}
+
+	return &types.GetPreSendEmailCountResponse{
+		Count: count,
+	}, nil
+}

internal/logic/admin/marketing/stopBatchSendEmailTaskLogic.go

@@ -0,0 +1,42 @@
+package marketing
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/model/task"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/email"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+)
+
+type StopBatchSendEmailTaskLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewStopBatchSendEmailTaskLogic Stop a batch send email task
+func NewStopBatchSendEmailTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *StopBatchSendEmailTaskLogic {
+	return &StopBatchSendEmailTaskLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *StopBatchSendEmailTaskLogic) StopBatchSendEmailTask(req *types.StopBatchSendEmailTaskRequest) (err error) {
+	if email.Manager != nil {
+		email.Manager.RemoveWorker(req.Id)
+	} else {
+		logger.Error("[StopBatchSendEmailTaskLogic] email.Manager is nil, cannot stop task")
+	}
+	err = l.svcCtx.DB.Model(&task.EmailTask{}).Where("id = ?", req.Id).Update("status", 2).Error
+
+	if err != nil {
+		l.Errorf("failed to stop email task, error: %v", err)
+		return xerr.NewErrCode(xerr.DatabaseUpdateError)
+	}
+	return
+}

internal/logic/admin/payment/getPaymentMethodListLogic.go

@@ -55,17 +55,18 @@ func (l *GetPaymentMethodListLogic) GetPaymentMethodList(req *types.GetPaymentMe
 			}
 		}
 		resp.List[i] = types.PaymentMethodDetail{
-			Id:         v.Id,
-			Name:       v.Name,
-			Platform:   v.Platform,
-			Icon:       v.Icon,
-			Domain:     v.Domain,
-			Config:     config,
-			FeeMode:    v.FeeMode,
-			FeePercent: v.FeePercent,
-			FeeAmount:  v.FeeAmount,
-			Enable:     *v.Enable,
-			NotifyURL:  notifyUrl,
+			Id:          v.Id,
+			Name:        v.Name,
+			Platform:    v.Platform,
+			Icon:        v.Icon,
+			Domain:      v.Domain,
+			Config:      config,
+			FeeMode:     v.FeeMode,
+			FeePercent:  v.FeePercent,
+			FeeAmount:   v.FeeAmount,
+			Enable:      *v.Enable,
+			NotifyURL:   notifyUrl,
+			Description: v.Description,
 		}
 	}
 	return

internal/logic/admin/server/updateNodeLogic.go

@@ -133,6 +133,7 @@ func (l *UpdateNodeLogic) UpdateNode(req *types.UpdateNodeRequest) error {
 		}
 		l.Infow("[GetNodeCountry]: Enqueue Success", logger.Field("taskID", taskInfo.ID), logger.Field("payload", string(payload)))
 	}
+
 	l.svcCtx.DeviceManager.Broadcast(device.SubscribeUpdate)
 	return nil
 }

internal/logic/admin/tool/getVersionLogic.go

@@ -0,0 +1,51 @@
+package tool
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/constant"
+	"github.com/perfect-panel/server/pkg/logger"
+)
+
+type GetVersionLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetVersionLogic Get Version
+func NewGetVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetVersionLogic {
+	return &GetVersionLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetVersionLogic) GetVersion() (resp *types.VersionResponse, err error) {
+	version := constant.Version
+	buildTime := constant.BuildTime
+
+	// Normalize unknown values
+	if version == "unknown version" {
+		version = "unknown"
+	}
+	if buildTime == "unknown time" {
+		buildTime = "unknown"
+	}
+
+	// Format version based on whether it starts with 'v'
+	var formattedVersion string
+	if len(version) > 0 && version[0] == 'v' {
+		formattedVersion = fmt.Sprintf("%s(%s)", version[1:], buildTime)
+	} else {
+		formattedVersion = fmt.Sprintf("%s(%s) Develop", version, buildTime)
+	}
+
+	return &types.VersionResponse{
+		Version: formattedVersion,
+	}, nil
+}

internal/logic/admin/user/createUserSubscribeLogic.go

@@ -77,5 +77,10 @@ func (l *CreateUserSubscribeLogic) CreateUserSubscribe(req *types.CreateUserSubs
 		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "UpdateUserCache error: %v", err.Error())
 	}
 
+	err = l.svcCtx.SubscribeModel.ClearCache(l.ctx, userSub.SubscribeId)
+	if err != nil {
+		logger.Errorw("ClearSubscribe error", logger.Field("error", err.Error()))
+	}
+
 	return nil
 }

internal/logic/admin/user/getUserListLogic.go

@@ -32,6 +32,7 @@ func (l *GetUserListLogic) GetUserList(req *types.GetUserListRequest) (*types.Ge
 		Search:          req.Search,
 		SubscribeId:     req.SubscribeId,
 		UserSubscribeId: req.UserSubscribeId,
+		Order:           "DESC",
 	})
 	if err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetUserListLogic failed: %v", err.Error())

internal/logic/admin/user/updateUserAuthMethodLogic.go

@@ -31,11 +31,21 @@ func (l *UpdateUserAuthMethodLogic) UpdateUserAuthMethod(req *types.UpdateUserAu
 		l.Errorw("Get user auth method error", logger.Field("error", err.Error()), logger.Field("userId", req.UserId), logger.Field("authType", req.AuthType))
 		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get user auth method error: %v", err.Error())
 	}
+	userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, req.UserId)
+	if err != nil {
+		l.Errorw("Get user info error", logger.Field("error", err.Error()), logger.Field("userId", req.UserId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get user info error: %v", err.Error())
+	}
+
 	method.AuthType = req.AuthType
 	method.AuthIdentifier = req.AuthIdentifier
 	if err = l.svcCtx.UserModel.UpdateUserAuthMethods(l.ctx, method); err != nil {
 		l.Errorw("Update user auth method error", logger.Field("error", err.Error()), logger.Field("userId", req.UserId), logger.Field("authType", req.AuthType))
 		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Update user auth method error: %v", err.Error())
 	}
+	if err = l.svcCtx.UserModel.UpdateUserCache(l.ctx, userInfo); err != nil {
+		l.Errorw("Update user cache error", logger.Field("error", err.Error()), logger.Field("userId", req.UserId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Update user cache error: %v", err.Error())
+	}
 	return nil
 }