init

internal/logic/admin/ads/createAdsLogic.go

@@ -0,0 +1,44 @@
+package ads
+
+import (
+	"context"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/ads"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateAdsLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create Ads
+func NewCreateAdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateAdsLogic {
+	return &CreateAdsLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateAdsLogic) CreateAds(req *types.CreateAdsRequest) error {
+	if err := l.svcCtx.AdsModel.Insert(l.ctx, &ads.Ads{
+		Title:     req.Title,
+		Type:      req.Type,
+		Content:   req.Content,
+		TargetURL: req.TargetURL,
+		StartTime: time.UnixMilli(req.StartTime),
+		EndTime:   time.UnixMilli(req.EndTime),
+		Status:    req.Status,
+	}); err != nil {
+		l.Errorw("insert ads error: %v", logger.Field("error", err.Error()), logger.Field("req", req))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert ads error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/ads/deleteAdsLogic.go

@@ -0,0 +1,34 @@
+package ads
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteAdsLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete Ads
+func NewDeleteAdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteAdsLogic {
+	return &DeleteAdsLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteAdsLogic) DeleteAds(req *types.DeleteAdsRequest) error {
+	if err := l.svcCtx.AdsModel.Delete(l.ctx, req.Id); err != nil {
+		l.Errorw("delete ads error", logger.Field("error", err.Error()), logger.Field("id", req.Id))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete ads error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/ads/getAdsDetailLogic.go

@@ -0,0 +1,38 @@
+package ads
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetAdsDetailLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get Ads Detail
+func NewGetAdsDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAdsDetailLogic {
+	return &GetAdsDetailLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetAdsDetailLogic) GetAdsDetail(req *types.GetAdsDetailRequest) (resp *types.Ads, err error) {
+	data, err := l.svcCtx.AdsModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("find ads error", logger.Field("error", err.Error()), logger.Field("id", req.Id))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find ads error: %v", err.Error())
+	}
+	resp = new(types.Ads)
+	tool.DeepCopy(resp, data)
+	return
+}

internal/logic/admin/ads/getAdsListLogic.go

@@ -0,0 +1,45 @@
+package ads
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/ads"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetAdsListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get Ads List
+func NewGetAdsListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAdsListLogic {
+	return &GetAdsListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetAdsListLogic) GetAdsList(req *types.GetAdsListRequest) (resp *types.GetAdsListResponse, err error) {
+	total, data, err := l.svcCtx.AdsModel.GetAdsListByPage(l.ctx, req.Page, req.Size, ads.Filter{
+		Search: req.Search,
+		Status: req.Status,
+	})
+	if err != nil {
+		l.Errorw("get ads list error", logger.Field("error", err.Error()), logger.Field("req", req))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get ads list error: %v", err.Error())
+	}
+	resp = &types.GetAdsListResponse{
+		Total: total,
+		List:  make([]types.Ads, len(data)),
+	}
+	tool.DeepCopy(&resp.List, data)
+	return
+}

internal/logic/admin/ads/updateAdsLogic.go

@@ -0,0 +1,44 @@
+package ads
+
+import (
+	"context"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateAdsLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update Ads
+func NewUpdateAdsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateAdsLogic {
+	return &UpdateAdsLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateAdsLogic) UpdateAds(req *types.UpdateAdsRequest) error {
+	data, err := l.svcCtx.AdsModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("find ads error", logger.Field("error", err.Error()), logger.Field("id", req.Id))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find ads error: %v", err.Error())
+	}
+	tool.DeepCopy(data, req)
+	data.StartTime = time.UnixMilli(req.StartTime)
+	data.EndTime = time.UnixMilli(req.EndTime)
+	if err := l.svcCtx.AdsModel.Update(l.ctx, data); err != nil {
+		l.Errorw("update ads error", logger.Field("error", err.Error()), logger.Field("req", req))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update ads error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/announcement/createAnnouncementLogic.go

@@ -0,0 +1,40 @@
+package announcement
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/announcement"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateAnnouncementLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create announcement
+func NewCreateAnnouncementLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateAnnouncementLogic {
+	return &CreateAnnouncementLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateAnnouncementLogic) CreateAnnouncement(req *types.CreateAnnouncementRequest) error {
+
+	if err := l.svcCtx.AnnouncementModel.Insert(l.ctx, &announcement.Announcement{
+		Title:   req.Title,
+		Content: req.Content,
+	}); err != nil {
+		l.Errorw("[CreateAnnouncement] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create announcement failed: %v", err.Error())
+	}
+
+	return nil
+}

internal/logic/admin/announcement/deleteAnnouncementLogic.go

@@ -0,0 +1,34 @@
+package announcement
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteAnnouncementLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete announcement
+func NewDeleteAnnouncementLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteAnnouncementLogic {
+	return &DeleteAnnouncementLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteAnnouncementLogic) DeleteAnnouncement(req *types.DeleteAnnouncementRequest) error {
+	if err := l.svcCtx.AnnouncementModel.Delete(l.ctx, req.Id); err != nil {
+		l.Errorw("[DeleteAnnouncement] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete announcement failed: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/announcement/getAnnouncementListLogic.go

@@ -0,0 +1,46 @@
+package announcement
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/announcement"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type GetAnnouncementListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get announcement list
+func NewGetAnnouncementListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAnnouncementListLogic {
+	return &GetAnnouncementListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetAnnouncementListLogic) GetAnnouncementList(req *types.GetAnnouncementListRequest) (resp *types.GetAnnouncementListResponse, err error) {
+	total, list, err := l.svcCtx.AnnouncementModel.GetAnnouncementListByPage(l.ctx, int(req.Page), int(req.Size), announcement.Filter{
+		Show:   req.Show,
+		Pinned: req.Pinned,
+		Popup:  req.Popup,
+		Search: req.Search,
+	})
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetAnnouncementListByPage error: %v", err.Error())
+	}
+	resp = &types.GetAnnouncementListResponse{}
+	resp.Total = total
+	resp.List = make([]types.Announcement, 0)
+	tool.DeepCopy(&resp.List, list)
+	return
+}

internal/logic/admin/announcement/getAnnouncementLogic.go

@@ -0,0 +1,38 @@
+package announcement
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetAnnouncementLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get announcement
+func NewGetAnnouncementLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAnnouncementLogic {
+	return &GetAnnouncementLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetAnnouncementLogic) GetAnnouncement(req *types.GetAnnouncementRequest) (resp *types.Announcement, err error) {
+	info, err := l.svcCtx.AnnouncementModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[GetAnnouncement] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get announcement error: %v", err.Error())
+	}
+	resp = &types.Announcement{}
+	tool.DeepCopy(resp, info)
+	return
+}

internal/logic/admin/announcement/updateAnnouncementLogic.go

@@ -0,0 +1,51 @@
+package announcement
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateAnnouncementLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update announcement
+func NewUpdateAnnouncementLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateAnnouncementLogic {
+	return &UpdateAnnouncementLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateAnnouncementLogic) UpdateAnnouncement(req *types.UpdateAnnouncementRequest) error {
+	info, err := l.svcCtx.AnnouncementModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[UpdateAnnouncement] Query Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get announcement error: %v", err.Error())
+	}
+	info.Title = req.Title
+	info.Content = req.Content
+	if req.Show != nil {
+		info.Show = req.Show
+	}
+	if req.Pinned != nil {
+		info.Pinned = req.Pinned
+	}
+	if req.Popup != nil {
+		info.Popup = req.Popup
+	}
+	err = l.svcCtx.AnnouncementModel.Update(l.ctx, info)
+	if err != nil {
+		l.Errorw("[UpdateAnnouncement] Update Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update announcement error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/authMethod/getAuthMethodConfigLogic.go

@@ -0,0 +1,46 @@
+package authMethod
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetAuthMethodConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get auth method config
+func NewGetAuthMethodConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAuthMethodConfigLogic {
+	return &GetAuthMethodConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetAuthMethodConfigLogic) GetAuthMethodConfig(req *types.GetAuthMethodConfigRequest) (resp *types.AuthMethodConfig, err error) {
+	method, err := l.svcCtx.AuthModel.FindOneByMethod(l.ctx, req.Method)
+	if err != nil {
+		l.Errorw("find one by method failed", logger.Field("method", req.Method), logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find one by method failed: %v", err.Error())
+	}
+
+	resp = new(types.AuthMethodConfig)
+	tool.DeepCopy(resp, method)
+	if method.Config != "" {
+		if err := json.Unmarshal([]byte(method.Config), &resp.Config); err != nil {
+			l.Errorw("unmarshal config failed", logger.Field("config", method.Config), logger.Field("error", err.Error()))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "unmarshal apple config failed: %v", err.Error())
+		}
+	}
+	return
+}

internal/logic/admin/authMethod/getAuthMethodListLogic.go

@@ -0,0 +1,49 @@
+package authMethod
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetAuthMethodListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetAuthMethodListLogic Get auth method list
+func NewGetAuthMethodListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAuthMethodListLogic {
+	return &GetAuthMethodListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetAuthMethodListLogic) GetAuthMethodList() (resp *types.GetAuthMethodListResponse, err error) {
+	methods, err := l.svcCtx.AuthModel.FindAll(l.ctx)
+	if err != nil {
+		l.Errorw("find all failed", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find all failed: %v", err.Error())
+	}
+	var list []types.AuthMethodConfig
+	for _, method := range methods {
+		var item types.AuthMethodConfig
+		tool.DeepCopy(&item, method)
+		if method.Config != "" {
+			if err := json.Unmarshal([]byte(method.Config), &item.Config); err != nil {
+				l.Errorw("unmarshal config failed", logger.Field("config", method.Config), logger.Field("error", err.Error()))
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "unmarshal config failed: %v", err.Error())
+			}
+		}
+		list = append(list, item)
+	}
+	return &types.GetAuthMethodListResponse{List: list}, nil
+}

internal/logic/admin/authMethod/getEmailPlatformLogic.go

@@ -0,0 +1,32 @@
+package authMethod
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/pkg/email"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type GetEmailPlatformLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get email support platform
+func NewGetEmailPlatformLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetEmailPlatformLogic {
+	return &GetEmailPlatformLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetEmailPlatformLogic) GetEmailPlatform() (resp *types.PlatformResponse, err error) {
+	return &types.PlatformResponse{
+		List: email.GetSupportedPlatforms(),
+	}, nil
+}

internal/logic/admin/authMethod/getSmsPlatformLogic.go

@@ -0,0 +1,32 @@
+package authMethod
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/pkg/sms"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type GetSmsPlatformLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get sms support platform
+func NewGetSmsPlatformLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSmsPlatformLogic {
+	return &GetSmsPlatformLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetSmsPlatformLogic) GetSmsPlatform() (resp *types.PlatformResponse, err error) {
+	return &types.PlatformResponse{
+		List: sms.GetSupportedPlatforms(),
+	}, nil
+}

internal/logic/admin/authMethod/testEmailSendLogic.go

@@ -0,0 +1,41 @@
+package authMethod
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/email"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type TestEmailSendLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Test email send
+func NewTestEmailSendLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TestEmailSendLogic {
+	return &TestEmailSendLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TestEmailSendLogic) TestEmailSend(req *types.TestEmailSendRequest) error {
+	client, err := email.NewSender(l.svcCtx.Config.Email.Platform, l.svcCtx.Config.Email.PlatformConfig, l.svcCtx.Config.Site.SiteName)
+	if err != nil {
+		l.Errorw("new email sender err", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "new email sender err: %v", err.Error())
+	}
+	err = client.Send([]string{req.Email}, "Test Email Send", "this a test email send by ppanel")
+	if err != nil {
+		return errors.Wrapf(xerr.NewErrCodeMsg(500, fmt.Sprintf("send email err: %v", err.Error())), "send email err: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/authMethod/testSmsSendLogic.go

@@ -0,0 +1,42 @@
+package authMethod
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/sms"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type TestSmsSendLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Test sms send
+func NewTestSmsSendLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TestSmsSendLogic {
+	return &TestSmsSendLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TestSmsSendLogic) TestSmsSend(req *types.TestSmsSendRequest) error {
+	client, err := sms.NewSender(l.svcCtx.Config.Mobile.Platform, l.svcCtx.Config.Mobile.PlatformConfig)
+	if err != nil {
+		l.Errorw("new sms sender err", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "new sms sender err: %v", err.Error())
+	}
+	err = client.SendCode(req.AreaCode, req.Telephone, "123456")
+	if err != nil {
+		l.Errorw("send sms err", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCodeMsg(500, fmt.Sprintf("send sms err: %v", err.Error())), "send sms err: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/authMethod/updateAuthMethodConfigLogic.go

@@ -0,0 +1,126 @@
+package authMethod
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/initialize"
+	"github.com/perfect-panel/ppanel-server/internal/model/auth"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/email"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/sms"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateAuthMethodConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update auth method config
+func NewUpdateAuthMethodConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateAuthMethodConfigLogic {
+	return &UpdateAuthMethodConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateAuthMethodConfigLogic) UpdateAuthMethodConfig(req *types.UpdateAuthMethodConfigRequest) (resp *types.AuthMethodConfig, err error) {
+	method, err := l.svcCtx.AuthModel.FindOneByMethod(l.ctx, req.Method)
+	if err != nil {
+		l.Errorw("find one by method failed", logger.Field("method", req.Method), logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find one by method failed: %v", err.Error())
+	}
+
+	tool.DeepCopy(method, req)
+	if req.Config != nil {
+		if value, ok := req.Config.(map[string]interface{}); ok {
+			if req.Method == "email" && value["verify_email_template"] == "" {
+				value["verify_email_template"] = email.DefaultEmailVerifyTemplate
+			}
+			if req.Method == "email" && value["expiration_email_template"] == "" {
+				value["expiration_email_template"] = email.DefaultExpirationEmailTemplate
+			}
+			if req.Method == "email" && value["maintenance_email_template"] == "" {
+				value["maintenance_email_template"] = email.DefaultMaintenanceEmailTemplate
+			}
+			if req.Method == "email" && value["traffic_exceed_email_template"] == "" {
+				value["traffic_exceed_email_template"] = email.DefaultTrafficExceedEmailTemplate
+			}
+
+			if value["platform_config"] != nil {
+				platformConfig, err := validatePlatformConfig(value["platform"].(string), value["platform_config"].(map[string]interface{}))
+				if err != nil {
+					l.Errorw("validate platform config failed", logger.Field("config", req.Config), logger.Field("error", err.Error()))
+					return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "validate platform config failed: %v", err.Error())
+				}
+				req.Config.(map[string]interface{})["platform_config"] = platformConfig
+			}
+		}
+		bytes, err := json.Marshal(req.Config)
+		if err != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "marshal config failed: %v", err.Error())
+		}
+		method.Config = string(bytes)
+	}
+	err = l.svcCtx.AuthModel.Update(l.ctx, method)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "update auth method failed: %v", err.Error())
+	}
+
+	resp = new(types.AuthMethodConfig)
+	tool.DeepCopy(resp, method)
+	if method.Config != "" {
+		if err := json.Unmarshal([]byte(method.Config), &resp.Config); err != nil {
+			l.Errorw("unmarshal apple config failed", logger.Field("config", method.Config), logger.Field("error", err.Error()))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "unmarshal apple config failed: %v", err.Error())
+		}
+	}
+	// update global config
+	defer l.UpdateGlobal(method.Method)
+	return
+}
+
+func (l *UpdateAuthMethodConfigLogic) UpdateGlobal(method string) {
+	if method == "email" {
+		initialize.Email(l.svcCtx)
+	}
+	if method == "mobile" {
+		initialize.Mobile(l.svcCtx)
+	}
+}
+
+func validatePlatformConfig(platform string, cfg map[string]interface{}) (interface{}, error) {
+	var bytes []byte
+	var err error
+	var config interface{}
+	bytes, err = json.Marshal(cfg)
+	if err != nil {
+		return nil, err
+	}
+	switch platform {
+	case email.SMTP.String():
+		config = new(auth.SMTPConfig)
+	case sms.Abosend.String():
+		config = new(auth.AbosendConfig)
+	case sms.AlibabaCloud.String():
+		config = new(auth.AlibabaCloudConfig)
+	case sms.Smsbao.String():
+		config = new(auth.SmsbaoConfig)
+	case sms.Twilio.String():
+		config = new(auth.TwilioConfig)
+	default:
+		return nil, errors.New("invalid platform")
+	}
+	err = json.Unmarshal(bytes, config)
+	if err != nil {
+		return nil, err
+	}
+	return config, nil
+}

internal/logic/admin/authMethod/validate_test.go

@@ -0,0 +1,21 @@
+package authMethod
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/perfect-panel/ppanel-server/pkg/sms"
+)
+
+func TestValidate(t *testing.T) {
+	config := " {\"0\":\"{\",\"1\":\"\\\"\",\"10\":\"y\",\"11\":\"I\",\"12\":\"d\",\"13\":\"\\\"\",\"14\":\":\",\"15\":\"\\\"\",\"16\":\"\\\"\",\"17\":\",\",\"18\":\"\\\"\",\"19\":\"A\",\"2\":\"A\",\"20\":\"c\",\"21\":\"c\",\"22\":\"e\",\"23\":\"s\",\"24\":\"s\",\"25\":\"K\",\"26\":\"e\",\"27\":\"y\",\"28\":\"S\",\"29\":\"e\",\"3\":\"c\",\"30\":\"c\",\"31\":\"r\",\"32\":\"e\",\"33\":\"t\",\"34\":\"\\\"\",\"35\":\":\",\"36\":\"\\\"\",\"37\":\"\\\"\",\"38\":\",\",\"39\":\"\\\"\",\"4\":\"c\",\"40\":\"S\",\"41\":\"i\",\"42\":\"g\",\"43\":\"n\",\"44\":\"N\",\"45\":\"a\",\"46\":\"m\",\"47\":\"e\",\"48\":\"\\\"\",\"49\":\":\",\"5\":\"e\",\"50\":\"\\\"\",\"51\":\"\\\"\",\"52\":\",\",\"53\":\"\\\"\",\"54\":\"E\",\"55\":\"n\",\"56\":\"d\",\"57\":\"p\",\"58\":\"o\",\"59\":\"i\",\"6\":\"s\",\"60\":\"n\",\"61\":\"t\",\"62\":\"\\\"\",\"63\":\":\",\"64\":\"\\\"\",\"65\":\"\\\"\",\"66\":\",\",\"67\":\"\\\"\",\"68\":\"V\",\"69\":\"e\",\"7\":\"s\",\"70\":\"r\",\"71\":\"i\",\"72\":\"f\",\"73\":\"y\",\"74\":\"T\",\"75\":\"e\",\"76\":\"m\",\"77\":\"p\",\"78\":\"l\",\"79\":\"a\",\"8\":\"K\",\"80\":\"t\",\"81\":\"e\",\"82\":\"C\",\"83\":\"o\",\"84\":\"d\",\"85\":\"e\",\"86\":\"\\\"\",\"87\":\":\",\"88\":\"\\\"\",\"89\":\"\\\"\",\"9\":\"e\",\"90\":\"}\",\"access\":\"xxxx\",\"secret\":\"SSxxxxxxxxxxxxxxxxxxxxxxxU\",\"template\":\"Your verification code is: {{.code}}\"}"
+	var mapConfig map[string]interface{}
+	if err := json.Unmarshal([]byte(config), &mapConfig); err != nil {
+		t.Error(err)
+	}
+	platformConfig, err := validatePlatformConfig(sms.Abosend.String(), mapConfig)
+	if err != nil {
+		t.Errorf("validateEmailPlatformConfig error: %v", err)
+	}
+	t.Logf("platformConfig: %+v", platformConfig)
+}

internal/logic/admin/console/queryRevenueStatisticsLogic.go

@@ -0,0 +1,77 @@
+package console
+
+import (
+	"context"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type QueryRevenueStatisticsLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Query revenue statistics
+func NewQueryRevenueStatisticsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryRevenueStatisticsLogic {
+	return &QueryRevenueStatisticsLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryRevenueStatisticsLogic) QueryRevenueStatistics() (resp *types.RevenueStatisticsResponse, err error) {
+
+	var today, monthly, all types.OrdersStatistics
+	now := time.Now()
+	// Get today's revenue statistics
+	todayData, err := l.svcCtx.OrderModel.QueryDateOrders(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)
+	} else {
+		today = types.OrdersStatistics{
+			AmountTotal:        todayData.AmountTotal,
+			NewOrderAmount:     todayData.NewOrderAmount,
+			RenewalOrderAmount: todayData.RenewalOrderAmount,
+		}
+	}
+	// 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)
+	} else {
+		monthly = types.OrdersStatistics{
+			AmountTotal:        monthlyData.AmountTotal,
+			NewOrderAmount:     monthlyData.NewOrderAmount,
+			RenewalOrderAmount: monthlyData.RenewalOrderAmount,
+			List:               make([]types.OrdersStatistics, 0),
+		}
+	}
+
+	// Get all revenue statistics
+	allData, err := l.svcCtx.OrderModel.QueryTotalOrders(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryRevenueStatisticsLogic] QueryTotalOrders error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "QueryTotalOrders error: %v", err)
+	} else {
+		all = types.OrdersStatistics{
+			AmountTotal:        allData.AmountTotal,
+			NewOrderAmount:     allData.NewOrderAmount,
+			RenewalOrderAmount: allData.RenewalOrderAmount,
+			List:               make([]types.OrdersStatistics, 0),
+		}
+	}
+	return &types.RevenueStatisticsResponse{
+		Today:   today,
+		Monthly: monthly,
+		All:     all,
+	}, nil
+}

internal/logic/admin/console/queryServerTotalDataLogic.go

@@ -0,0 +1,140 @@
+package console
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/pkg/errors"
+)
+
+type QueryServerTotalDataLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewQueryServerTotalDataLogic Query server total data
+func NewQueryServerTotalDataLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryServerTotalDataLogic {
+	return &QueryServerTotalDataLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryServerTotalDataLogic) QueryServerTotalData() (resp *types.ServerTotalDataResponse, err error) {
+	resp = &types.ServerTotalDataResponse{
+		ServerTrafficRankingToday:     make([]types.ServerTrafficData, 0),
+		ServerTrafficRankingYesterday: make([]types.ServerTrafficData, 0),
+		UserTrafficRankingToday:       make([]types.UserTrafficData, 0),
+		UserTrafficRankingYesterday:   make([]types.UserTrafficData, 0),
+	}
+
+	// Query node server status
+	servers, err := l.svcCtx.ServerModel.FindAllServer(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] FindAllServer error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(err, "FindAllServer error: %v", err)
+	}
+	onlineServers, err := l.svcCtx.NodeCache.GetOnlineNodeStatusCount(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] GetOnlineNodeStatusCount error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(err, "GetOnlineNodeStatusCount error: %v", err)
+	}
+	resp.OnlineServers = onlineServers
+	resp.OfflineServers = int64(len(servers) - int(onlineServers))
+
+	// 获取所有节点在线用户
+	allNodeOnlineUser, err := l.svcCtx.NodeCache.GetAllNodeOnlineUser(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] Get all node online user failed", logger.Field("error", err.Error()))
+	}
+	resp.OnlineUserIPs = int64(len(allNodeOnlineUser))
+
+	// 获取所有节点今日上传下载流量
+	allNodeUploadTraffic, err := l.svcCtx.NodeCache.GetAllNodeUploadTraffic(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] Get all node upload traffic failed", logger.Field("error", err.Error()))
+	}
+	resp.TodayUpload = allNodeUploadTraffic
+	allNodeDownloadTraffic, err := l.svcCtx.NodeCache.GetAllNodeDownloadTraffic(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] Get all node download traffic failed", logger.Field("error", err.Error()))
+	}
+	resp.TodayDownload = allNodeDownloadTraffic
+	// 获取节点流量排行榜 前10
+	nodeTrafficRankingToday, err := l.svcCtx.NodeCache.GetNodeTodayTotalTrafficRank(l.ctx, 10)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] Get node today total traffic rank failed", logger.Field("error", err.Error()))
+	}
+	if len(nodeTrafficRankingToday) > 0 {
+		var serverTrafficData []types.ServerTrafficData
+		for _, rank := range nodeTrafficRankingToday {
+			serverInfo, err := l.svcCtx.ServerModel.FindOne(l.ctx, rank.ID)
+			if err != nil {
+				l.Errorw("[QueryServerTotalDataLogic] FindOne error", logger.Field("error", err))
+				continue
+			}
+			serverTrafficData = append(serverTrafficData, types.ServerTrafficData{
+				ServerId: rank.ID,
+				Name:     serverInfo.Name,
+				Upload:   rank.Upload,
+				Download: rank.Download,
+			})
+		}
+		resp.ServerTrafficRankingToday = serverTrafficData
+	}
+	// 获取用户流量排行榜 前10
+	userTrafficRankingToday, err := l.svcCtx.NodeCache.GetUserTodayTotalTrafficRank(l.ctx, 10)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] Get user today total traffic rank failed", logger.Field("error", err.Error()))
+	}
+
+	if len(userTrafficRankingToday) > 0 {
+		var userTrafficData []types.UserTrafficData
+		for _, rank := range userTrafficRankingToday {
+			userTrafficData = append(userTrafficData, types.UserTrafficData{
+				SID:      rank.SID,
+				Upload:   rank.Upload,
+				Download: rank.Download,
+			})
+		}
+		resp.UserTrafficRankingToday = userTrafficData
+	}
+	// 获取昨日节点流量排行榜 前10
+	nodeTrafficRankingYesterday, err := l.svcCtx.NodeCache.GetYesterdayNodeTotalTrafficRank(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] Get yesterday node total traffic rank failed", logger.Field("error", err.Error()))
+	}
+	if len(nodeTrafficRankingYesterday) > 0 {
+		var serverTrafficData []types.ServerTrafficData
+		for _, rank := range nodeTrafficRankingYesterday {
+			serverTrafficData = append(serverTrafficData, types.ServerTrafficData{
+				ServerId: rank.ID,
+				Name:     rank.Name,
+				Upload:   rank.Upload,
+				Download: rank.Download,
+			})
+		}
+		resp.ServerTrafficRankingYesterday = serverTrafficData
+	}
+	// 获取昨日用户流量排行榜 前10
+	userTrafficRankingYesterday, err := l.svcCtx.NodeCache.GetYesterdayUserTotalTrafficRank(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryServerTotalDataLogic] Get yesterday user total traffic rank failed", logger.Field("error", err.Error()))
+	}
+	if len(userTrafficRankingYesterday) > 0 {
+		var userTrafficData []types.UserTrafficData
+		for _, rank := range userTrafficRankingYesterday {
+			userTrafficData = append(userTrafficData, types.UserTrafficData{
+				SID:      rank.SID,
+				Upload:   rank.Upload,
+				Download: rank.Download,
+			})
+		}
+		resp.UserTrafficRankingYesterday = userTrafficData
+	}
+	return resp, nil
+}

