Merge upstream/master into develop

Sync upstream changes from perfect-panel/server

  Includes updates from v1.0.1 to v1.2.5:
  - Currency configuration support
  - Subscribe improvements (short token, inventory check, etc.)
  - Node management enhancements
  - Database migrations
  - Bug fixes and optimizations

internal/logic/admin/server/createNodeLogic.go

@@ -31,6 +31,7 @@ func (l *CreateNodeLogic) CreateNode(req *types.CreateNodeRequest) error {
 	data := node.Node{
 		Name:     req.Name,
 		Tags:     tool.StringSliceToString(req.Tags),
+		Enabled:  req.Enabled,
 		Port:     req.Port,
 		Address:  req.Address,
 		ServerId: req.ServerId,

internal/logic/admin/server/hasMigrateSeverNodeLogic.go

@@ -1,52 +0,0 @@
-package server
-
-import (
-	"context"
-
-	"github.com/perfect-panel/server/internal/model/node"
-	"github.com/perfect-panel/server/internal/model/server"
-	"github.com/perfect-panel/server/internal/svc"
-	"github.com/perfect-panel/server/internal/types"
-	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
-)
-
-type HasMigrateSeverNodeLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-// NewHasMigrateSeverNodeLogic Check if there is any server or node to migrate
-func NewHasMigrateSeverNodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *HasMigrateSeverNodeLogic {
-	return &HasMigrateSeverNodeLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *HasMigrateSeverNodeLogic) HasMigrateSeverNode() (resp *types.HasMigrateSeverNodeResponse, err error) {
-	var oldCount, newCount int64
-	query := l.svcCtx.DB.WithContext(l.ctx)
-
-	err = query.Model(&server.Server{}).Count(&oldCount).Error
-	if err != nil {
-		l.Errorw("[HasMigrateSeverNode] Query Old Server Count Error: ", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "[HasMigrateSeverNode] Query Old Server Count Error")
-	}
-	err = query.Model(&node.Server{}).Count(&newCount).Error
-	if err != nil {
-		l.Errorw("[HasMigrateSeverNode] Query New Server Count Error: ", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "[HasMigrateSeverNode] Query New Server Count Error")
-	}
-	var shouldMigrate bool
-	if oldCount != 0 && newCount == 0 {
-		shouldMigrate = true
-	}
-
-	return &types.HasMigrateSeverNodeResponse{
-		HasMigrate: shouldMigrate,
-	}, nil
-}

internal/logic/admin/server/migrateServerNodeLogic.go

@@ -1,338 +0,0 @@
-package server
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"github.com/perfect-panel/server/internal/model/node"
-	"github.com/perfect-panel/server/internal/model/server"
-	"github.com/perfect-panel/server/internal/svc"
-	"github.com/perfect-panel/server/internal/types"
-	"github.com/perfect-panel/server/pkg/logger"
-)
-
-type MigrateServerNodeLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-// NewMigrateServerNodeLogic Migrate server and node data to new database
-func NewMigrateServerNodeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *MigrateServerNodeLogic {
-	return &MigrateServerNodeLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *MigrateServerNodeLogic) MigrateServerNode() (resp *types.MigrateServerNodeResponse, err error) {
-	tx := l.svcCtx.DB.WithContext(l.ctx).Begin()
-	var oldServers []*server.Server
-	var newServers []*node.Server
-	var newNodes []*node.Node
-
-	err = tx.Model(&server.Server{}).Find(&oldServers).Error
-	if err != nil {
-		l.Errorw("[MigrateServerNode] Query Old Server List Error: ", logger.Field("error", err.Error()))
-		return &types.MigrateServerNodeResponse{
-			Succee:  0,
-			Fail:    0,
-			Message: fmt.Sprintf("Query Old Server List Error: %s", err.Error()),
-		}, nil
-	}
-	for _, oldServer := range oldServers {
-		data, err := l.adapterServer(oldServer)
-		if err != nil {
-			l.Errorw("[MigrateServerNode] Adapter Server Error: ", logger.Field("error", err.Error()))
-			if resp == nil {
-				resp = &types.MigrateServerNodeResponse{}
-			}
-			resp.Fail++
-			if resp.Message == "" {
-				resp.Message = fmt.Sprintf("Adapter Server Error: %s", err.Error())
-			} else {
-				resp.Message = fmt.Sprintf("%s; Adapter Server Error: %s", resp.Message, err.Error())
-			}
-			continue
-		}
-		newServers = append(newServers, data)
-
-		newNode, err := l.adapterNode(oldServer)
-		if err != nil {
-			l.Errorw("[MigrateServerNode] Adapter Node Error: ", logger.Field("error", err.Error()))
-			if resp == nil {
-				resp = &types.MigrateServerNodeResponse{}
-			}
-			resp.Fail++
-			if resp.Message == "" {
-				resp.Message = fmt.Sprintf("Adapter Node Error: %s", err.Error())
-			} else {
-				resp.Message = fmt.Sprintf("%s; Adapter Node Error: %s", resp.Message, err.Error())
-			}
-			continue
-		}
-		for _, item := range newNode {
-			if item.Port == 0 {
-				protocols, _ := data.UnmarshalProtocols()
-				if len(protocols) > 0 {
-					item.Port = protocols[0].Port
-				}
-			}
-			newNodes = append(newNodes, item)
-		}
-	}
-
-	if len(newServers) > 0 {
-		err = tx.Model(&node.Server{}).CreateInBatches(newServers, 20).Error
-		if err != nil {
-			tx.Rollback()
-			l.Errorw("[MigrateServerNode] Insert New Server List Error: ", logger.Field("error", err.Error()))
-			return &types.MigrateServerNodeResponse{
-				Succee:  0,
-				Fail:    uint64(len(newServers)),
-				Message: fmt.Sprintf("Insert New Server List Error: %s", err.Error()),
-			}, nil
-		}
-	}
-	if len(newNodes) > 0 {
-		err = tx.Model(&node.Node{}).CreateInBatches(newNodes, 20).Error
-		if err != nil {
-			tx.Rollback()
-			l.Errorw("[MigrateServerNode] Insert New Node List Error: ", logger.Field("error", err.Error()))
-			return &types.MigrateServerNodeResponse{
-				Succee:  uint64(len(newServers)),
-				Fail:    uint64(len(newNodes)),
-				Message: fmt.Sprintf("Insert New Node List Error: %s", err.Error()),
-			}, nil
-		}
-	}
-	tx.Commit()
-
-	return &types.MigrateServerNodeResponse{
-		Succee:  uint64(len(newServers)),
-		Fail:    0,
-		Message: fmt.Sprintf("Migrate Success: %d servers and %d nodes", len(newServers), len(newNodes)),
-	}, nil
-}
-
-func (l *MigrateServerNodeLogic) adapterServer(info *server.Server) (*node.Server, error) {
-	result := &node.Server{
-		Id:      info.Id,
-		Name:    info.Name,
-		Country: info.Country,
-		City:    info.City,
-		//Ratio:     info.TrafficRatio,
-		Address:   info.ServerAddr,
-		Sort:      int(info.Sort),
-		Protocols: "",
-	}
-	var protocols []node.Protocol
-
-	switch info.Protocol {
-	case ShadowSocks:
-		var src server.Shadowsocks
-		err := json.Unmarshal([]byte(info.Config), &src)
-		if err != nil {
-			return nil, err
-		}
-		protocols = append(protocols, node.Protocol{
-			Type:      "shadowsocks",
-			Cipher:    src.Method,
-			Port:      uint16(src.Port),
-			ServerKey: src.ServerKey,
-			Ratio:     float64(info.TrafficRatio),
-		})
-	case Vmess:
-		var src server.Vmess
-		err := json.Unmarshal([]byte(info.Config), &src)
-		if err != nil {
-			return nil, err
-		}
-		protocol := node.Protocol{
-			Type:              "vmess",
-			Port:              uint16(src.Port),
-			Security:          src.Security,
-			SNI:               src.SecurityConfig.SNI,
-			AllowInsecure:     src.SecurityConfig.AllowInsecure,
-			Fingerprint:       src.SecurityConfig.Fingerprint,
-			RealityServerAddr: src.SecurityConfig.RealityServerAddr,
-			RealityServerPort: src.SecurityConfig.RealityServerPort,
-			RealityPrivateKey: src.SecurityConfig.RealityPrivateKey,
-			RealityPublicKey:  src.SecurityConfig.RealityPublicKey,
-			RealityShortId:    src.SecurityConfig.RealityShortId,
-			Transport:         src.Transport,
-			Host:              src.TransportConfig.Host,
-			Path:              src.TransportConfig.Path,
-			ServiceName:       src.TransportConfig.ServiceName,
-			Flow:              src.Flow,
-			Ratio:             float64(info.TrafficRatio),
-		}
-		protocols = append(protocols, protocol)
-		protocols = append(protocols, protocol)
-	case Vless:
-		var src server.Vless
-		err := json.Unmarshal([]byte(info.Config), &src)
-		if err != nil {
-			return nil, err
-		}
-		protocol := node.Protocol{
-			Type:              "vless",
-			Port:              uint16(src.Port),
-			Security:          src.Security,
-			SNI:               src.SecurityConfig.SNI,
-			AllowInsecure:     src.SecurityConfig.AllowInsecure,
-			Fingerprint:       src.SecurityConfig.Fingerprint,
-			RealityServerAddr: src.SecurityConfig.RealityServerAddr,
-			RealityServerPort: src.SecurityConfig.RealityServerPort,
-			RealityPrivateKey: src.SecurityConfig.RealityPrivateKey,
-			RealityPublicKey:  src.SecurityConfig.RealityPublicKey,
-			RealityShortId:    src.SecurityConfig.RealityShortId,
-			Transport:         src.Transport,
-			Host:              src.TransportConfig.Host,
-			Path:              src.TransportConfig.Path,
-			ServiceName:       src.TransportConfig.ServiceName,
-			Flow:              src.Flow,
-			Ratio:             float64(info.TrafficRatio),
-		}
-		protocols = append(protocols, protocol)
-	case Trojan:
-		var src server.Trojan
-		err := json.Unmarshal([]byte(info.Config), &src)
-		if err != nil {
-			return nil, err
-		}
-		protocol := node.Protocol{
-			Type:              "trojan",
-			Port:              uint16(src.Port),
-			Security:          src.Security,
-			SNI:               src.SecurityConfig.SNI,
-			AllowInsecure:     src.SecurityConfig.AllowInsecure,
-			Fingerprint:       src.SecurityConfig.Fingerprint,
-			RealityServerAddr: src.SecurityConfig.RealityServerAddr,
-			RealityServerPort: src.SecurityConfig.RealityServerPort,
-			RealityPrivateKey: src.SecurityConfig.RealityPrivateKey,
-			RealityPublicKey:  src.SecurityConfig.RealityPublicKey,
-			RealityShortId:    src.SecurityConfig.RealityShortId,
-			Transport:         src.Transport,
-			Host:              src.TransportConfig.Host,
-			Path:              src.TransportConfig.Path,
-			ServiceName:       src.TransportConfig.ServiceName,
-			Flow:              src.Flow,
-			Ratio:             float64(info.TrafficRatio),
-		}
-		protocols = append(protocols, protocol)
-	case Hysteria2:
-		var src server.Hysteria2
-		err := json.Unmarshal([]byte(info.Config), &src)
-		if err != nil {
-			return nil, err
-		}
-		protocol := node.Protocol{
-			Type:              "hysteria",
-			Port:              uint16(src.Port),
-			HopPorts:          src.HopPorts,
-			HopInterval:       src.HopInterval,
-			ObfsPassword:      src.ObfsPassword,
-			SNI:               src.SecurityConfig.SNI,
-			AllowInsecure:     src.SecurityConfig.AllowInsecure,
-			Fingerprint:       src.SecurityConfig.Fingerprint,
-			RealityServerAddr: src.SecurityConfig.RealityServerAddr,
-			RealityServerPort: src.SecurityConfig.RealityServerPort,
-			RealityPrivateKey: src.SecurityConfig.RealityPrivateKey,
-			RealityPublicKey:  src.SecurityConfig.RealityPublicKey,
-			RealityShortId:    src.SecurityConfig.RealityShortId,
-			Ratio:             float64(info.TrafficRatio),
-		}
-		protocols = append(protocols, protocol)
-	case Tuic:
-		var src server.Tuic
-		err := json.Unmarshal([]byte(info.Config), &src)
-		if err != nil {
-			return nil, err
-		}
-		protocol := node.Protocol{
-			Type:                 "tuic",
-			Port:                 uint16(src.Port),
-			DisableSNI:           src.DisableSNI,
-			ReduceRtt:            src.ReduceRtt,
-			UDPRelayMode:         src.UDPRelayMode,
-			CongestionController: src.CongestionController,
-			SNI:                  src.SecurityConfig.SNI,
-			AllowInsecure:        src.SecurityConfig.AllowInsecure,
-			Fingerprint:          src.SecurityConfig.Fingerprint,
-			RealityServerAddr:    src.SecurityConfig.RealityServerAddr,
-			RealityServerPort:    src.SecurityConfig.RealityServerPort,
-			RealityPrivateKey:    src.SecurityConfig.RealityPrivateKey,
-			RealityPublicKey:     src.SecurityConfig.RealityPublicKey,
-			RealityShortId:       src.SecurityConfig.RealityShortId,
-			Ratio:                float64(info.TrafficRatio),
-		}
-		protocols = append(protocols, protocol)
-	case AnyTLS:
-		var src server.AnyTLS
-		err := json.Unmarshal([]byte(info.Config), &src)
-		if err != nil {
-			return nil, err
-		}
-		protocol := node.Protocol{
-			Type:              "anytls",
-			Port:              uint16(src.Port),
-			SNI:               src.SecurityConfig.SNI,
-			AllowInsecure:     src.SecurityConfig.AllowInsecure,
-			Fingerprint:       src.SecurityConfig.Fingerprint,
-			RealityServerAddr: src.SecurityConfig.RealityServerAddr,
-			RealityServerPort: src.SecurityConfig.RealityServerPort,
-			RealityPrivateKey: src.SecurityConfig.RealityPrivateKey,
-			RealityPublicKey:  src.SecurityConfig.RealityPublicKey,
-			RealityShortId:    src.SecurityConfig.RealityShortId,
-			Ratio:             float64(info.TrafficRatio),
-		}
-		protocols = append(protocols, protocol)
-	}
-	if len(protocols) > 0 {
-		err := result.MarshalProtocols(protocols)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return result, nil
-}
-
-func (l *MigrateServerNodeLogic) adapterNode(info *server.Server) ([]*node.Node, error) {
-	var nodes []*node.Node
-	enable := true
-	switch info.RelayMode {
-	case server.RelayModeNone:
-		nodes = append(nodes, &node.Node{
-			Name:     info.Name,
-			Tags:     "",
-			Port:     0,
-			Address:  info.ServerAddr,
-			ServerId: info.Id,
-			Protocol: info.Protocol,
-			Enabled:  &enable,
-		})
-	default:
-		var relays []server.NodeRelay
-		err := json.Unmarshal([]byte(info.RelayNode), &relays)
-		if err != nil {
-			return nil, err
-		}
-		for _, relay := range relays {
-			nodes = append(nodes, &node.Node{
-				Name:     relay.Prefix + info.Name,
-				Tags:     "",
-				Port:     uint16(relay.Port),
-				Address:  relay.Host,
-				ServerId: info.Id,
-				Protocol: info.Protocol,
-				Enabled:  &enable,
-			})
-		}
-	}
-
-	return nodes, nil
-}

internal/logic/admin/subscribe/createSubscribeLogic.go

@@ -35,28 +35,29 @@ func (l *CreateSubscribeLogic) CreateSubscribe(req *types.CreateSubscribeRequest
 		discount = string(val)
 	}
 	sub := &subscribe.Subscribe{
-		Id:             0,
-		Name:           req.Name,
-		Language:       req.Language,
-		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,
-		Nodes:          tool.Int64SliceToString(req.Nodes),
-		NodeTags:       tool.StringSliceToString(req.NodeTags),
-		Show:           req.Show,
-		Sell:           req.Sell,
-		Sort:           0,
-		DeductionRatio: req.DeductionRatio,
-		AllowDeduction: req.AllowDeduction,
-		ResetCycle:     req.ResetCycle,
-		RenewalReset:   req.RenewalReset,
+		Id:                0,
+		Name:              req.Name,
+		Language:          req.Language,
+		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,
+		Nodes:             tool.Int64SliceToString(req.Nodes),
+		NodeTags:          tool.StringSliceToString(req.NodeTags),
+		Show:              req.Show,
+		Sell:              req.Sell,
+		Sort:              0,
+		DeductionRatio:    req.DeductionRatio,
+		AllowDeduction:    req.AllowDeduction,
+		ResetCycle:        req.ResetCycle,
+		RenewalReset:      req.RenewalReset,
+		ShowOriginalPrice: req.ShowOriginalPrice,
 	}
 	err := l.svcCtx.SubscribeModel.Insert(l.ctx, sub)
 	if err != nil {

internal/logic/admin/subscribe/updateSubscribeLogic.go

@@ -43,28 +43,29 @@ func (l *UpdateSubscribeLogic) UpdateSubscribe(req *types.UpdateSubscribeRequest
 		discount = string(val)
 	}
 	sub := &subscribe.Subscribe{
-		Id:             req.Id,
-		Name:           req.Name,
-		Language:       req.Language,
-		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,
-		Nodes:          tool.Int64SliceToString(req.Nodes),
-		NodeTags:       tool.StringSliceToString(req.NodeTags),
-		Show:           req.Show,
-		Sell:           req.Sell,
-		Sort:           req.Sort,
-		DeductionRatio: req.DeductionRatio,
-		AllowDeduction: req.AllowDeduction,
-		ResetCycle:     req.ResetCycle,
-		RenewalReset:   req.RenewalReset,
+		Id:                req.Id,
+		Name:              req.Name,
+		Language:          req.Language,
+		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,
+		Nodes:             tool.Int64SliceToString(req.Nodes),
+		NodeTags:          tool.StringSliceToString(req.NodeTags),
+		Show:              req.Show,
+		Sell:              req.Sell,
+		Sort:              req.Sort,
+		DeductionRatio:    req.DeductionRatio,
+		AllowDeduction:    req.AllowDeduction,
+		ResetCycle:        req.ResetCycle,
+		RenewalReset:      req.RenewalReset,
+		ShowOriginalPrice: req.ShowOriginalPrice,
 	}
 	err = l.svcCtx.SubscribeModel.Update(l.ctx, sub)
 	if err != nil {

internal/logic/admin/system/getNodeConfigLogic.go

@@ -3,6 +3,7 @@ package system
 import (
 	"context"
 	"encoding/json"
+
 	"github.com/perfect-panel/server/internal/config"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"

internal/logic/admin/system/setNodeMultiplierLogic.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 
+	"github.com/perfect-panel/server/initialize"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/logger"
@@ -32,9 +33,12 @@ func (l *SetNodeMultiplierLogic) SetNodeMultiplier(req *types.SetNodeMultiplierR
 		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 {
+	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())
 	}
+	// update Node Multiplier
+	initialize.Node(l.svcCtx)
+
 	return nil
 }

internal/logic/admin/user/getUserListLogic.go

@@ -30,6 +30,7 @@ func (l *GetUserListLogic) GetUserList(req *types.GetUserListRequest) (*types.Ge
 	list, total, err := l.svcCtx.UserModel.QueryPageList(l.ctx, req.Page, req.Size, &user.UserFilterParams{
 		UserId:          req.UserId,
 		Search:          req.Search,
+		Unscoped:        req.Unscoped,
 		SubscribeId:     req.SubscribeId,
 		UserSubscribeId: req.UserSubscribeId,
 		Order:           "DESC",

internal/logic/admin/user/getUserSubscribeLogic.go

@@ -41,6 +41,7 @@ func (l *GetUserSubscribeLogic) GetUserSubscribe(req *types.GetUserSubscribeList
 	for _, item := range data {
 		var sub types.UserSubscribe
 		tool.DeepCopy(&sub, item)
+		sub.Short, _ = tool.FixedUniqueString(item.Token, 8, "")
 		resp.List = append(resp.List, sub)
 	}
 	return

internal/logic/admin/user/resetUserSubscribeTokenLogic.go

@@ -0,0 +1,55 @@
+package user
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/uuidx"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type ResetUserSubscribeTokenLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewResetUserSubscribeTokenLogic Reset user subscribe token
+func NewResetUserSubscribeTokenLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ResetUserSubscribeTokenLogic {
+	return &ResetUserSubscribeTokenLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ResetUserSubscribeTokenLogic) ResetUserSubscribeToken(req *types.ResetUserSubscribeTokenRequest) error {
+	userSub, err := l.svcCtx.UserModel.FindOneSubscribe(l.ctx, req.UserSubscribeId)
+	if err != nil {
+		logger.Errorf("[ResetUserSubscribeToken] FindOneSubscribe error: %v", err.Error())
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindOneSubscribe error: %v", err.Error())
+	}
+	userSub.Token = uuidx.SubscribeToken(fmt.Sprintf("AdminUpdate:%d", time.Now().UnixMilli()))
+
+	err = l.svcCtx.UserModel.UpdateSubscribe(l.ctx, userSub)
+	if err != nil {
+		logger.Errorf("[ResetUserSubscribeToken] UpdateSubscribe error: %v", err.Error())
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "UpdateSubscribe error: %v", err.Error())
+	}
+	// Clear user subscribe cache
+	if err = l.svcCtx.UserModel.ClearSubscribeCache(l.ctx, userSub); err != nil {
+		l.Errorw("ClearSubscribeCache failed:", logger.Field("error", err.Error()), logger.Field("userSubscribeId", userSub.Id))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "ClearSubscribeCache failed: %v", err.Error())
+	}
+	// Clear subscribe cache
+	if err = l.svcCtx.SubscribeModel.ClearCache(l.ctx, userSub.SubscribeId); err != nil {
+		l.Errorw("failed to clear subscribe cache", logger.Field("error", err.Error()), logger.Field("subscribeId", userSub.SubscribeId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "failed to clear subscribe cache: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/user/resetUserSubscribeTrafficLogic.go

@@ -0,0 +1,53 @@
+package user
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type ResetUserSubscribeTrafficLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewResetUserSubscribeTrafficLogic Reset user subscribe traffic
+func NewResetUserSubscribeTrafficLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ResetUserSubscribeTrafficLogic {
+	return &ResetUserSubscribeTrafficLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ResetUserSubscribeTrafficLogic) ResetUserSubscribeTraffic(req *types.ResetUserSubscribeTrafficRequest) error {
+	userSub, err := l.svcCtx.UserModel.FindOneSubscribe(l.ctx, req.UserSubscribeId)
+	if err != nil {
+		l.Errorw("FindOneSubscribe error", logger.Field("error", err.Error()), logger.Field("userSubscribeId", req.UserSubscribeId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), " FindOneSubscribe error: %v", err.Error())
+	}
+	userSub.Download = 0
+	userSub.Upload = 0
+
+	err = l.svcCtx.UserModel.UpdateSubscribe(l.ctx, userSub)
+	if err != nil {
+		l.Errorw("UpdateSubscribe error", logger.Field("error", err.Error()), logger.Field("userSubscribeId", req.UserSubscribeId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), " UpdateSubscribe error: %v", err.Error())
+	}
+	// Clear user subscribe cache
+	if err = l.svcCtx.UserModel.ClearSubscribeCache(l.ctx, userSub); err != nil {
+		l.Errorw("ClearSubscribeCache failed:", logger.Field("error", err.Error()), logger.Field("userSubscribeId", userSub.Id))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "ClearSubscribeCache failed: %v", err.Error())
+	}
+	// Clear subscribe cache
+	if err = l.svcCtx.SubscribeModel.ClearCache(l.ctx, userSub.SubscribeId); err != nil {
+		l.Errorw("failed to clear subscribe cache", logger.Field("error", err.Error()), logger.Field("subscribeId", userSub.SubscribeId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "failed to clear subscribe cache: %v", err.Error())
+	}
+	return nil
+}

internal/logic/admin/user/toggleUserSubscribeStatusLogic.go

@@ -0,0 +1,63 @@
+package user
+
+import (
+	"context"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type ToggleUserSubscribeStatusLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewToggleUserSubscribeStatusLogic Stop user subscribe
+func NewToggleUserSubscribeStatusLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ToggleUserSubscribeStatusLogic {
+	return &ToggleUserSubscribeStatusLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ToggleUserSubscribeStatusLogic) ToggleUserSubscribeStatus(req *types.ToggleUserSubscribeStatusRequest) error {
+	userSub, err := l.svcCtx.UserModel.FindOneSubscribe(l.ctx, req.UserSubscribeId)
+	if err != nil {
+		l.Errorw("FindOneSubscribe error", logger.Field("error", err.Error()), logger.Field("userSubscribeId", req.UserSubscribeId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), " FindOneSubscribe error: %v", err.Error())
+	}
+
+	switch userSub.Status {
+	case 2: // active
+		userSub.Status = 5 // set status to stopped
+	case 5: // stopped
+		userSub.Status = 2 // set status to active
+	default:
+		l.Errorw("invalid user subscribe status", logger.Field("userSubscribeId", req.UserSubscribeId), logger.Field("status", userSub.Status))
+		return errors.Wrapf(xerr.NewErrCodeMsg(xerr.ERROR, "invalid subscribe status"), "invalid user subscribe status: %d", userSub.Status)
+	}
+
+	err = l.svcCtx.UserModel.UpdateSubscribe(l.ctx, userSub)
+	if err != nil {
+		l.Errorw("UpdateSubscribe error", logger.Field("error", err.Error()), logger.Field("userSubscribeId", req.UserSubscribeId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), " UpdateSubscribe error: %v", err.Error())
+	}
+
+	// Clear user subscribe cache
+	if err = l.svcCtx.UserModel.ClearSubscribeCache(l.ctx, userSub); err != nil {
+		l.Errorw("ClearSubscribeCache failed:", logger.Field("error", err.Error()), logger.Field("userSubscribeId", userSub.Id))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "ClearSubscribeCache failed: %v", err.Error())
+	}
+	// Clear subscribe cache
+	if err = l.svcCtx.SubscribeModel.ClearCache(l.ctx, userSub.SubscribeId); err != nil {
+		l.Errorw("failed to clear subscribe cache", logger.Field("error", err.Error()), logger.Field("subscribeId", userSub.SubscribeId))
+		return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "failed to clear subscribe cache: %v", err.Error())
+	}
+
+	return nil
+}