internal/logic/admin/console/queryTicketWaitReplyLogic.go

@@ -0,0 +1,35 @@
+package console
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type QueryTicketWaitReplyLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewQueryTicketWaitReplyLogic Query ticket wait reply
+func NewQueryTicketWaitReplyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryTicketWaitReplyLogic {
+	return &QueryTicketWaitReplyLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryTicketWaitReplyLogic) QueryTicketWaitReply() (resp *types.TicketWaitRelpyResponse, err error) {
+	count, err := l.svcCtx.TicketModel.QueryWaitReplyTotal(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryTicketWaitReply] Query Database Error: ", logger.Field("error", err.Error()))
+		return nil, err
+	}
+	return &types.TicketWaitRelpyResponse{
+		Count: count,
+	}, nil
+}

internal/logic/admin/console/queryUserStatisticsLogic.go

@@ -0,0 +1,71 @@
+package console
+
+import (
+	"context"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type QueryUserStatisticsLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Query user statistics
+func NewQueryUserStatisticsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryUserStatisticsLogic {
+	return &QueryUserStatisticsLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryUserStatisticsLogic) QueryUserStatistics() (resp *types.UserStatisticsResponse, err error) {
+	resp = &types.UserStatisticsResponse{}
+	now := time.Now()
+	// query today user register count
+	todayUserResisterCount, err := l.svcCtx.UserModel.QueryResisterUserTotalByDate(l.ctx, now)
+	if err != nil {
+		l.Errorw("[QueryUserStatisticsLogic] QueryResisterUserTotalByDate error", logger.Field("error", err.Error()))
+	} else {
+		resp.Today.Register = todayUserResisterCount
+	}
+	// query today user purchase count
+	newToday, renewalToday, err := l.svcCtx.OrderModel.QueryDateUserCounts(l.ctx, now)
+	if err != nil {
+		l.Errorw("[QueryUserStatisticsLogic] QueryDateUserCounts error", logger.Field("error", err.Error()))
+	} else {
+		resp.Today.NewOrderUsers = newToday
+		resp.Today.RenewalOrderUsers = renewalToday
+	}
+	// query month user register count
+	monthUserResisterCount, err := l.svcCtx.UserModel.QueryResisterUserTotalByMonthly(l.ctx, now)
+	if err != nil {
+		l.Errorw("[QueryUserStatisticsLogic] QueryResisterUserTotalByMonthly error", logger.Field("error", err.Error()))
+	} else {
+		resp.Monthly.Register = monthUserResisterCount
+	}
+	// query month user purchase count
+	newMonth, renewalMonth, err := l.svcCtx.OrderModel.QueryMonthlyUserCounts(l.ctx, now)
+	if err != nil {
+		l.Errorw("[QueryUserStatisticsLogic] QueryMonthlyUserCounts error", logger.Field("error", err.Error()))
+	} 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)
+	}
+
+	// query all user count
+	allUserCount, err := l.svcCtx.UserModel.QueryResisterUserTotal(l.ctx)
+	if err != nil {
+		l.Errorw("[QueryUserStatisticsLogic] QueryResisterUserTotal error", logger.Field("error", err.Error()))
+	} else {
+		resp.All.Register = allUserCount
+	}
+	return
+}

internal/logic/admin/coupon/batchDeleteCouponLogic.go

@@ -0,0 +1,36 @@
+package coupon
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type BatchDeleteCouponLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Batch delete coupon
+func NewBatchDeleteCouponLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteCouponLogic {
+	return &BatchDeleteCouponLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *BatchDeleteCouponLogic) BatchDeleteCoupon(req *types.BatchDeleteCouponRequest) error {
+	// batch delete coupon by ids
+	err := l.svcCtx.CouponModel.BatchDelete(l.ctx, req.Ids)
+	if err != nil {
+		l.Errorw("[BatchDeleteCoupon] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "batch delete coupon error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/coupon/createCouponLogic.go

@@ -0,0 +1,49 @@
+package coupon
+
+import (
+	"context"
+	"math/rand"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/coupon"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/random"
+	"github.com/perfect-panel/ppanel-server/pkg/snowflake"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateCouponLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create coupon
+func NewCreateCouponLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateCouponLogic {
+	return &CreateCouponLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateCouponLogic) CreateCoupon(req *types.CreateCouponRequest) error {
+	if req.Code == "" {
+		rand.NewSource(time.Now().UnixNano())
+		sid := snowflake.GetID()
+		req.Code = random.KeyNew(4, 2) + "-" + random.StrToDashedString(random.EncodeBase36(sid))
+	}
+	couponInfo := &coupon.Coupon{}
+	tool.DeepCopy(couponInfo, req)
+	couponInfo.Subscribe = tool.Int64SliceToString(req.Subscribe)
+	err := l.svcCtx.CouponModel.Insert(l.ctx, couponInfo)
+	if err != nil {
+		l.Errorw("[CreateCoupon] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create coupon error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/coupon/deleteCouponLogic.go

@@ -0,0 +1,36 @@
+package coupon
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteCouponLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete coupon
+func NewDeleteCouponLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteCouponLogic {
+	return &DeleteCouponLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteCouponLogic) DeleteCoupon(req *types.DeleteCouponRequest) error {
+	// delete coupon by id
+	err := l.svcCtx.CouponModel.Delete(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[DeleteCoupon] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete coupon error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/coupon/getCouponListLogic.go

@@ -0,0 +1,46 @@
+package coupon
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetCouponListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get coupon list
+func NewGetCouponListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetCouponListLogic {
+	return &GetCouponListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetCouponListLogic) GetCouponList(req *types.GetCouponListRequest) (resp *types.GetCouponListResponse, err error) {
+	resp = &types.GetCouponListResponse{}
+	// get coupon list from db
+	total, list, err := l.svcCtx.CouponModel.QueryCouponListByPage(l.ctx, int(req.Page), int(req.Size), req.Subscribe, req.Search)
+	if err != nil {
+		l.Errorw("[GetCouponList] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get coupon list error: %v", err.Error())
+	}
+	resp.Total = total
+	resp.List = make([]types.Coupon, 0)
+	for _, coupon := range list {
+		couponInfo := types.Coupon{}
+		tool.DeepCopy(&couponInfo, coupon)
+		couponInfo.Subscribe = tool.StringToInt64Slice(coupon.Subscribe)
+		resp.List = append(resp.List, couponInfo)
+	}
+	return
+}

internal/logic/admin/coupon/updateCouponLogic.go

@@ -0,0 +1,43 @@
+package coupon
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/coupon"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateCouponLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update coupon
+func NewUpdateCouponLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateCouponLogic {
+	return &UpdateCouponLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateCouponLogic) UpdateCoupon(req *types.UpdateCouponRequest) error {
+	fmt.Printf("req Subscribe: %v\n", req.Subscribe)
+	couponInfo := &coupon.Coupon{}
+	// update coupon
+	tool.DeepCopy(couponInfo, req)
+	couponInfo.Subscribe = tool.Int64SliceToString(req.Subscribe)
+	err := l.svcCtx.CouponModel.Update(l.ctx, couponInfo)
+	if err != nil {
+		l.Errorw("[UpdateCoupon] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update coupon error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/document/batchDeleteDocumentLogic.go

@@ -0,0 +1,36 @@
+package document
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type BatchDeleteDocumentLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Batch delete document
+func NewBatchDeleteDocumentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteDocumentLogic {
+	return &BatchDeleteDocumentLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *BatchDeleteDocumentLogic) BatchDeleteDocument(req *types.BatchDeleteDocumentRequest) error {
+	for _, id := range req.Ids {
+		if err := l.svcCtx.DocumentModel.Delete(l.ctx, id); err != nil {
+			l.Errorw("[BatchDeleteDocument] Database Error", logger.Field("error", err.Error()))
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "failed to delete document: %v", err.Error())
+		}
+	}
+	return nil
+}

internal/logic/admin/document/createDocumentLogic.go

@@ -0,0 +1,41 @@
+package document
+
+import (
+	"context"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/document"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateDocumentLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create document
+func NewCreateDocumentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateDocumentLogic {
+	return &CreateDocumentLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateDocumentLogic) CreateDocument(req *types.CreateDocumentRequest) error {
+	if err := l.svcCtx.DocumentModel.Insert(l.ctx, &document.Document{
+		Title:   req.Title,
+		Content: req.Content,
+		Tags:    strings.Join(req.Tags, ","),
+		Show:    req.Show,
+	}); err != nil {
+		l.Errorw("[CreateDocument] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert document error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/document/deleteDocumentLogic.go

@@ -0,0 +1,34 @@
+package document
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteDocumentLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete document
+func NewDeleteDocumentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteDocumentLogic {
+	return &DeleteDocumentLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteDocumentLogic) DeleteDocument(req *types.DeleteDocumentRequest) error {
+	if err := l.svcCtx.DocumentModel.Delete(l.ctx, req.Id); err != nil {
+		l.Errorw("[DeleteDocument] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "failed to delete document: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/document/getDocumentDetailLogic.go

@@ -0,0 +1,44 @@
+package document
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetDocumentDetailLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get document detail
+func NewGetDocumentDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetDocumentDetailLogic {
+	return &GetDocumentDetailLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetDocumentDetailLogic) GetDocumentDetail(req *types.GetDocumentDetailRequest) (resp *types.Document, err error) {
+	data, err := l.svcCtx.DocumentModel.QueryDocumentDetail(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[GetDocumentDetail] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "QueryDocumentDetail error: %v", err.Error())
+	}
+	resp = &types.Document{
+		Id:        data.Id,
+		Title:     data.Title,
+		Tags:      tool.StringMergeAndRemoveDuplicates(data.Tags),
+		Content:   data.Content,
+		CreatedAt: data.CreatedAt.UnixMilli(),
+		UpdatedAt: data.UpdatedAt.UnixMilli(),
+	}
+	return
+}

internal/logic/admin/document/getDocumentListLogic.go

@@ -0,0 +1,51 @@
+package document
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetDocumentListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get document list
+func NewGetDocumentListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetDocumentListLogic {
+	return &GetDocumentListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetDocumentListLogic) GetDocumentList(req *types.GetDocumentListRequest) (resp *types.GetDocumentListResponse, err error) {
+	total, data, err := l.svcCtx.DocumentModel.QueryDocumentList(l.ctx, int(req.Page), int(req.Size), req.Tag, req.Search)
+	if err != nil {
+		l.Errorw("[GetDocumentList] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "QueryDocumentList error: %v", err.Error())
+	}
+	resp = &types.GetDocumentListResponse{
+		Total: total,
+		List:  make([]types.Document, 0),
+	}
+	for _, v := range data {
+		resp.List = append(resp.List, types.Document{
+			Id:        v.Id,
+			Title:     v.Title,
+			Tags:      tool.StringMergeAndRemoveDuplicates(v.Tags),
+			Content:   v.Content,
+			Show:      *v.Show,
+			CreatedAt: v.CreatedAt.UnixMilli(),
+			UpdatedAt: v.UpdatedAt.UnixMilli(),
+		})
+	}
+	return
+}

internal/logic/admin/document/updateDocumentLogic.go

@@ -0,0 +1,42 @@
+package document
+
+import (
+	"context"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/document"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateDocumentLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update document
+func NewUpdateDocumentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateDocumentLogic {
+	return &UpdateDocumentLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateDocumentLogic) UpdateDocument(req *types.UpdateDocumentRequest) error {
+	if err := l.svcCtx.DocumentModel.Update(l.ctx, &document.Document{
+		Id:      req.Id,
+		Title:   req.Title,
+		Content: req.Content,
+		Tags:    strings.Join(req.Tags, ","),
+		Show:    req.Show,
+	}); err != nil {
+		l.Errorw("[UpdateDocument] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "failed to update document: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/log/getMessageLogListLogic.go

@@ -0,0 +1,50 @@
+package log
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/log"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetMessageLogListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetMessageLogListLogic Get message log list
+func NewGetMessageLogListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetMessageLogListLogic {
+	return &GetMessageLogListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetMessageLogListLogic) GetMessageLogList(req *types.GetMessageLogListRequest) (resp *types.GetMessageLogListResponse, err error) {
+	total, data, err := l.svcCtx.LogModel.FindMessageLogList(l.ctx, req.Page, req.Size, log.MessageLogFilterParams{
+		Type:     req.Type,
+		Platform: req.Platform,
+		To:       req.To,
+		Subject:  req.Subject,
+		Content:  req.Content,
+		Status:   req.Status,
+	})
+	if err != nil {
+		l.Errorw("[GetMessageLogList] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "[GetMessageLogList] Database Error: %s", err.Error())
+	}
+	var list []types.MessageLog
+	tool.DeepCopy(&list, data)
+
+	return &types.GetMessageLogListResponse{
+		Total: total,
+		List:  list,
+	}, nil
+}

internal/logic/admin/order/createOrderLogic.go

@@ -0,0 +1,59 @@
+package order
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/order"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateOrderLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create order
+func NewCreateOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateOrderLogic {
+	return &CreateOrderLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateOrderLogic) CreateOrder(req *types.CreateOrderRequest) error {
+	paymentMethod, err := l.svcCtx.PaymentModel.FindOne(l.ctx, req.PaymentId)
+	if err != nil {
+		l.Logger.Error("[CreateOrder] PaymentMethod Not Found", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.PaymentMethodNotFound), "PaymentMethod not found: %v", err.Error())
+	}
+
+	err = l.svcCtx.OrderModel.Insert(l.ctx, &order.Order{
+		UserId:         req.UserId,
+		OrderNo:        tool.GenerateTradeNo(),
+		Type:           req.Type,
+		Quantity:       req.Quantity,
+		Price:          req.Price,
+		Amount:         req.Amount,
+		Discount:       req.Discount,
+		Coupon:         req.Coupon,
+		CouponDiscount: req.CouponDiscount,
+		PaymentId:      req.PaymentId,
+		Method:         paymentMethod.Token,
+		FeeAmount:      req.FeeAmount,
+		TradeNo:        req.TradeNo,
+		Status:         req.Status,
+		SubscribeId:    req.SubscribeId,
+	})
+	if err != nil {
+		l.Logger.Error("[CreateOrder] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Insert error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/order/getOrderListLogic.go

@@ -0,0 +1,40 @@
+package order
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetOrderListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetOrderListLogic Get order list
+func NewGetOrderListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetOrderListLogic {
+	return &GetOrderListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetOrderListLogic) GetOrderList(req *types.GetOrderListRequest) (resp *types.GetOrderListResponse, err error) {
+	total, list, err := l.svcCtx.OrderModel.QueryOrderListByPage(l.ctx, int(req.Page), int(req.Size), req.Status, req.UserId, req.SubscribeId, req.Search)
+	if err != nil {
+		l.Errorw("[GetOrderList] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "QueryOrderListByPage error: %v", err.Error())
+	}
+	resp = &types.GetOrderListResponse{}
+	resp.List = make([]types.Order, 0)
+	tool.DeepCopy(&resp.List, list)
+	resp.Total = total
+	return
+}

internal/logic/admin/order/updateOrderStatusLogic.go

@@ -0,0 +1,81 @@
+package order
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/hibiken/asynq"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	queue "github.com/perfect-panel/ppanel-server/queue/types"
+)
+
+type UpdateOrderStatusLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update order status
+func NewUpdateOrderStatusLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateOrderStatusLogic {
+	return &UpdateOrderStatusLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateOrderStatusLogic) UpdateOrderStatus(req *types.UpdateOrderStatusRequest) error {
+	info, err := l.svcCtx.OrderModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[UpdateOrderStatus] FindOne error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindOne error: %v", err.Error())
+	}
+
+	if req.PaymentId != 0 {
+		paymentMethod, err := l.svcCtx.PaymentModel.FindOne(l.ctx, req.PaymentId)
+		if err != nil {
+			l.Logger.Error("[CreateOrder] PaymentMethod Not Found", logger.Field("error", err.Error()))
+			return errors.Wrapf(xerr.NewErrCode(xerr.PaymentMethodNotFound), "PaymentMethod not found: %v", err.Error())
+		}
+		info.PaymentId = paymentMethod.Id
+		info.Method = paymentMethod.Platform
+	}
+	if req.TradeNo != "" {
+		info.TradeNo = req.TradeNo
+	}
+
+	err = l.svcCtx.OrderModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		if err := l.svcCtx.OrderModel.Update(l.ctx, info, db); err != nil {
+			l.Errorw("[UpdateOrderStatus] Update error", logger.Field("error", err.Error()), logger.Field("OrderID", info.Id))
+			return err
+		}
+		if err := l.svcCtx.OrderModel.UpdateOrderStatus(l.ctx, info.OrderNo, req.Status, db); err != nil {
+			return err
+		}
+		// If order status is 2, create user subscription
+		if req.Status == 2 {
+			payload := queue.ForthwithActivateOrderPayload{
+				OrderNo: info.OrderNo,
+			}
+			p, _ := json.Marshal(payload)
+			task := asynq.NewTask(queue.ForthwithActivateOrder, p)
+			_, err = l.svcCtx.Queue.EnqueueContext(l.ctx, task)
+			if err != nil {
+				l.Errorw("[UpdateOrderStatus] Enqueue error", logger.Field("error", err.Error()))
+				return errors.Wrapf(xerr.NewErrCode(xerr.QueueEnqueueError), "Enqueue error: %v", err.Error())
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		l.Errorw("[UpdateOrderStatus] Transaction error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Transaction error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/payment/createPaymentMethodLogic.go

@@ -0,0 +1,97 @@
+package payment
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/pkg/random"
+
+	paymentModel "github.com/perfect-panel/ppanel-server/internal/model/payment"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/payment"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreatePaymentMethodLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewCreatePaymentMethodLogic Create Payment Method
+func NewCreatePaymentMethodLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreatePaymentMethodLogic {
+	return &CreatePaymentMethodLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreatePaymentMethodLogic) CreatePaymentMethod(req *types.CreatePaymentMethodRequest) (resp *types.PaymentConfig, err error) {
+	if payment.ParsePlatform(req.Platform) == payment.UNSUPPORTED {
+		l.Errorw("unsupported payment platform", logger.Field("mark", req.Platform))
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(400, "UNSUPPORTED_PAYMENT_PLATFORM"), "unsupported payment platform: %s", req.Platform)
+	}
+	config := parsePaymentPlatformConfig(l.ctx, payment.ParsePlatform(req.Platform), req.Config)
+	var paymentMethod = &paymentModel.Payment{
+		Name:        req.Name,
+		Platform:    req.Platform,
+		Icon:        req.Icon,
+		Domain:      req.Domain,
+		Description: req.Description,
+		Config:      config,
+		FeeMode:     req.FeeMode,
+		FeePercent:  req.FeePercent,
+		FeeAmount:   req.FeeAmount,
+		Enable:      req.Enable,
+		Token:       random.KeyNew(8, 1),
+	}
+	if err := l.svcCtx.PaymentModel.Insert(l.ctx, paymentMethod); err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert payment method error: %s", err.Error())
+	}
+	resp = &types.PaymentConfig{}
+	tool.DeepCopy(resp, paymentMethod)
+	var configMap map[string]interface{}
+	_ = json.Unmarshal([]byte(paymentMethod.Config), &configMap)
+	resp.Config = configMap
+	return
+}
+
+func parsePaymentPlatformConfig(ctx context.Context, platform payment.Platform, config interface{}) string {
+	data, err := json.Marshal(config)
+	if err != nil {
+		logger.WithContext(ctx).Errorw("parse payment platform config error", logger.Field("platform", platform), logger.Field("config", config), logger.Field("error", err.Error()))
+	}
+	switch platform {
+	case payment.Stripe:
+		stripe := &paymentModel.StripeConfig{}
+		if err := stripe.Unmarshal(string(data)); err != nil {
+			logger.WithContext(ctx).Errorw("parse stripe config error", logger.Field("config", string(data)), logger.Field("error", err.Error()))
+		}
+		return stripe.Marshal()
+	case payment.AlipayF2F:
+		alipay := &paymentModel.AlipayF2FConfig{}
+		if err := alipay.Unmarshal(string(data)); err != nil {
+			logger.WithContext(ctx).Errorw("parse alipay config error", logger.Field("config", string(data)), logger.Field("error", err.Error()))
+		}
+		return alipay.Marshal()
+	case payment.EPay:
+		epay := &paymentModel.EPayConfig{}
+		if err := epay.Unmarshal(string(data)); err != nil {
+			logger.WithContext(ctx).Errorw("parse epay config error", logger.Field("config", string(data)), logger.Field("error", err.Error()))
+		}
+		return epay.Marshal()
+	case payment.Payssion:
+		payssion := &paymentModel.PayssionConfig{}
+		if err := payssion.Unmarshal(string(data)); err != nil {
+			logger.WithContext(ctx).Errorw("parse payssion config error", logger.Field("config", string(data)), logger.Field("error", err.Error()))
+		}
+		return payssion.Marshal()
+	default:
+		return ""
+	}
+}

internal/logic/admin/payment/deletePaymentMethodLogic.go

@@ -0,0 +1,34 @@
+package payment
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeletePaymentMethodLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete Payment Method
+func NewDeletePaymentMethodLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeletePaymentMethodLogic {
+	return &DeletePaymentMethodLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeletePaymentMethodLogic) DeletePaymentMethod(req *types.DeletePaymentMethodRequest) error {
+	if err := l.svcCtx.PaymentModel.Delete(l.ctx, req.Id); err != nil {
+		l.Errorw("delete payment method error", logger.Field("id", req.Id), logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete payment method error: %s", err.Error())
+	}
+	return nil
+}

internal/logic/admin/payment/getPaymentMethodListLogic.go

@@ -0,0 +1,72 @@
+package payment
+
+import (
+	"context"
+	"encoding/json"
+
+	paymentPlatform "github.com/perfect-panel/ppanel-server/pkg/payment"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/payment"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetPaymentMethodListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetPaymentMethodListLogic Get Payment Method List
+func NewGetPaymentMethodListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPaymentMethodListLogic {
+	return &GetPaymentMethodListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPaymentMethodListLogic) GetPaymentMethodList(req *types.GetPaymentMethodListRequest) (resp *types.GetPaymentMethodListResponse, err error) {
+	total, list, err := l.svcCtx.PaymentModel.FindListByPage(l.ctx, req.Page, req.Size, &payment.Filter{
+		Search: req.Search,
+		Mark:   req.Platform,
+		Enable: req.Enable,
+	})
+	if err != nil {
+		l.Errorw("find payment method list error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find payment method list error: %s", err.Error())
+	}
+	resp = &types.GetPaymentMethodListResponse{
+		Total: total,
+		List:  make([]types.PaymentMethodDetail, len(list)),
+	}
+	for i, v := range list {
+		config := make(map[string]interface{})
+		_ = json.Unmarshal([]byte(v.Config), &config)
+		notifyUrl := ""
+		if paymentPlatform.ParsePlatform(v.Platform) != paymentPlatform.Balance {
+			if v.Domain != "" {
+				notifyUrl = v.Domain + "/v1/notify/" + v.Platform + "/" + v.Token
+			} else {
+				notifyUrl = "https://" + l.svcCtx.Config.Host + "/v1/notify/" + v.Platform + "/" + v.Token
+			}
+		}
+		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,
+		}
+	}
+	return
+}

internal/logic/admin/payment/getPaymentPlatformLogic.go

@@ -0,0 +1,32 @@
+package payment
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/payment"
+)
+
+type GetPaymentPlatformLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get supported payment platform
+func NewGetPaymentPlatformLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPaymentPlatformLogic {
+	return &GetPaymentPlatformLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPaymentPlatformLogic) GetPaymentPlatform() (resp *types.PlatformResponse, err error) {
+	resp = &types.PlatformResponse{
+		List: payment.GetSupportedPlatforms(),
+	}
+	return
+}

internal/logic/admin/payment/updatePaymentMethodLogic.go

@@ -0,0 +1,54 @@
+package payment
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/payment"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdatePaymentMethodLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update Payment Method
+func NewUpdatePaymentMethodLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdatePaymentMethodLogic {
+	return &UpdatePaymentMethodLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdatePaymentMethodLogic) UpdatePaymentMethod(req *types.UpdatePaymentMethodRequest) (resp *types.PaymentConfig, err error) {
+	if payment.ParsePlatform(req.Platform) == payment.UNSUPPORTED {
+		l.Errorw("unsupported payment platform", logger.Field("mark", req.Platform))
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(400, "UNSUPPORTED_PAYMENT_PLATFORM"), "unsupported payment platform: %s", req.Platform)
+	}
+	method, err := l.svcCtx.PaymentModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("find payment method error", logger.Field("id", req.Id), logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find payment method error: %s", err.Error())
+	}
+	config := parsePaymentPlatformConfig(l.ctx, payment.ParsePlatform(req.Platform), req.Config)
+	tool.DeepCopy(method, req)
+	method.Config = config
+	if err := l.svcCtx.PaymentModel.Update(l.ctx, method); err != nil {
+		l.Errorw("update payment method error", logger.Field("id", req.Id), logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update payment method error: %s", err.Error())
+	}
+	resp = &types.PaymentConfig{}
+	tool.DeepCopy(resp, method)
+	var configMap map[string]interface{}
+	_ = json.Unmarshal([]byte(method.Config), &configMap)
+	resp.Config = configMap
+	return
+}

internal/logic/admin/server/batchDeleteNodeGroupLogic.go

@@ -0,0 +1,44 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type BatchDeleteNodeGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewBatchDeleteNodeGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteNodeGroupLogic {
+	return &BatchDeleteNodeGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *BatchDeleteNodeGroupLogic) BatchDeleteNodeGroup(req *types.BatchDeleteNodeGroupRequest) error {
+	// Check if the group is empty
+	count, err := l.svcCtx.ServerModel.QueryServerCountByServerGroups(l.ctx, req.Ids)
+	if err != nil {
+		l.Errorw("[BatchDeleteNodeGroup] Query Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query server error: %v", err)
+	}
+	if count > 0 {
+		return errors.Wrapf(xerr.NewErrCode(xerr.NodeGroupNotEmpty), "group is not empty")
+	}
+	// Delete the group
+	err = l.svcCtx.ServerModel.BatchDeleteNodeGroup(l.ctx, req.Ids)
+	if err != nil {
+		l.Errorw("[BatchDeleteNodeGroup] Delete Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), err.Error())
+	}
+	return nil
+}

internal/logic/admin/server/batchDeleteNodeLogic.go

@@ -0,0 +1,43 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+type BatchDeleteNodeLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewBatchDeleteNodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteNodeLogic {
+	return &BatchDeleteNodeLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *BatchDeleteNodeLogic) BatchDeleteNode(req *types.BatchDeleteNodeRequest) error {
+	err := l.svcCtx.DB.Transaction(func(db *gorm.DB) error {
+		for _, id := range req.Ids {
+			err := l.svcCtx.ServerModel.Delete(l.ctx, id)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		l.Errorw("[BatchDeleteNode] Delete Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), err.Error())
+	}
+	return nil
+}

internal/logic/admin/server/createNodeGroupLogic.go

@@ -0,0 +1,40 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/server"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+
+	"github.com/pkg/errors"
+)
+
+type CreateNodeGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateNodeGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateNodeGroupLogic {
+	return &CreateNodeGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateNodeGroupLogic) CreateNodeGroup(req *types.CreateNodeGroupRequest) error {
+	groupInfo := &server.Group{
+		Name:        req.Name,
+		Description: req.Description,
+	}
+	err := l.svcCtx.ServerModel.InsertGroup(l.ctx, groupInfo)
+	if err != nil {
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), err.Error())
+	}
+	return nil
+}

internal/logic/admin/server/createNodeLogic.go

@@ -0,0 +1,106 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"time"
+
+	"github.com/hibiken/asynq"
+	"github.com/perfect-panel/ppanel-server/internal/model/server"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	queue "github.com/perfect-panel/ppanel-server/queue/types"
+	"github.com/pkg/errors"
+)
+
+type CreateNodeLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateNodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateNodeLogic {
+	return &CreateNodeLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateNodeLogic) CreateNode(req *types.CreateNodeRequest) error {
+	config, err := json.Marshal(req.Config)
+	if err != nil {
+		return err
+	}
+	var serverInfo server.Server
+	tool.DeepCopy(&serverInfo, req)
+	serverInfo.Config = string(config)
+	nodeRelay, err := json.Marshal(req.RelayNode)
+	if err != nil {
+		l.Errorw("[UpdateNode] Marshal RelayNode Error: ", logger.Field("error", err.Error()))
+		return err
+	}
+	if len(req.Tags) > 0 {
+		serverInfo.Tags = strings.Join(req.Tags, ",")
+	}
+
+	serverInfo.LastReportedAt = time.UnixMicro(1218124800)
+
+	serverInfo.City = req.City
+	serverInfo.Country = req.Country
+
+	serverInfo.RelayNode = string(nodeRelay)
+	if req.Protocol == "vless" {
+		var cfg types.Vless
+		if err := json.Unmarshal(config, &cfg); err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "json.Unmarshal error: %v", err.Error())
+		}
+		if cfg.Security == "reality" && cfg.SecurityConfig.RealityPublicKey == "" {
+			public, private, err := tool.Curve25519Genkey(false, "")
+			if err != nil {
+				return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "generate curve25519 key error")
+			}
+			cfg.SecurityConfig.RealityPublicKey = public
+			cfg.SecurityConfig.RealityPrivateKey = private
+			cfg.SecurityConfig.RealityShortId = tool.GenerateShortID(private)
+		}
+		if cfg.SecurityConfig.RealityServerAddr == "" {
+			cfg.SecurityConfig.RealityServerAddr = cfg.SecurityConfig.SNI
+		}
+		if cfg.SecurityConfig.RealityServerPort == 0 {
+			cfg.SecurityConfig.RealityServerPort = 443
+		}
+		config, _ = json.Marshal(cfg)
+		serverInfo.Config = string(config)
+	}
+
+	err = l.svcCtx.ServerModel.Insert(l.ctx, &serverInfo)
+	if err != nil {
+		l.Errorw("[CreateNode] Insert Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create server error: %v", err)
+	}
+
+	// Marshal the task payload
+	payload, err := json.Marshal(queue.GetNodeCountry{
+		Protocol:   serverInfo.Protocol,
+		ServerAddr: serverInfo.ServerAddr,
+	})
+	if err != nil {
+		l.Errorw("[GetNodeCountry]: Marshal Error", logger.Field("error", err.Error()))
+		return errors.Wrap(xerr.NewErrCode(xerr.ERROR), "Failed to marshal task payload")
+	}
+	// Create a queue task
+	task := asynq.NewTask(queue.ForthwithGetCountry, payload)
+	// Enqueue the task
+	taskInfo, err := l.svcCtx.Queue.Enqueue(task)
+	if err != nil {
+		l.Errorw("[GetNodeCountry]: Enqueue Error", logger.Field("error", err.Error()), logger.Field("payload", string(payload)))
+		return errors.Wrap(xerr.NewErrCode(xerr.ERROR), "Failed to enqueue task")
+	}
+	l.Infow("[GetNodeCountry]: Enqueue Success", logger.Field("taskID", taskInfo.ID), logger.Field("payload", string(payload)))
+	return nil
+}

internal/logic/admin/server/createRuleGroupLogic.go

@@ -0,0 +1,69 @@
+package server
+
+import (
+	"context"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/pkg/rules"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/server"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateRuleGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create rule group
+func NewCreateRuleGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateRuleGroupLogic {
+	return &CreateRuleGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+func parseAndValidateRules(ruleText, ruleName string) ([]string, error) {
+	var rs []string
+	ruleArr := strings.Split(ruleText, "\n")
+	if len(ruleArr) == 0 {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "rules is empty")
+	}
+
+	for _, s := range ruleArr {
+		r := rules.NewRule(s, ruleName)
+		if r == nil {
+			continue
+		}
+		if err := r.Validate(); err != nil {
+			continue
+		}
+		rs = append(rs, r.String())
+	}
+	return rs, nil
+}
+func (l *CreateRuleGroupLogic) CreateRuleGroup(req *types.CreateRuleGroupRequest) error {
+	rs, err := parseAndValidateRules(req.Rules, req.Name)
+	if err != nil {
+		return err
+	}
+
+	err = l.svcCtx.ServerModel.InsertRuleGroup(l.ctx, &server.RuleGroup{
+		Name:   req.Name,
+		Icon:   req.Icon,
+		Tags:   tool.StringSliceToString(req.Tags),
+		Rules:  strings.Join(rs, "\n"),
+		Enable: req.Enable,
+	})
+	if err != nil {
+		l.Errorw("[CreateRuleGroup] Insert Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create server rule group error: %v", err)
+	}
+	return nil
+}

internal/logic/admin/server/deleteNodeGroupLogic.go

@@ -0,0 +1,44 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteNodeGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteNodeGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteNodeGroupLogic {
+	return &DeleteNodeGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteNodeGroupLogic) DeleteNodeGroup(req *types.DeleteNodeGroupRequest) error {
+	// Check if the group is empty
+	count, err := l.svcCtx.ServerModel.QueryServerCountByServerGroups(l.ctx, []int64{req.Id})
+	if err != nil {
+		l.Errorw("[DeleteNodeGroup] Query Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query server error: %v", err)
+	}
+	if count > 0 {
+		return errors.Wrapf(xerr.NewErrCode(xerr.NodeGroupNotEmpty), "group is not empty")
+	}
+	// Delete the group
+	err = l.svcCtx.ServerModel.DeleteGroup(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[DeleteNodeGroup] Delete Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), err.Error())
+	}
+	return nil
+}

internal/logic/admin/server/deleteNodeLogic.go

@@ -0,0 +1,56 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+type DeleteNodeLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteNodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteNodeLogic {
+	return &DeleteNodeLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteNodeLogic) DeleteNode(req *types.DeleteNodeRequest) error {
+	err := l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
+		// Delete server
+		err := l.svcCtx.ServerModel.Delete(l.ctx, req.Id)
+		if err != nil {
+			return err
+		}
+		// Delete server to subscribe
+		subs, err := l.svcCtx.SubscribeModel.QuerySubscribeIdsByServerIdAndServerGroupId(l.ctx, req.Id, 0)
+		if err != nil {
+			return err
+		}
+		for _, sub := range subs {
+			servers := tool.StringToInt64Slice(sub.Server)
+			newServers := tool.RemoveElementBySlice(servers, req.Id)
+			sub.Server = tool.Int64SliceToString(newServers)
+			if err = l.svcCtx.SubscribeModel.Update(l.ctx, sub); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		l.Errorw("[DeleteNode] Delete Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete server error: %v", err)
+	}
+	return nil
+}

internal/logic/admin/server/deleteRuleGroupLogic.go

@@ -0,0 +1,35 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteRuleGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete rule group
+func NewDeleteRuleGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteRuleGroupLogic {
+	return &DeleteRuleGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteRuleGroupLogic) DeleteRuleGroup(req *types.DeleteRuleGroupRequest) error {
+	err := l.svcCtx.ServerModel.DeleteRuleGroup(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[DeleteRuleGroup] Delete Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete server rule group error: %v", err)
+	}
+	return nil
+}

internal/logic/admin/server/getNodeDetailLogic.go

@@ -0,0 +1,43 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetNodeDetailLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetNodeDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetNodeDetailLogic {
+	return &GetNodeDetailLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetNodeDetailLogic) GetNodeDetail(req *types.GetDetailRequest) (resp *types.Server, err error) {
+	detail, err := l.svcCtx.ServerModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get server detail error: %v", err.Error())
+	}
+	resp = &types.Server{}
+	tool.DeepCopy(resp, detail)
+	var cfg map[string]interface{}
+	err = json.Unmarshal([]byte(detail.Config), &cfg)
+	if err != nil {
+		cfg = make(map[string]interface{})
+	}
+	resp.Config = cfg
+	return
+}

internal/logic/admin/server/getNodeGroupListLogic.go

@@ -0,0 +1,39 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetNodeGroupListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetNodeGroupListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetNodeGroupListLogic {
+	return &GetNodeGroupListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetNodeGroupListLogic) GetNodeGroupList() (resp *types.GetNodeGroupListResponse, err error) {
+	nodeGroupList, err := l.svcCtx.ServerModel.QueryAllGroup(l.ctx)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), err.Error())
+	}
+	nodeGroups := make([]types.ServerGroup, 0)
+	tool.DeepCopy(&nodeGroups, nodeGroupList)
+	return &types.GetNodeGroupListResponse{
+		Total: int64(len(nodeGroups)),
+		List:  nodeGroups,
+	}, nil
+}

internal/logic/admin/server/getNodeListLogic.go

@@ -0,0 +1,100 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/server"
+
+	"github.com/redis/go-redis/v9"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetNodeListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetNodeListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetNodeListLogic {
+	return &GetNodeListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetNodeListLogic) GetNodeList(req *types.GetNodeServerListRequest) (resp *types.GetNodeServerListResponse, err error) {
+	total, list, err := l.svcCtx.ServerModel.FindServerListByFilter(l.ctx, &server.ServerFilter{
+		Page:   req.Page,
+		Size:   req.Size,
+		Search: req.Search,
+		Tag:    req.Tag,
+		Group:  req.GroupId,
+	})
+	if err != nil {
+		l.Errorw("[GetNodeList] Query Database Error: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), err.Error())
+	}
+	nodes := make([]types.Server, 0)
+	for _, v := range list {
+		node := types.Server{}
+		tool.DeepCopy(&node, v)
+		// default relay mode
+		if node.RelayMode == "" {
+			node.RelayMode = "none"
+		}
+		if len(v.Tags) > 0 {
+			if strings.Contains(v.Tags, ",") {
+				node.Tags = strings.Split(v.Tags, ",")
+			} else {
+				node.Tags = []string{v.Tags}
+			}
+		}
+		// parse config
+		var cfg map[string]interface{}
+		err = json.Unmarshal([]byte(v.Config), &cfg)
+		if err != nil {
+			cfg = make(map[string]interface{})
+		}
+		node.Config = cfg
+		relayNode := make([]types.NodeRelay, 0)
+		err = json.Unmarshal([]byte(v.RelayNode), &relayNode)
+		if err != nil {
+			l.Errorw("[GetNodeList] Unmarshal RelayNode Error: ", logger.Field("error", err.Error()), logger.Field("relayNode", v.RelayNode))
+		}
+		node.RelayNode = relayNode
+		var status types.NodeStatus
+		nodeStatus, err := l.svcCtx.NodeCache.GetNodeStatus(l.ctx, v.Id)
+		if err != nil {
+			// redis nil is not a Error
+			if !errors.Is(err, redis.Nil) {
+				l.Errorw("[GetNodeList] Get Node Status Error: ", logger.Field("error", err.Error()))
+			}
+		} else {
+			onlineUser, err := l.svcCtx.NodeCache.GetNodeOnlineUser(l.ctx, v.Id)
+			if err != nil {
+				l.Errorw("[GetNodeList] Get Node Online User Error: ", logger.Field("error", err.Error()))
+			} else {
+				status.Online = onlineUser
+			}
+			status.Cpu = nodeStatus.Cpu
+			status.Mem = nodeStatus.Mem
+			status.Disk = nodeStatus.Disk
+			status.UpdatedAt = nodeStatus.UpdatedAt
+		}
+		node.Status = &status
+		nodes = append(nodes, node)
+	}
+	return &types.GetNodeServerListResponse{
+		Total: total,
+		List:  nodes,
+	}, nil
+}

internal/logic/admin/server/getNodeTagListLogic.go

@@ -0,0 +1,53 @@
+package server
+
+import (
+	"context"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/server"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+type GetNodeTagListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get node tag list
+func NewGetNodeTagListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetNodeTagListLogic {
+	return &GetNodeTagListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetNodeTagListLogic) GetNodeTagList() (resp *types.GetNodeTagListResponse, err error) {
+	var nodeTags, tags []string
+	err = l.svcCtx.ServerModel.Transaction(l.ctx, func(db *gorm.DB) error {
+
+		return db.Model(&server.Server{}).Select("tags").Pluck("tags", &nodeTags).Error
+	})
+
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get node tag list failed, %s", err.Error())
+	}
+
+	for _, tag := range nodeTags {
+		tags = append(tags, strings.Split(tag, ",")...)
+	}
+
+	// Remove duplicate tags
+	tags = tool.RemoveDuplicateElements(tags...)
+
+	return &types.GetNodeTagListResponse{
+		Tags: tags,
+	}, nil
+}

internal/logic/admin/server/getRuleGroupListLogic.go

@@ -0,0 +1,52 @@
+package server
+
+import (
+	"context"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetRuleGroupListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get rule group list
+func NewGetRuleGroupListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetRuleGroupListLogic {
+	return &GetRuleGroupListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetRuleGroupListLogic) GetRuleGroupList() (resp *types.GetRuleGroupResponse, err error) {
+	nodeRuleGroupList, err := l.svcCtx.ServerModel.QueryAllRuleGroup(l.ctx)
+	if err != nil {
+		l.Errorw("[GetRuleGroupList] Query Database Error: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), err.Error())
+	}
+	nodeRuleGroups := make([]types.ServerRuleGroup, len(nodeRuleGroupList))
+	for i, v := range nodeRuleGroupList {
+		nodeRuleGroups[i] = types.ServerRuleGroup{
+			Id:        v.Id,
+			Icon:      v.Icon,
+			Name:      v.Name,
+			Tags:      strings.Split(v.Tags, ","),
+			Rules:     v.Rules,
+			Enable:    v.Enable,
+			CreatedAt: v.CreatedAt.UnixMilli(),
+			UpdatedAt: v.UpdatedAt.UnixMilli(),
+		}
+	}
+	return &types.GetRuleGroupResponse{
+		Total: int64(len(nodeRuleGroups)),
+		List:  nodeRuleGroups,
+	}, nil
+}

internal/logic/admin/server/nodeSortLogic.go

@@ -0,0 +1,82 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/server"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type NodeSortLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Node sort
+func NewNodeSortLogic(ctx context.Context, svcCtx *svc.ServiceContext) *NodeSortLogic {
+	return &NodeSortLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *NodeSortLogic) NodeSort(req *types.NodeSortRequest) error {
+	err := l.svcCtx.ServerModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		// find all servers id
+		var existingIDs []int64
+		db.Model(&server.Server{}).Select("id").Find(&existingIDs)
+		// check if the id is valid
+		validIDMap := make(map[int64]bool)
+		for _, id := range existingIDs {
+			validIDMap[id] = true
+		}
+		// check if the sort is valid
+		var validItems []types.SortItem
+		for _, item := range req.Sort {
+			if validIDMap[item.Id] {
+				validItems = append(validItems, item)
+			}
+		}
+		// query all servers
+		var servers []*server.Server
+		db.Model(&server.Server{}).Order("sort ASC").Find(&servers)
+		// create a map of the current sort
+		currentSortMap := make(map[int64]int64)
+		for _, item := range servers {
+			currentSortMap[item.Id] = item.Sort
+		}
+
+		// new sort map
+		newSortMap := make(map[int64]int64)
+		for _, item := range validItems {
+			newSortMap[item.Id] = item.Sort
+		}
+
+		var itemsToUpdate []types.SortItem
+		for _, item := range validItems {
+			if oldSort, exists := currentSortMap[item.Id]; exists && oldSort != item.Sort {
+				itemsToUpdate = append(itemsToUpdate, item)
+			}
+		}
+		for _, item := range itemsToUpdate {
+			if err := db.Model(&server.Server{}).Where("id = ?", item.Id).Update("sort", item.Sort).Error; err != nil {
+				l.Errorw("[NodeSort] Update Database Error: ", logger.Field("error", err.Error()), logger.Field("id", item.Id), logger.Field("sort", item.Sort))
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		l.Errorw("[NodeSort] Update Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), err.Error())
+	}
+	return nil
+}

internal/logic/admin/server/updateNodeGroupLogic.go

@@ -0,0 +1,40 @@
+package server
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateNodeGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateNodeGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateNodeGroupLogic {
+	return &UpdateNodeGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateNodeGroupLogic) UpdateNodeGroup(req *types.UpdateNodeGroupRequest) error {
+	// check server group exist
+	nodeGroup, err := l.svcCtx.ServerModel.FindOneGroup(l.ctx, req.Id)
+	if err != nil {
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), err.Error())
+	}
+	nodeGroup.Name = req.Name
+	nodeGroup.Description = req.Description
+	err = l.svcCtx.ServerModel.UpdateGroup(l.ctx, nodeGroup)
+	if err != nil {
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), err.Error())
+	}
+	return nil
+}

internal/logic/admin/server/updateNodeLogic.go

@@ -0,0 +1,110 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/pkg/device"
+
+	"github.com/hibiken/asynq"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	queue "github.com/perfect-panel/ppanel-server/queue/types"
+	"github.com/pkg/errors"
+)
+
+type UpdateNodeLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateNodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateNodeLogic {
+	return &UpdateNodeLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateNodeLogic) UpdateNode(req *types.UpdateNodeRequest) error {
+	// Check server exist
+	nodeInfo, err := l.svcCtx.ServerModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find server error: %v", err)
+	}
+	tool.DeepCopy(nodeInfo, req)
+	config, err := json.Marshal(req.Config)
+	if err != nil {
+		return err
+	}
+
+	nodeInfo.Config = string(config)
+	nodeRelay, err := json.Marshal(req.RelayNode)
+	if err != nil {
+		l.Errorw("[UpdateNode] Marshal RelayNode Error: ", logger.Field("error", err.Error()))
+		return err
+	}
+
+	if len(req.Tags) > 0 {
+		nodeInfo.Tags = strings.Join(req.Tags, ",")
+	}
+
+	nodeInfo.City = req.City
+	nodeInfo.Country = req.Country
+
+	nodeInfo.RelayNode = string(nodeRelay)
+	if req.Protocol == "vless" {
+		var cfg types.Vless
+		if err := json.Unmarshal(config, &cfg); err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "json.Unmarshal error: %v", err.Error())
+		}
+		if cfg.Security == "reality" && cfg.SecurityConfig.RealityPublicKey == "" {
+			public, private, err := tool.Curve25519Genkey(false, "")
+			if err != nil {
+				return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "generate curve25519 key error")
+			}
+			cfg.SecurityConfig.RealityPublicKey = public
+			cfg.SecurityConfig.RealityPrivateKey = private
+			cfg.SecurityConfig.RealityShortId = tool.GenerateShortID(private)
+		}
+		if cfg.SecurityConfig.RealityServerAddr == "" {
+			cfg.SecurityConfig.RealityServerAddr = cfg.SecurityConfig.SNI
+		}
+		if cfg.SecurityConfig.RealityServerPort == 0 {
+			cfg.SecurityConfig.RealityServerPort = 443
+		}
+		config, _ = json.Marshal(cfg)
+		nodeInfo.Config = string(config)
+	}
+	err = l.svcCtx.ServerModel.Update(l.ctx, nodeInfo)
+	if err != nil {
+		l.Errorw("[UpdateNode] Update Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create server error: %v", err)
+	}
+
+	// Marshal the task payload
+	payload, err := json.Marshal(queue.GetNodeCountry{
+		Protocol:   nodeInfo.Protocol,
+		ServerAddr: nodeInfo.ServerAddr,
+	})
+	if err != nil {
+		l.Errorw("[GetNodeCountry]: Marshal Error", logger.Field("error", err.Error()))
+		return errors.Wrap(xerr.NewErrCode(xerr.ERROR), "Failed to marshal task payload")
+	}
+	// Create a queue task
+	task := asynq.NewTask(queue.ForthwithGetCountry, payload)
+	// Enqueue the task
+	taskInfo, err := l.svcCtx.Queue.Enqueue(task)
+	if err != nil {
+		l.Errorw("[GetNodeCountry]: Enqueue Error", logger.Field("error", err.Error()), logger.Field("payload", string(payload)))
+		return errors.Wrap(xerr.NewErrCode(xerr.ERROR), "Failed to enqueue task")
+	}
+	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/server/updateRuleGroupLogic.go

@@ -0,0 +1,50 @@
+package server
+
+import (
+	"context"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/server"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type UpdateRuleGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewUpdateRuleGroupLogic Update rule group
+func NewUpdateRuleGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateRuleGroupLogic {
+	return &UpdateRuleGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateRuleGroupLogic) UpdateRuleGroup(req *types.UpdateRuleGroupRequest) error {
+	rs, err := parseAndValidateRules(req.Rules, req.Name)
+	if err != nil {
+		return err
+	}
+	err = l.svcCtx.ServerModel.UpdateRuleGroup(l.ctx, &server.RuleGroup{
+		Id:     req.Id,
+		Icon:   req.Icon,
+		Name:   req.Name,
+		Tags:   tool.StringSliceToString(req.Tags),
+		Rules:  strings.Join(rs, "\n"),
+		Enable: req.Enable,
+	})
+	if err != nil {
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), err.Error())
+	}
+	return nil
+}

internal/logic/admin/subscribe/batchDeleteSubscribeGroupLogic.go

@@ -0,0 +1,36 @@
+package subscribe
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribe"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type BatchDeleteSubscribeGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Batch delete subscribe group
+func NewBatchDeleteSubscribeGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteSubscribeGroupLogic {
+	return &BatchDeleteSubscribeGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *BatchDeleteSubscribeGroupLogic) BatchDeleteSubscribeGroup(req *types.BatchDeleteSubscribeGroupRequest) error {
+	err := l.svcCtx.DB.Model(&subscribe.Group{}).Where("id in ?", req.Ids).Delete(&subscribe.Group{}).Error
+	if err != nil {
+		l.Logger.Error("[BatchDeleteSubscribeGroup] Delete Database Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "batch delete subscribe group failed: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/subscribe/batchDeleteSubscribeLogic.go

@@ -0,0 +1,59 @@
+package subscribe
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/user"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type BatchDeleteSubscribeLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Batch delete subscribe
+func NewBatchDeleteSubscribeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteSubscribeLogic {
+	return &BatchDeleteSubscribeLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+var errorIsExistActiveUser = errors.New("subscription ID belongs to an active user subscription")
+
+func (l *BatchDeleteSubscribeLogic) BatchDeleteSubscribe(req *types.BatchDeleteSubscribeRequest) error {
+	err := l.svcCtx.DB.Transaction(func(tx *gorm.DB) error {
+		for _, id := range req.Ids {
+			var count int64
+			// Validate whether the subscription ID belongs to an active user subscription.
+			if err := tx.Model(&user.Subscribe{}).Where("subscribe_id = ? AND status = 1", id).Count(&count).Find(&user.Subscribe{}).Error; err != nil {
+				l.Logger.Error("[BatchDeleteSubscribe] Query Subscribe Error: ", logger.Field("error", err.Error()))
+				return err
+			}
+			if count > 0 {
+				return errorIsExistActiveUser
+			}
+			if err := l.svcCtx.SubscribeModel.Delete(l.ctx, id, tx); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		if errors.Is(err, errorIsExistActiveUser) {
+			return errors.Wrapf(xerr.NewErrCode(xerr.SubscribeIsUsedError), "subscription ID belongs to an active user subscription")
+		}
+		l.Logger.Error("[BatchDeleteSubscribe] Transaction Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete subscribe failed: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/subscribe/createSubscribeGroupLogic.go

@@ -0,0 +1,39 @@
+package subscribe
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribe"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateSubscribeGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create subscribe group
+func NewCreateSubscribeGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateSubscribeGroupLogic {
+	return &CreateSubscribeGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateSubscribeGroupLogic) CreateSubscribeGroup(req *types.CreateSubscribeGroupRequest) error {
+	err := l.svcCtx.DB.Model(&subscribe.Group{}).Create(&subscribe.Group{
+		Name:        req.Name,
+		Description: req.Description,
+	}).Error
+	if err != nil {
+		l.Logger.Error("[CreateSubscribeGroupLogic] create subscribe group failed: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create subscribe group failed: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/subscribe/createSubscribeLogic.go

@@ -0,0 +1,68 @@
+package subscribe
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribe"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateSubscribeLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewCreateSubscribeLogic Create subscribe
+func NewCreateSubscribeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateSubscribeLogic {
+	return &CreateSubscribeLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateSubscribeLogic) CreateSubscribe(req *types.CreateSubscribeRequest) error {
+	discount := ""
+	if len(req.Discount) > 0 {
+		val, _ := json.Marshal(req.Discount)
+		discount = string(val)
+	}
+	sub := &subscribe.Subscribe{
+		Id:             0,
+		Name:           req.Name,
+		Description:    req.Description,
+		UnitPrice:      req.UnitPrice,
+		UnitTime:       req.UnitTime,
+		Discount:       discount,
+		Replacement:    req.Replacement,
+		Inventory:      req.Inventory,
+		Traffic:        req.Traffic,
+		SpeedLimit:     req.SpeedLimit,
+		DeviceLimit:    req.DeviceLimit,
+		Quota:          req.Quota,
+		GroupId:        req.GroupId,
+		ServerGroup:    tool.Int64SliceToString(req.ServerGroup),
+		Server:         tool.Int64SliceToString(req.Server),
+		Show:           req.Show,
+		Sell:           req.Sell,
+		Sort:           0,
+		DeductionRatio: req.DeductionRatio,
+		AllowDeduction: req.AllowDeduction,
+		ResetCycle:     req.ResetCycle,
+		RenewalReset:   req.RenewalReset,
+	}
+	err := l.svcCtx.SubscribeModel.Insert(l.ctx, sub)
+	if err != nil {
+		l.Logger.Error("[CreateSubscribeLogic] create subscribe error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create subscribe error: %v", err.Error())
+	}
+
+	return nil
+}

internal/logic/admin/subscribe/deleteSubscribeGroupLogic.go

@@ -0,0 +1,36 @@
+package subscribe
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribe"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteSubscribeGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete subscribe group
+func NewDeleteSubscribeGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteSubscribeGroupLogic {
+	return &DeleteSubscribeGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteSubscribeGroupLogic) DeleteSubscribeGroup(req *types.DeleteSubscribeGroupRequest) error {
+	err := l.svcCtx.DB.Model(&subscribe.Group{}).Where("id = ?", req.Id).Delete(&subscribe.Group{}).Error
+	if err != nil {
+		l.Logger.Error("[DeleteSubscribeGroupLogic] delete subscribe group failed: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete subscribe group failed: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/subscribe/deleteSubscribeLogic.go

@@ -0,0 +1,51 @@
+package subscribe
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/user"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteSubscribeLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete subscribe
+func NewDeleteSubscribeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteSubscribeLogic {
+	return &DeleteSubscribeLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteSubscribeLogic) DeleteSubscribe(req *types.DeleteSubscribeRequest) error {
+	// Check if the subscribe exists
+	var total int64
+	err := l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		return db.Model(&user.Subscribe{}).Where("subscribe_id = ? AND `status` = ?", req.Id, 1).Count(&total).Find(&user.Subscribe{}).Error
+	})
+	if err != nil {
+		l.Logger.Error("[DeleteSubscribeLogic] check subscribe failed: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "check subscribe failed: %v", err.Error())
+	}
+	if total != 0 {
+		return errors.Wrapf(xerr.NewErrCode(xerr.SubscribeIsUsedError), "subscribe is used")
+	}
+
+	err = l.svcCtx.SubscribeModel.Delete(l.ctx, req.Id)
+	if err != nil {
+		l.Logger.Error("[DeleteSubscribeLogic] delete subscribe failed: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete subscribe failed: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/subscribe/getSubscribeDetailsLogic.go

@@ -0,0 +1,47 @@
+package subscribe
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetSubscribeDetailsLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get subscribe details
+func NewGetSubscribeDetailsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSubscribeDetailsLogic {
+	return &GetSubscribeDetailsLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetSubscribeDetailsLogic) GetSubscribeDetails(req *types.GetSubscribeDetailsRequest) (resp *types.Subscribe, err error) {
+	sub, err := l.svcCtx.SubscribeModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Logger.Error("[GetSubscribeDetailsLogic] get subscribe details failed: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get subscribe details failed: %v", err.Error())
+	}
+	resp = &types.Subscribe{}
+	tool.DeepCopy(resp, sub)
+	if sub.Discount != "" {
+		err = json.Unmarshal([]byte(sub.Discount), &resp.Discount)
+		if err != nil {
+			l.Logger.Error("[GetSubscribeDetailsLogic] JSON unmarshal failed: ", logger.Field("error", err.Error()), logger.Field("discount", sub.Discount))
+		}
+	}
+	resp.Server = tool.StringToInt64Slice(sub.Server)
+	resp.ServerGroup = tool.StringToInt64Slice(sub.ServerGroup)
+	return resp, nil
+}

internal/logic/admin/subscribe/getSubscribeGroupListLogic.go

@@ -0,0 +1,44 @@
+package subscribe
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribe"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetSubscribeGroupListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get subscribe group list
+func NewGetSubscribeGroupListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSubscribeGroupListLogic {
+	return &GetSubscribeGroupListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetSubscribeGroupListLogic) GetSubscribeGroupList() (resp *types.GetSubscribeGroupListResponse, err error) {
+	var list []*subscribe.Group
+	var total int64
+	err = l.svcCtx.DB.Model(&subscribe.Group{}).Count(&total).Find(&list).Error
+	if err != nil {
+		l.Logger.Error("[GetSubscribeGroupListLogic] get subscribe group list failed: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get subscribe group list failed: %v", err.Error())
+	}
+	groupList := make([]types.SubscribeGroup, 0)
+	tool.DeepCopy(&groupList, list)
+	return &types.GetSubscribeGroupListResponse{
+		Total: total,
+		List:  groupList,
+	}, nil
+}

internal/logic/admin/subscribe/getSubscribeListLogic.go

@@ -0,0 +1,72 @@
+package subscribe
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetSubscribeListLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get subscribe list
+func NewGetSubscribeListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSubscribeListLogic {
+	return &GetSubscribeListLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetSubscribeListLogic) GetSubscribeList(req *types.GetSubscribeListRequest) (resp *types.GetSubscribeListResponse, err error) {
+	total, list, err := l.svcCtx.SubscribeModel.QuerySubscribeListByPage(l.ctx, int(req.Page), int(req.Size), req.GroupId, req.Search)
+	if err != nil {
+		l.Logger.Error("[GetSubscribeListLogic] get subscribe list failed: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get subscribe list failed: %v", err.Error())
+	}
+	var (
+		subscribeIdList = make([]int64, 0, len(list))
+		resultList      = make([]types.SubscribeItem, 0, len(list))
+	)
+	for _, item := range list {
+		subscribeIdList = append(subscribeIdList, item.Id)
+		var sub types.SubscribeItem
+		tool.DeepCopy(&sub, item)
+		if item.Discount != "" {
+			err = json.Unmarshal([]byte(item.Discount), &sub.Discount)
+			if err != nil {
+				l.Logger.Error("[GetSubscribeListLogic] JSON unmarshal failed: ", logger.Field("error", err.Error()), logger.Field("discount", item.Discount))
+			}
+		}
+		sub.Server = tool.StringToInt64Slice(item.Server)
+		sub.ServerGroup = tool.StringToInt64Slice(item.ServerGroup)
+		resultList = append(resultList, sub)
+	}
+
+	subscribeMaps, err := l.svcCtx.UserModel.QueryActiveSubscriptions(l.ctx, subscribeIdList...)
+	if err != nil {
+		l.Logger.Error("[GetSubscribeListLogic] get user subscribe failed: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get user subscribe failed: %v", err.Error())
+	}
+
+	for i, item := range resultList {
+		if subscribe, ok := subscribeMaps[item.Id]; ok {
+			resultList[i].Sold = subscribe
+		}
+	}
+
+	resp = &types.GetSubscribeListResponse{
+		Total: total,
+		List:  resultList,
+	}
+	return
+}

internal/logic/admin/subscribe/subscribeSortLogic.go

@@ -0,0 +1,64 @@
+package subscribe
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type SubscribeSortLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewSubscribeSortLogic Subscribe sort
+func NewSubscribeSortLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SubscribeSortLogic {
+	return &SubscribeSortLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *SubscribeSortLogic) SubscribeSort(req *types.SubscribeSortRequest) error {
+	var sort = make(map[int64]int64, len(req.Sort))
+	var ids []int64
+	for i, v := range req.Sort {
+		sort[v.Id] = int64(i)
+		ids = append(ids, v.Id)
+	}
+	// query min sort by ids
+	minSort, err := l.svcCtx.SubscribeModel.QuerySubscribeMinSortByIds(l.ctx, ids)
+	if err != nil {
+		l.Logger.Error("[SubscribeSortLogic] query subscribe list by ids error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query subscribe list by ids error: %v", err.Error())
+	}
+	subs, err := l.svcCtx.SubscribeModel.QuerySubscribeListByIds(l.ctx, ids)
+	if err != nil {
+		l.Logger.Error("[SubscribeSortLogic] query subscribe list by ids error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query subscribe list by ids error: %v", err.Error())
+	}
+	// reordering
+	for _, sub := range subs {
+		if newSort, ok := sort[sub.Id]; ok {
+			sub.Sort = minSort + newSort
+		}
+	}
+	// update sort
+	err = l.svcCtx.SubscribeModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		return db.Save(subs).Error
+	})
+	if err != nil {
+		l.Logger.Error("[SubscribeSortLogic] update subscribe sort error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update subscribe sort error: %v", err.Error())
+	}
+	l.Logger.Info("[UpdateSubscribeSort] Successfully updated subscribe sort")
+	return nil
+}

internal/logic/admin/subscribe/updateSubscribeGroupLogic.go

@@ -0,0 +1,40 @@
+package subscribe
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribe"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateSubscribeGroupLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update subscribe group
+func NewUpdateSubscribeGroupLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateSubscribeGroupLogic {
+	return &UpdateSubscribeGroupLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateSubscribeGroupLogic) UpdateSubscribeGroup(req *types.UpdateSubscribeGroupRequest) error {
+	err := l.svcCtx.DB.Model(&subscribe.Group{}).Where("id = ?", req.Id).Save(&subscribe.Group{
+		Id:          req.Id,
+		Name:        req.Name,
+		Description: req.Description,
+	}).Error
+	if err != nil {
+		l.Logger.Error("[UpdateSubscribeGroup] update subscribe group failed", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update subscribe group failed: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/subscribe/updateSubscribeLogic.go

@@ -0,0 +1,76 @@
+package subscribe
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/pkg/device"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribe"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateSubscribeLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update subscribe
+func NewUpdateSubscribeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateSubscribeLogic {
+	return &UpdateSubscribeLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateSubscribeLogic) UpdateSubscribe(req *types.UpdateSubscribeRequest) error {
+	// Query the database to get the subscribe information
+	_, err := l.svcCtx.SubscribeModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Logger.Error("[UpdateSubscribe] Database query error", logger.Field("error", err.Error()), logger.Field("subscribe_id", req.Id))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get subscribe error: %v", err.Error())
+	}
+	discount := ""
+	if len(req.Discount) > 0 {
+		val, _ := json.Marshal(req.Discount)
+		discount = string(val)
+	}
+	sub := &subscribe.Subscribe{
+		Id:             req.Id,
+		Name:           req.Name,
+		Description:    req.Description,
+		UnitPrice:      req.UnitPrice,
+		UnitTime:       req.UnitTime,
+		Discount:       discount,
+		Replacement:    req.Replacement,
+		Inventory:      req.Inventory,
+		Traffic:        req.Traffic,
+		SpeedLimit:     req.SpeedLimit,
+		DeviceLimit:    req.DeviceLimit,
+		Quota:          req.Quota,
+		GroupId:        req.GroupId,
+		ServerGroup:    tool.Int64SliceToString(req.ServerGroup),
+		Server:         tool.Int64SliceToString(req.Server),
+		Show:           req.Show,
+		Sell:           req.Sell,
+		Sort:           req.Sort,
+		DeductionRatio: req.DeductionRatio,
+		AllowDeduction: req.AllowDeduction,
+		ResetCycle:     req.ResetCycle,
+		RenewalReset:   req.RenewalReset,
+	}
+	err = l.svcCtx.SubscribeModel.Update(l.ctx, sub)
+	if err != nil {
+		l.Logger.Error("[UpdateSubscribe] update subscribe failed", logger.Field("error", err.Error()), logger.Field("subscribe", sub))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update subscribe error: %v", err.Error())
+	}
+	l.svcCtx.DeviceManager.Broadcast(device.SubscribeUpdate)
+	return nil
+}

internal/logic/admin/system/createApplicationLogic.go

@@ -0,0 +1,125 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/application"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateApplicationLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateApplicationLogic {
+	return &CreateApplicationLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateApplicationLogic) CreateApplication(req *types.CreateApplicationRequest) error {
+	var ios []application.ApplicationVersion
+	if len(req.Platform.IOS) > 0 {
+		for _, ios_ := range req.Platform.IOS {
+			ios = append(ios, application.ApplicationVersion{
+				Url:         ios_.Url,
+				Version:     ios_.Version,
+				Platform:    "ios",
+				IsDefault:   ios_.IsDefault,
+				Description: ios_.Description,
+			})
+		}
+	}
+
+	var mac []application.ApplicationVersion
+	if len(req.Platform.MacOS) > 0 {
+		for _, mac_ := range req.Platform.MacOS {
+			mac = append(mac, application.ApplicationVersion{
+				Url:         mac_.Url,
+				Version:     mac_.Version,
+				Platform:    "macos",
+				IsDefault:   mac_.IsDefault,
+				Description: mac_.Description,
+			})
+		}
+	}
+
+	var linux []application.ApplicationVersion
+	if len(req.Platform.Linux) > 0 {
+		for _, linux_ := range req.Platform.Linux {
+			linux = append(linux, application.ApplicationVersion{
+				Url:         linux_.Url,
+				Version:     linux_.Version,
+				Platform:    "linux",
+				IsDefault:   linux_.IsDefault,
+				Description: linux_.Description,
+			})
+		}
+	}
+
+	var android []application.ApplicationVersion
+	if len(req.Platform.Android) > 0 {
+		for _, android_ := range req.Platform.Android {
+			android = append(android, application.ApplicationVersion{
+				Url:         android_.Url,
+				Version:     android_.Version,
+				Platform:    "android",
+				IsDefault:   android_.IsDefault,
+				Description: android_.Description,
+			})
+		}
+	}
+
+	var windows []application.ApplicationVersion
+	if len(req.Platform.Windows) > 0 {
+		for _, windows_ := range req.Platform.Windows {
+			windows = append(windows, application.ApplicationVersion{
+				Url:         windows_.Url,
+				Version:     windows_.Version,
+				Platform:    "windows",
+				IsDefault:   windows_.IsDefault,
+				Description: windows_.Description,
+			})
+		}
+	}
+
+	var harmony []application.ApplicationVersion
+	if len(req.Platform.Harmony) > 0 {
+		for _, harmony_ := range req.Platform.Harmony {
+			harmony = append(harmony, application.ApplicationVersion{
+				Url:         harmony_.Url,
+				Version:     harmony_.Version,
+				Platform:    "harmony",
+				IsDefault:   harmony_.IsDefault,
+				Description: harmony_.Description,
+			})
+		}
+	}
+	var applicationVersions []application.ApplicationVersion
+	applicationVersions = append(applicationVersions, ios...)
+	applicationVersions = append(applicationVersions, mac...)
+	applicationVersions = append(applicationVersions, linux...)
+	applicationVersions = append(applicationVersions, android...)
+	applicationVersions = append(applicationVersions, windows...)
+	applicationVersions = append(applicationVersions, harmony...)
+	app := application.Application{
+		Name:                req.Name,
+		Icon:                req.Icon,
+		SubscribeType:       req.SubscribeType,
+		ApplicationVersions: applicationVersions,
+	}
+	err := l.svcCtx.ApplicationModel.Insert(l.ctx, &app)
+	if err != nil {
+		l.Errorw("[CreateApplicationLogic] create application error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create application error: %v", err)
+	}
+	return nil
+}

internal/logic/admin/system/createApplicationVersionLogic.go

@@ -0,0 +1,44 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/application"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type CreateApplicationVersionLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Create application version
+func NewCreateApplicationVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateApplicationVersionLogic {
+	return &CreateApplicationVersionLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateApplicationVersionLogic) CreateApplicationVersion(req *types.CreateApplicationVersionRequest) error {
+	create := &application.ApplicationVersion{
+		Url:           req.Url,
+		Platform:      req.Platform,
+		Version:       req.Version,
+		Description:   req.Description,
+		IsDefault:     req.IsDefault,
+		ApplicationId: req.ApplicationId,
+	}
+	err := l.svcCtx.ApplicationModel.InsertVersion(l.ctx, create)
+	if err != nil {
+		l.Errorw("[CreateApplicationVersion] create application version error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create application version error: %v", err)
+	}
+	return nil
+}

internal/logic/admin/system/deleteApplicationLogic.go

@@ -0,0 +1,35 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteApplicationLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteApplicationLogic {
+	return &DeleteApplicationLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteApplicationLogic) DeleteApplication(req *types.DeleteApplicationRequest) error {
+	// delete application
+	err := l.svcCtx.ApplicationModel.Delete(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[DeleteApplicationLogic] delete application error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete application error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/system/deleteApplicationVersionLogic.go

@@ -0,0 +1,36 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type DeleteApplicationVersionLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Delete application
+func NewDeleteApplicationVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteApplicationVersionLogic {
+	return &DeleteApplicationVersionLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteApplicationVersionLogic) DeleteApplicationVersion(req *types.DeleteApplicationVersionRequest) error {
+	// delete application
+	err := l.svcCtx.ApplicationModel.DeleteVersion(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[DeleteApplicationVersion] delete application version error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete application version error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/system/getApplicationConfigLogic.go

@@ -0,0 +1,49 @@
+package system
+
+import (
+	"context"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type GetApplicationConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// get application config
+func NewGetApplicationConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetApplicationConfigLogic {
+	return &GetApplicationConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetApplicationConfigLogic) GetApplicationConfig() (resp *types.ApplicationConfig, err error) {
+	resp = &types.ApplicationConfig{}
+	appConfig, err := l.svcCtx.ApplicationModel.FindOneConfig(l.ctx, 1)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			err = nil
+			return
+		}
+		l.Errorw("[GetApplicationConfig] Database Error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get app config  error: %v", err.Error())
+	}
+	resp.AppId = appConfig.AppId
+	resp.EncryptionKey = appConfig.EncryptionKey
+	resp.EncryptionMethod = appConfig.EncryptionMethod
+	resp.Domains = strings.Split(appConfig.Domains, ";")
+	resp.StartupPicture = appConfig.StartupPicture
+	resp.StartupPictureSkipTime = appConfig.StartupPictureSkipTime
+	return
+}

internal/logic/admin/system/getApplicationLogic.go

@@ -0,0 +1,113 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/application"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type GetApplicationLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get application
+func NewGetApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetApplicationLogic {
+	return &GetApplicationLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetApplicationLogic) GetApplication() (resp *types.ApplicationResponse, err error) {
+	resp = &types.ApplicationResponse{}
+	var applications []*application.Application
+	err = l.svcCtx.ApplicationModel.Transaction(l.ctx, func(tx *gorm.DB) (err error) {
+		return tx.Model(applications).Preload("ApplicationVersions").Find(&applications).Error
+	})
+	if err != nil {
+		l.Errorw("[GetApplicationLogic] get application error: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get application error: %v", err.Error())
+	}
+
+	if len(applications) == 0 {
+		return resp, nil
+	}
+
+	for _, app := range applications {
+		applicationResponse := types.ApplicationResponseInfo{
+			Id:            app.Id,
+			Name:          app.Name,
+			Icon:          app.Icon,
+			Description:   app.Description,
+			SubscribeType: app.SubscribeType,
+		}
+		applicationVersions := app.ApplicationVersions
+		if len(applicationVersions) != 0 {
+			for _, applicationVersion := range applicationVersions {
+				switch applicationVersion.Platform {
+				case "ios":
+					applicationResponse.Platform.IOS = append(applicationResponse.Platform.IOS, &types.ApplicationVersion{
+						Id:          applicationVersion.Id,
+						Url:         applicationVersion.Url,
+						Version:     applicationVersion.Version,
+						IsDefault:   applicationVersion.IsDefault,
+						Description: applicationVersion.Description,
+					})
+				case "macos":
+					applicationResponse.Platform.MacOS = append(applicationResponse.Platform.MacOS, &types.ApplicationVersion{
+						Id:          applicationVersion.Id,
+						Url:         applicationVersion.Url,
+						Version:     applicationVersion.Version,
+						IsDefault:   applicationVersion.IsDefault,
+						Description: applicationVersion.Description,
+					})
+				case "linux":
+					applicationResponse.Platform.Linux = append(applicationResponse.Platform.Linux, &types.ApplicationVersion{
+						Id:          applicationVersion.Id,
+						Url:         applicationVersion.Url,
+						Version:     applicationVersion.Version,
+						IsDefault:   applicationVersion.IsDefault,
+						Description: applicationVersion.Description,
+					})
+				case "android":
+					applicationResponse.Platform.Android = append(applicationResponse.Platform.Android, &types.ApplicationVersion{
+						Id:          applicationVersion.Id,
+						Url:         applicationVersion.Url,
+						Version:     applicationVersion.Version,
+						IsDefault:   applicationVersion.IsDefault,
+						Description: applicationVersion.Description,
+					})
+				case "windows":
+					applicationResponse.Platform.Windows = append(applicationResponse.Platform.Windows, &types.ApplicationVersion{
+						Id:          applicationVersion.Id,
+						Url:         applicationVersion.Url,
+						Version:     applicationVersion.Version,
+						IsDefault:   applicationVersion.IsDefault,
+						Description: applicationVersion.Description,
+					})
+				case "harmony":
+					applicationResponse.Platform.Harmony = append(applicationResponse.Platform.Harmony, &types.ApplicationVersion{
+						Id:          applicationVersion.Id,
+						Url:         applicationVersion.Url,
+						Version:     applicationVersion.Version,
+						IsDefault:   applicationVersion.IsDefault,
+						Description: applicationVersion.Description,
+					})
+				}
+			}
+		}
+		resp.Applications = append(resp.Applications, applicationResponse)
+	}
+
+	return
+}

internal/logic/admin/system/getCurrencyConfigLogic.go

@@ -0,0 +1,38 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetCurrencyConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get Currency Config
+func NewGetCurrencyConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetCurrencyConfigLogic {
+	return &GetCurrencyConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetCurrencyConfigLogic) GetCurrencyConfig() (resp *types.CurrencyConfig, err error) {
+	configs, err := l.svcCtx.SystemModel.GetCurrencyConfig(l.ctx)
+	if err != nil {
+		l.Errorw("[GetCurrencyConfigLogic] GetCurrencyConfig error: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetCurrencyConfig error: %v", err.Error())
+	}
+	resp = &types.CurrencyConfig{}
+	tool.SystemConfigSliceReflectToStruct(configs, resp)
+	return
+}

internal/logic/admin/system/getInviteConfigLogic.go

@@ -0,0 +1,40 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetInviteConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetInviteConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetInviteConfigLogic {
+	return &GetInviteConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetInviteConfigLogic) GetInviteConfig() (*types.InviteConfig, error) {
+	resp := &types.InviteConfig{}
+	// get invite config from db
+	configs, err := l.svcCtx.SystemModel.GetInviteConfig(l.ctx)
+	if err != nil {
+		l.Errorw("[GetInviteConfigLogic] get invite config error: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get invite config error: %v", err.Error())
+	}
+	// reflect to response
+	tool.SystemConfigSliceReflectToStruct(configs, resp)
+
+	return resp, nil
+}

internal/logic/admin/system/getNodeConfigLogic.go

@@ -0,0 +1,40 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetNodeConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetNodeConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetNodeConfigLogic {
+	return &GetNodeConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetNodeConfigLogic) GetNodeConfig() (*types.NodeConfig, error) {
+	resp := &types.NodeConfig{}
+
+	// get server config from db
+	configs, err := l.svcCtx.SystemModel.GetNodeConfig(l.ctx)
+	if err != nil {
+		l.Errorw("[GetNodeConfigLogic] GetNodeConfig get server config error: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetNodeConfig get server config error: %v", err.Error())
+	}
+	// reflect to response
+	tool.SystemConfigSliceReflectToStruct(configs, resp)
+	return resp, nil
+}

internal/logic/admin/system/getNodeMultiplierLogic.go

@@ -0,0 +1,46 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetNodeMultiplierLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get Node Multiplier
+func NewGetNodeMultiplierLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetNodeMultiplierLogic {
+	return &GetNodeMultiplierLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetNodeMultiplierLogic) GetNodeMultiplier() (resp *types.GetNodeMultiplierResponse, err error) {
+	data, err := l.svcCtx.SystemModel.FindNodeMultiplierConfig(l.ctx)
+	if err != nil {
+		l.Logger.Error("Get Node Multiplier Config Error: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get Node Multiplier Config Error: %s", err.Error())
+	}
+	var periods []types.TimePeriod
+	if data.Value != "" {
+		if err := json.Unmarshal([]byte(data.Value), &periods); err != nil {
+			l.Logger.Error("Unmarshal Node Multiplier Config Error: ", logger.Field("error", err.Error()), logger.Field("value", data.Value))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Unmarshal Node Multiplier Config Error: %s", err.Error())
+		}
+	}
+
+	return &types.GetNodeMultiplierResponse{
+		Periods: periods,
+	}, nil
+}

internal/logic/admin/system/getPrivacyPolicyConfigLogic.go

@@ -0,0 +1,40 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetPrivacyPolicyConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewGetPrivacyPolicyConfigLogic get Privacy Policy Config
+func NewGetPrivacyPolicyConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPrivacyPolicyConfigLogic {
+	return &GetPrivacyPolicyConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetPrivacyPolicyConfigLogic) GetPrivacyPolicyConfig() (resp *types.PrivacyPolicyConfig, err error) {
+	resp = &types.PrivacyPolicyConfig{}
+	// get tos config from db
+	configs, err := l.svcCtx.SystemModel.GetTosConfig(l.ctx)
+	if err != nil {
+		l.Errorw("[GetTosConfig] GetTosConfig error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetTosConfig error: %v", err.Error())
+	}
+	// reflect to response
+	tool.SystemConfigSliceReflectToStruct(configs, resp)
+	return
+}

internal/logic/admin/system/getRegisterConfigLogic.go

@@ -0,0 +1,41 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetRegisterConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetRegisterConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetRegisterConfigLogic {
+	return &GetRegisterConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetRegisterConfigLogic) GetRegisterConfig() (*types.RegisterConfig, error) {
+	resp := &types.RegisterConfig{}
+
+	// get register config from database
+	configs, err := l.svcCtx.SystemModel.GetRegisterConfig(l.ctx)
+	if err != nil {
+		l.Errorw("[GetRegisterConfig] Database query error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get register config error: %v", err.Error())
+	}
+
+	// reflect to response
+	tool.SystemConfigSliceReflectToStruct(configs, resp)
+	return resp, nil
+}

internal/logic/admin/system/getSiteConfigLogic.go

@@ -0,0 +1,39 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetSiteConfigLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logger.Logger
+}
+
+func NewGetSiteConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSiteConfigLogic {
+	return &GetSiteConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetSiteConfigLogic) GetSiteConfig() (resp *types.SiteConfig, err error) {
+	resp = &types.SiteConfig{}
+	// get site config from db
+	siteConfigs, err := l.svcCtx.SystemModel.GetSiteConfig(l.ctx)
+	if err != nil {
+		l.Logger.Error("[GetSiteConfig] Database query error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get site config failed: %v", err.Error())
+	}
+	// reflect to response
+	tool.SystemConfigSliceReflectToStruct(siteConfigs, resp)
+	return resp, nil
+}

internal/logic/admin/system/getSubscribeConfigLogic.go

@@ -0,0 +1,40 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetSubscribeConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetSubscribeConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSubscribeConfigLogic {
+	return &GetSubscribeConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetSubscribeConfigLogic) GetSubscribeConfig() (resp *types.SubscribeConfig, err error) {
+	resp = &types.SubscribeConfig{}
+	// get subscribe config from db
+	subscribeConfigs, err := l.svcCtx.SystemModel.GetSubscribeConfig(l.ctx)
+	if err != nil {
+		l.Errorw("[GetSubscribeConfig] Database query error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get subscribe config failed: %v", err.Error())
+	}
+
+	// reflect to response
+	tool.SystemConfigSliceReflectToStruct(subscribeConfigs, resp)
+	return resp, nil
+}

internal/logic/admin/system/getSubscribeTypeLogic.go

@@ -0,0 +1,42 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribeType"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetSubscribeTypeLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logger.Logger
+}
+
+func NewGetSubscribeTypeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSubscribeTypeLogic {
+	return &GetSubscribeTypeLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logger.WithContext(ctx),
+	}
+}
+
+func (l *GetSubscribeTypeLogic) GetSubscribeType() (resp *types.SubscribeType, err error) {
+	var list []*subscribeType.SubscribeType
+	err = l.svcCtx.DB.Model(&subscribeType.SubscribeType{}).Find(&list).Error
+	if err != nil {
+		l.Errorw("[GetSubscribeType] get subscribe type failed", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get subscribe type failed: %v", err)
+	}
+	typeList := make([]string, 0)
+	for _, item := range list {
+		typeList = append(typeList, item.Name)
+	}
+	return &types.SubscribeType{
+		SubscribeTypes: typeList,
+	}, nil
+}

internal/logic/admin/system/getTosConfigLogic.go

@@ -0,0 +1,39 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetTosConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetTosConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetTosConfigLogic {
+	return &GetTosConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetTosConfigLogic) GetTosConfig() (resp *types.TosConfig, err error) {
+	resp = &types.TosConfig{}
+	// get tos config from db
+	configs, err := l.svcCtx.SystemModel.GetTosConfig(l.ctx)
+	if err != nil {
+		l.Errorw("[GetTosConfig] GetTosConfig error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetTosConfig error: %v", err.Error())
+	}
+	// reflect to response
+	tool.SystemConfigSliceReflectToStruct(configs, resp)
+	return
+}

internal/logic/admin/system/getVerifyCodeConfigLogic.go

@@ -0,0 +1,38 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetVerifyCodeConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get Verify Code Config
+func NewGetVerifyCodeConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetVerifyCodeConfigLogic {
+	return &GetVerifyCodeConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetVerifyCodeConfigLogic) GetVerifyCodeConfig() (resp *types.VerifyCodeConfig, err error) {
+	data, err := l.svcCtx.SystemModel.GetVerifyCodeConfig(l.ctx)
+	if err != nil {
+		l.Errorw("Get Verify Code Config Error: ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get Verify Code Config Error: %s", err.Error())
+	}
+	resp = &types.VerifyCodeConfig{}
+	tool.SystemConfigSliceReflectToStruct(data, resp)
+	return
+}

internal/logic/admin/system/getVerifyConfigLogic.go

@@ -0,0 +1,41 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/initialize"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetVerifyConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetVerifyConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetVerifyConfigLogic {
+	return &GetVerifyConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetVerifyConfigLogic) GetVerifyConfig() (*types.VerifyConfig, error) {
+	resp := &types.VerifyConfig{}
+	// get verify config from db
+	verifyConfigs, err := l.svcCtx.SystemModel.GetVerifyConfig(l.ctx)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get verify config failed: %v", err.Error())
+	}
+	// reflect to response
+	tool.SystemConfigSliceReflectToStruct(verifyConfigs, resp)
+	// update verify config to system
+	initialize.Verify(l.svcCtx)
+	return resp, nil
+}

internal/logic/admin/system/setNodeMultiplierLogic.go

@@ -0,0 +1,40 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type SetNodeMultiplierLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Set Node Multiplier
+func NewSetNodeMultiplierLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SetNodeMultiplierLogic {
+	return &SetNodeMultiplierLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *SetNodeMultiplierLogic) SetNodeMultiplier(req *types.SetNodeMultiplierRequest) error {
+	data, err := json.Marshal(req.Periods)
+	if err != nil {
+		l.Logger.Error("Marshal Node Multiplier Config Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Marshal Node Multiplier Config Error: %s", err.Error())
+	}
+	if err := l.svcCtx.SystemModel.UpdateNodeMultiplierConfig(l.ctx, string(data)); err != nil {
+		l.Logger.Error("Update Node Multiplier Config Error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Update Node Multiplier Config Error: %s", err.Error())
+	}
+	return nil
+}

internal/logic/admin/system/settingTelegramBotLogic.go

@@ -0,0 +1,30 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/initialize"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type SettingTelegramBotLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewSettingTelegramBotLogic setting telegram bot
+func NewSettingTelegramBotLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SettingTelegramBotLogic {
+	return &SettingTelegramBotLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *SettingTelegramBotLogic) SettingTelegramBot() error {
+	initialize.Telegram(l.svcCtx)
+	return nil
+}

internal/logic/admin/system/updateApplicationConfigLogic.go

@@ -0,0 +1,45 @@
+package system
+
+import (
+	"context"
+	"strings"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/application"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateApplicationConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// update application config
+func NewUpdateApplicationConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateApplicationConfigLogic {
+	return &UpdateApplicationConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateApplicationConfigLogic) UpdateApplicationConfig(req *types.ApplicationConfig) error {
+	err := l.svcCtx.ApplicationModel.UpdateConfig(l.ctx, &application.ApplicationConfig{
+		Id:                     1,
+		AppId:                  req.AppId,
+		EncryptionKey:          req.EncryptionKey,
+		EncryptionMethod:       req.EncryptionMethod,
+		Domains:                strings.Join(req.Domains, ";"),
+		StartupPicture:         req.StartupPicture,
+		StartupPictureSkipTime: req.StartupPictureSkipTime,
+	})
+	if err != nil {
+		l.Errorw("[UpdateApplicationConfig] Database Error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update app config error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/system/updateApplicationLogic.go

@@ -0,0 +1,149 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/application"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+)
+
+type UpdateApplicationLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateApplicationLogic {
+	return &UpdateApplicationLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateApplicationLogic) UpdateApplication(req *types.UpdateApplicationRequest) error {
+
+	// find application
+	app, err := l.svcCtx.ApplicationModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[UpdateApplication] find application error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find application error: %v", err.Error())
+	}
+	app.Name = req.Name
+	app.Icon = req.Icon
+	app.SubscribeType = req.SubscribeType
+	app.Description = req.Description
+
+	var ios []application.ApplicationVersion
+	if len(req.Platform.IOS) > 0 {
+		for _, ios_ := range req.Platform.IOS {
+			ios = append(ios, application.ApplicationVersion{
+				Url:           ios_.Url,
+				Version:       ios_.Version,
+				Platform:      "ios",
+				IsDefault:     ios_.IsDefault,
+				Description:   ios_.Description,
+				ApplicationId: app.Id,
+			})
+		}
+	}
+
+	var mac []application.ApplicationVersion
+	if len(req.Platform.MacOS) > 0 {
+		for _, mac_ := range req.Platform.MacOS {
+			mac = append(mac, application.ApplicationVersion{
+				Url:           mac_.Url,
+				Version:       mac_.Version,
+				Platform:      "macos",
+				IsDefault:     mac_.IsDefault,
+				Description:   mac_.Description,
+				ApplicationId: app.Id,
+			})
+		}
+	}
+
+	var linux []application.ApplicationVersion
+	if len(req.Platform.Linux) > 0 {
+		for _, linux_ := range req.Platform.Linux {
+			linux = append(linux, application.ApplicationVersion{
+				Url:           linux_.Url,
+				Version:       linux_.Version,
+				Platform:      "linux",
+				IsDefault:     linux_.IsDefault,
+				Description:   linux_.Description,
+				ApplicationId: app.Id,
+			})
+		}
+	}
+
+	var android []application.ApplicationVersion
+	if len(req.Platform.Android) > 0 {
+		for _, android_ := range req.Platform.Android {
+			android = append(android, application.ApplicationVersion{
+				Url:           android_.Url,
+				Version:       android_.Version,
+				Platform:      "android",
+				IsDefault:     android_.IsDefault,
+				Description:   android_.Description,
+				ApplicationId: app.Id,
+			})
+		}
+	}
+
+	var windows []application.ApplicationVersion
+	if len(req.Platform.Windows) > 0 {
+		for _, windows_ := range req.Platform.Windows {
+			windows = append(windows, application.ApplicationVersion{
+				Url:           windows_.Url,
+				Version:       windows_.Version,
+				Platform:      "windows",
+				IsDefault:     windows_.IsDefault,
+				Description:   windows_.Description,
+				ApplicationId: app.Id,
+			})
+		}
+	}
+
+	var harmony []application.ApplicationVersion
+	if len(req.Platform.Harmony) > 0 {
+		for _, harmony_ := range req.Platform.Harmony {
+			harmony = append(harmony, application.ApplicationVersion{
+				Url:           harmony_.Url,
+				Version:       harmony_.Version,
+				Platform:      "harmony",
+				IsDefault:     harmony_.IsDefault,
+				Description:   harmony_.Description,
+				ApplicationId: app.Id,
+			})
+		}
+	}
+	var applicationVersions []application.ApplicationVersion
+	applicationVersions = append(applicationVersions, ios...)
+	applicationVersions = append(applicationVersions, mac...)
+	applicationVersions = append(applicationVersions, linux...)
+	applicationVersions = append(applicationVersions, android...)
+	applicationVersions = append(applicationVersions, windows...)
+	applicationVersions = append(applicationVersions, harmony...)
+	app.ApplicationVersions = applicationVersions
+	err = l.svcCtx.ApplicationModel.Transaction(l.ctx, func(db *gorm.DB) error {
+
+		if err = db.Where("application_id = ?", app.Id).Delete(&application.ApplicationVersion{}).Error; err != nil {
+			return err
+		}
+		if err = db.Create(&applicationVersions).Error; err != nil {
+			return err
+		}
+		return db.Save(app).Error
+	})
+	if err != nil {
+		l.Errorw("[UpdateApplication] update application error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update application error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/system/updateApplicationVersionLogic.go

@@ -0,0 +1,45 @@
+package system
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type UpdateApplicationVersionLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update application version
+func NewUpdateApplicationVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateApplicationVersionLogic {
+	return &UpdateApplicationVersionLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateApplicationVersionLogic) UpdateApplicationVersion(req *types.UpdateApplicationVersionRequest) error {
+	// find application
+	app, err := l.svcCtx.ApplicationModel.FindOneVersion(l.ctx, req.Id)
+	if err != nil {
+		l.Errorw("[UpdateApplicationVersion] find application version error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find application error: %v", err.Error())
+	}
+	app.Url = req.Url
+	app.Version = req.Version
+	app.Description = req.Description
+	app.IsDefault = req.IsDefault
+	err = l.svcCtx.ApplicationModel.UpdateVersion(l.ctx, app)
+	if err != nil {
+		l.Errorw("[UpdateApplicationVersion] update application version error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update application version error: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/system/updateCurrencyConfigLogic.go

@@ -0,0 +1,62 @@
+package system
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/system"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type UpdateCurrencyConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update Currency Config
+func NewUpdateCurrencyConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateCurrencyConfigLogic {
+	return &UpdateCurrencyConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateCurrencyConfigLogic) UpdateCurrencyConfig(req *types.CurrencyConfig) error {
+	v := reflect.ValueOf(*req)
+	// Get the reflection type of the structure
+	t := v.Type()
+	err := l.svcCtx.SystemModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		var err error
+		for i := 0; i < v.NumField(); i++ {
+			// Get the field name
+			fieldName := t.Field(i).Name
+			// Get the field value to string
+			fieldValue := tool.ConvertValueToString(v.Field(i))
+			// Update the invite config
+			err = db.Model(&system.System{}).Where("`category` = 'currency' and `key` = ?", fieldName).Update("value", fieldValue).Error
+			if err != nil {
+				break
+			}
+		}
+		if err != nil {
+			return err
+		}
+		// clear cache
+		return l.svcCtx.Redis.Del(l.ctx, config.CurrencyConfigKey, config.GlobalConfigKey).Err()
+	})
+	if err != nil {
+		l.Errorw("[UpdateCurrencyConfig] update currency config error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update invite config error: %v", err)
+	}
+	return nil
+}

internal/logic/admin/system/updateInviteConfigLogic.go

@@ -0,0 +1,64 @@
+package system
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/perfect-panel/ppanel-server/initialize"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/system"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+)
+
+type UpdateInviteConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateInviteConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateInviteConfigLogic {
+	return &UpdateInviteConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateInviteConfigLogic) UpdateInviteConfig(req *types.InviteConfig) error {
+	v := reflect.ValueOf(*req)
+	// Get the reflection type of the structure
+	t := v.Type()
+	err := l.svcCtx.SystemModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		var err error
+		for i := 0; i < v.NumField(); i++ {
+			// Get the field name
+			fieldName := t.Field(i).Name
+			// Get the field value to string
+			fieldValue := tool.ConvertValueToString(v.Field(i))
+			// Update the invite config
+			err = db.Model(&system.System{}).Where("`category` = 'invite' and `key` = ?", fieldName).Update("value", fieldValue).Error
+			if err != nil {
+				break
+			}
+		}
+		if err != nil {
+			return err
+		}
+		// clear cache
+		return l.svcCtx.Redis.Del(l.ctx, config.InviteConfigKey, config.GlobalConfigKey).Err()
+	})
+	if err != nil {
+		l.Errorw("[UpdateInviteConfig] update invite config error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update invite config error: %v", err)
+	}
+	initialize.Invite(l.svcCtx)
+	return nil
+}

internal/logic/admin/system/updateNodeConfigLogic.go

@@ -0,0 +1,59 @@
+package system
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/perfect-panel/ppanel-server/initialize"
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/system"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+)
+
+type UpdateNodeConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateNodeConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateNodeConfigLogic {
+	return &UpdateNodeConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateNodeConfigLogic) UpdateNodeConfig(req *types.NodeConfig) error {
+	v := reflect.ValueOf(*req)
+	// Get the reflection type of the structure
+	t := v.Type()
+	err := l.svcCtx.SystemModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		var err error
+		for i := 0; i < v.NumField(); i++ {
+			// Get the field name
+			fieldName := t.Field(i).Name
+			// Get the field value to string
+			fieldValue := tool.ConvertValueToString(v.Field(i))
+			// Update the server config
+			err = db.Model(&system.System{}).Where("`category` = 'server' and `key` = ?", fieldName).Update("value", fieldValue).Error
+			if err != nil {
+				break
+			}
+		}
+		return l.svcCtx.Redis.Del(l.ctx, config.NodeConfigKey).Err()
+	})
+	if err != nil {
+		l.Errorw("[UpdateNodeConfig] update node config error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update server config error: %v", err)
+	}
+	initialize.Node(l.svcCtx)
+	return nil
+}

internal/logic/admin/system/updatePrivacyPolicyConfigLogic.go

@@ -0,0 +1,59 @@
+package system
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/system"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+)
+
+type UpdatePrivacyPolicyConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Update Privacy Policy Config
+func NewUpdatePrivacyPolicyConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdatePrivacyPolicyConfigLogic {
+	return &UpdatePrivacyPolicyConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdatePrivacyPolicyConfigLogic) UpdatePrivacyPolicyConfig(req *types.PrivacyPolicyConfig) error {
+	v := reflect.ValueOf(*req)
+	// Get the reflection type of the structure
+	t := v.Type()
+	err := l.svcCtx.SystemModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		var err error
+		for i := 0; i < v.NumField(); i++ {
+			// Get the field name
+			fieldName := t.Field(i).Name
+			// Get the field value to string
+			fieldValue := tool.ConvertValueToString(v.Field(i))
+			// Update the tos config
+			err = db.Model(&system.System{}).Where("`category` = 'tos' and `key` = ?", fieldName).Update("value", fieldValue).Error
+			if err != nil {
+				break
+			}
+		}
+		return l.svcCtx.Redis.Del(l.ctx, config.TosConfigKey).Err()
+	})
+	if err != nil {
+		l.Errorw("[UpdateTosConfigLogic] update tos config error: ", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update tos config error: %v", err)
+	}
+
+	return nil
+}

internal/logic/admin/system/updateRegisterConfigLogic.go

@@ -0,0 +1,65 @@
+package system
+
+import (
+	"context"
+
+	"reflect"
+
+	"github.com/perfect-panel/ppanel-server/initialize"
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/system"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+)
+
+type UpdateRegisterConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateRegisterConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateRegisterConfigLogic {
+	return &UpdateRegisterConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateRegisterConfigLogic) UpdateRegisterConfig(req *types.RegisterConfig) error {
+	v := reflect.ValueOf(*req)
+	// Get the reflection type of the structure
+	t := v.Type()
+	err := l.svcCtx.SystemModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		var err error
+		for i := 0; i < v.NumField(); i++ {
+			// Get the field name
+			fieldName := t.Field(i).Name
+			// Get the field value to string
+			fieldValue := tool.ConvertValueToString(v.Field(i))
+			// Update the site config
+			err = db.Model(&system.System{}).Where("`category` = 'register' and `key` = ?", fieldName).Update("value", fieldValue).Error
+			if err != nil {
+				break
+			}
+		}
+		if err != nil {
+			return err
+		}
+		return l.svcCtx.Redis.Del(l.ctx, config.RegisterConfigKey, config.GlobalConfigKey).Err()
+	})
+	if err != nil {
+		l.Errorw("[UpdateRegisterConfig] update register config error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update register config error: %v", err.Error())
+	}
+	// init system config
+	initialize.Register(l.svcCtx)
+	return nil
+}

internal/logic/admin/system/updateSiteConfigLogic.go

@@ -0,0 +1,61 @@
+package system
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/perfect-panel/ppanel-server/initialize"
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/system"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+type UpdateSiteConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateSiteConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateSiteConfigLogic {
+	return &UpdateSiteConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateSiteConfigLogic) UpdateSiteConfig(req *types.SiteConfig) error {
+	// Get the reflection value of the structure
+	v := reflect.ValueOf(*req)
+	// Get the reflection type of the structure
+	t := v.Type()
+	err := l.svcCtx.SystemModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		var err error
+		for i := 0; i < v.NumField(); i++ {
+			// Get the field name
+			fieldName := t.Field(i).Name
+			// Get the field value
+			fieldValue := v.Field(i)
+			err = db.Model(&system.System{}).Where("`category` = 'site' and `key` = ?", fieldName).Update("value", fieldValue.String()).Error
+			if err != nil {
+				break
+			}
+		}
+		if err != nil {
+			return err
+		}
+
+		return l.svcCtx.Redis.Del(l.ctx, config.SiteConfigKey, config.GlobalConfigKey).Err()
+	})
+	if err != nil {
+		l.Logger.Error("[UpdateSiteConfig] update site config error", logger.Field("error", err.Error()))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update site config error: %v", err.Error())
+	}
+	initialize.Site(l.svcCtx)
+	return nil
+}