Merge remote-tracking branch 'origin/master' into internal

internal/handler/admin/group/createNodeGroupHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Create node group
+func CreateNodeGroupHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.CreateNodeGroupRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewCreateNodeGroupLogic(c.Request.Context(), svcCtx)
+		err := l.CreateNodeGroup(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/group/deleteNodeGroupHandler.go

@@ -0,0 +1,29 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Delete node group
+func DeleteNodeGroupHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.DeleteNodeGroupRequest
+		if err := c.ShouldBind(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewDeleteNodeGroupLogic(c.Request.Context(), svcCtx)
+		err := l.DeleteNodeGroup(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/group/exportGroupResultHandler.go

@@ -0,0 +1,36 @@
+package group
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Export group result
+func ExportGroupResultHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.ExportGroupResultRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewExportGroupResultLogic(c.Request.Context(), svcCtx)
+		data, filename, err := l.ExportGroupResult(&req)
+		if err != nil {
+			result.HttpResult(c, nil, err)
+			return
+		}
+
+		// 设置响应头
+		c.Header("Content-Type", "text/csv")
+		c.Header("Content-Disposition", "attachment; filename="+filename)
+		c.Data(http.StatusOK, "text/csv", data)
+	}
+}

internal/handler/admin/group/getGroupConfigHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Get group config
+func GetGroupConfigHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetGroupConfigRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewGetGroupConfigLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetGroupConfig(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/group/getGroupHistoryDetailHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Get group history detail
+func GetGroupHistoryDetailHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetGroupHistoryDetailRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewGetGroupHistoryDetailLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetGroupHistoryDetail(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/group/getGroupHistoryHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Get group history
+func GetGroupHistoryHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetGroupHistoryRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewGetGroupHistoryLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetGroupHistory(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/group/getNodeGroupListHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Get node group list
+func GetNodeGroupListHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetNodeGroupListRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewGetNodeGroupListLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetNodeGroupList(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/group/getRecalculationStatusHandler.go

@@ -0,0 +1,18 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Get recalculation status
+func GetRecalculationStatusHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+
+		l := group.NewGetRecalculationStatusLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetRecalculationStatus()
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/group/getSubscribeGroupMappingHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Get subscribe group mapping
+func GetSubscribeGroupMappingHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetSubscribeGroupMappingRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewGetSubscribeGroupMappingLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetSubscribeGroupMapping(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/group/previewUserNodesHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Preview user nodes
+func PreviewUserNodesHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.PreviewUserNodesRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewPreviewUserNodesLogic(c.Request.Context(), svcCtx)
+		resp, err := l.PreviewUserNodes(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/admin/group/recalculateGroupHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Recalculate group
+func RecalculateGroupHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.RecalculateGroupRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewRecalculateGroupLogic(c.Request.Context(), svcCtx)
+		err := l.RecalculateGroup(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/group/resetGroupsHandler.go

@@ -0,0 +1,17 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Reset all groups
+func ResetGroupsHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		l := group.NewResetGroupsLogic(c.Request.Context(), svcCtx)
+		err := l.ResetGroups()
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/group/updateGroupConfigHandler.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Update group config
+func UpdateGroupConfigHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.UpdateGroupConfigRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewUpdateGroupConfigLogic(c.Request.Context(), svcCtx)
+		err := l.UpdateGroupConfig(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/admin/group/updateNodeGroupHandler.go

@@ -0,0 +1,33 @@
+package group
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/admin/group"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Update node group
+func UpdateNodeGroupHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.UpdateNodeGroupRequest
+		if err := c.ShouldBindUri(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		if err := c.ShouldBind(&req); err != nil {
+			result.ParamErrorResult(c, err)
+			return
+		}
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := group.NewUpdateNodeGroupLogic(c.Request.Context(), svcCtx)
+		err := l.UpdateNodeGroup(&req)
+		result.HttpResult(c, nil, err)
+	}
+}

internal/handler/auth/admin/adminGenerateCaptchaHandler.go

@@ -0,0 +1,18 @@
+package admin
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/auth/admin"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Generate captcha
+func AdminGenerateCaptchaHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+
+		l := admin.NewAdminGenerateCaptchaLogic(c.Request.Context(), svcCtx)
+		resp, err := l.AdminGenerateCaptcha()
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/auth/admin/adminLoginHandler.go

@@ -0,0 +1,30 @@
+package admin
+
+import (
+	"github.com/gin-gonic/gin"
+	adminLogic "github.com/perfect-panel/server/internal/logic/auth/admin"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Admin login
+func AdminLoginHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.UserLoginRequest
+		_ = c.ShouldBind(&req)
+		// get client ip
+		req.IP = c.ClientIP()
+		req.UserAgent = c.Request.UserAgent()
+
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := adminLogic.NewAdminLoginLogic(c.Request.Context(), svcCtx)
+		resp, err := l.AdminLogin(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/auth/admin/adminResetPasswordHandler.go

@@ -0,0 +1,29 @@
+package admin
+
+import (
+	"github.com/gin-gonic/gin"
+	adminLogic "github.com/perfect-panel/server/internal/logic/auth/admin"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Admin reset password
+func AdminResetPasswordHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.ResetPasswordRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+		// get client ip
+		req.IP = c.ClientIP()
+		req.UserAgent = c.Request.UserAgent()
+
+		l := adminLogic.NewAdminResetPasswordLogic(c.Request.Context(), svcCtx)
+		resp, err := l.AdminResetPassword(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/auth/generateCaptchaHandler.go

@@ -0,0 +1,18 @@
+package auth
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/auth"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Generate captcha
+func GenerateCaptchaHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+
+		l := auth.NewGenerateCaptchaLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GenerateCaptcha()
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/auth/resetPasswordHandler.go

@@ -1,16 +1,11 @@
 package auth
 
 import (
-	"time"
-
 	"github.com/gin-gonic/gin"
 	"github.com/perfect-panel/server/internal/logic/auth"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/result"
-	"github.com/perfect-panel/server/pkg/turnstile"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
 )
 
 // Reset password
@@ -25,17 +20,8 @@ func ResetPasswordHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
 		}
 		// get client ip
 		req.IP = c.ClientIP()
-		if svcCtx.Config.Verify.ResetPasswordVerify {
-			verifyTurns := turnstile.New(turnstile.Config{
-				Secret:  svcCtx.Config.Verify.TurnstileSecret,
-				Timeout: 3 * time.Second,
-			})
-			if verify, err := verifyTurns.Verify(c, req.CfToken, req.IP); err != nil || !verify {
-				err = errors.Wrapf(xerr.NewErrCode(xerr.TooManyRequests), "error: %v, verify: %v", err, verify)
-				result.HttpResult(c, nil, err)
-				return
-			}
-		}
+		req.UserAgent = c.Request.UserAgent()
+
 		l := auth.NewResetPasswordLogic(c.Request.Context(), svcCtx)
 		resp, err := l.ResetPassword(&req)
 		result.HttpResult(c, resp, err)

internal/handler/auth/telephoneLoginHandler.go

@@ -1,16 +1,11 @@
 package auth
 
 import (
-	"time"
-
 	"github.com/gin-gonic/gin"
 	"github.com/perfect-panel/server/internal/logic/auth"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/result"
-	"github.com/perfect-panel/server/pkg/turnstile"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
 )
 
 // User Telephone login

internal/handler/auth/telephoneResetPasswordHandler.go

@@ -1,14 +1,13 @@
 package auth
 
 import (
-	"time"
-
 	"github.com/gin-gonic/gin"
 	"github.com/perfect-panel/server/internal/logic/auth"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/captcha"
 	"github.com/perfect-panel/server/pkg/result"
-	"github.com/perfect-panel/server/pkg/turnstile"
+	"github.com/perfect-panel/server/pkg/tool"
 	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
@@ -25,17 +24,44 @@ func TelephoneResetPasswordHandler(svcCtx *svc.ServiceContext) func(c *gin.Conte
 		}
 		// get client ip
 		req.IP = c.ClientIP()
-		if svcCtx.Config.Verify.ResetPasswordVerify {
-			verifyTurns := turnstile.New(turnstile.Config{
-				Secret:  svcCtx.Config.Verify.TurnstileSecret,
-				Timeout: 3 * time.Second,
+
+		// Get verify config from database
+		verifyCfg, err := svcCtx.SystemModel.GetVerifyConfig(c.Request.Context())
+		if err != nil {
+			result.HttpResult(c, nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get verify config failed: %v", err))
+			return
+		}
+
+		var config struct {
+			CaptchaType                     string `json:"captcha_type"`
+			EnableUserResetPasswordCaptcha bool   `json:"enable_user_reset_password_captcha"`
+			TurnstileSecret                 string `json:"turnstile_secret"`
+		}
+		tool.SystemConfigSliceReflectToStruct(verifyCfg, &config)
+
+		// Verify captcha if enabled
+		if config.EnableUserResetPasswordCaptcha {
+			captchaService := captcha.NewService(captcha.Config{
+				Type:            captcha.CaptchaType(config.CaptchaType),
+				TurnstileSecret: config.TurnstileSecret,
+				RedisClient:     svcCtx.Redis,
 			})
-			if verify, err := verifyTurns.Verify(c.Request.Context(), req.CfToken, req.IP); err != nil || !verify {
-				err = errors.Wrapf(xerr.NewErrCode(xerr.TooManyRequests), "error: %v, verify: %v", err, verify)
-				result.HttpResult(c, nil, err)
+
+			var token, code string
+			if config.CaptchaType == "turnstile" {
+				token = req.CfToken
+			} else {
+				token = req.CaptchaId
+				code = req.CaptchaCode
+			}
+
+			verified, err := captchaService.Verify(c.Request.Context(), token, code, req.IP)
+			if err != nil || !verified {
+				result.HttpResult(c, nil, errors.Wrapf(xerr.NewErrCode(xerr.TooManyRequests), "captcha verification failed: %v", err))
 				return
 			}
 		}
+
 		l := auth.NewTelephoneResetPasswordLogic(c, svcCtx)
 		resp, err := l.TelephoneResetPassword(&req)
 		result.HttpResult(c, resp, err)

internal/handler/auth/telephoneUserRegisterHandler.go

@@ -1,16 +1,11 @@
 package auth
 
 import (
-	"time"
-
 	"github.com/gin-gonic/gin"
 	"github.com/perfect-panel/server/internal/logic/auth"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/result"
-	"github.com/perfect-panel/server/pkg/turnstile"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
 )
 
 // User Telephone register
@@ -26,17 +21,7 @@ func TelephoneUserRegisterHandler(svcCtx *svc.ServiceContext) func(c *gin.Contex
 		// get client ip
 		req.IP = c.ClientIP()
 		req.UserAgent = c.Request.UserAgent()
-		if svcCtx.Config.Verify.RegisterVerify {
-			verifyTurns := turnstile.New(turnstile.Config{
-				Secret:  svcCtx.Config.Verify.TurnstileSecret,
-				Timeout: 3 * time.Second,
-			})
-			if verify, err := verifyTurns.Verify(c, req.CfToken, req.IP); err != nil || !verify {
-				err = errors.Wrapf(xerr.NewErrCode(xerr.TooManyRequests), "error: %v, verify: %v", err, verify)
-				result.HttpResult(c, nil, err)
-				return
-			}
-		}
+
 		l := auth.NewTelephoneUserRegisterLogic(c.Request.Context(), svcCtx)
 		resp, err := l.TelephoneUserRegister(&req)
 		result.HttpResult(c, resp, err)

internal/handler/auth/userLoginHandler.go

@@ -1,16 +1,11 @@
 package auth
 
 import (
-	"time"
-
 	"github.com/gin-gonic/gin"
 	"github.com/perfect-panel/server/internal/logic/auth"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/result"
-	"github.com/perfect-panel/server/pkg/turnstile"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
 )
 
 // User login
@@ -21,17 +16,7 @@ func UserLoginHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
 		// get client ip
 		req.IP = c.ClientIP()
 		req.UserAgent = c.Request.UserAgent()
-		if svcCtx.Config.Verify.LoginVerify && !svcCtx.Config.Debug {
-			verifyTurns := turnstile.New(turnstile.Config{
-				Secret:  svcCtx.Config.Verify.TurnstileSecret,
-				Timeout: 3 * time.Second,
-			})
-			if verify, err := verifyTurns.Verify(c, req.CfToken, req.IP); err != nil || !verify {
-				err = errors.Wrapf(xerr.NewErrCode(xerr.TooManyRequests), "error: %v, verify: %v", err, verify)
-				result.HttpResult(c, nil, err)
-				return
-			}
-		}
+
 		validateErr := svcCtx.Validate(&req)
 		if validateErr != nil {
 			result.ParamErrorResult(c, validateErr)

internal/handler/auth/userRegisterHandler.go

@@ -1,16 +1,11 @@
 package auth
 
 import (
-	"time"
-
 	"github.com/gin-gonic/gin"
 	"github.com/perfect-panel/server/internal/logic/auth"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/result"
-	"github.com/perfect-panel/server/pkg/turnstile"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
 )
 
 // User register
@@ -21,16 +16,7 @@ func UserRegisterHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
 		// get client ip
 		req.IP = c.ClientIP()
 		req.UserAgent = c.Request.UserAgent()
-		if svcCtx.Config.Verify.RegisterVerify {
-			verifyTurns := turnstile.New(turnstile.Config{
-				Secret:  svcCtx.Config.Verify.TurnstileSecret,
-				Timeout: 3 * time.Second,
-			})
-			if verify, err := verifyTurns.Verify(c, req.CfToken, req.IP); err != nil || !verify {
-				result.HttpResult(c, nil, errors.Wrapf(xerr.NewErrCode(xerr.TooManyRequests), "verify error: %v", err.Error()))
-				return
-			}
-		}
+
 		validateErr := svcCtx.Validate(&req)
 		if validateErr != nil {
 			result.ParamErrorResult(c, validateErr)

internal/handler/public/user/getUserTrafficStatsHandler.go

@@ -0,0 +1,26 @@
+package user
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/perfect-panel/server/internal/logic/public/user"
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/result"
+)
+
+// Get User Traffic Statistics
+func GetUserTrafficStatsHandler(svcCtx *svc.ServiceContext) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		var req types.GetUserTrafficStatsRequest
+		_ = c.ShouldBind(&req)
+		validateErr := svcCtx.Validate(&req)
+		if validateErr != nil {
+			result.ParamErrorResult(c, validateErr)
+			return
+		}
+
+		l := user.NewGetUserTrafficStatsLogic(c.Request.Context(), svcCtx)
+		resp, err := l.GetUserTrafficStats(&req)
+		result.HttpResult(c, resp, err)
+	}
+}

internal/handler/routes.go

@@ -12,6 +12,7 @@ import (
 	adminConsole "github.com/perfect-panel/server/internal/handler/admin/console"
 	adminCoupon "github.com/perfect-panel/server/internal/handler/admin/coupon"
 	adminDocument "github.com/perfect-panel/server/internal/handler/admin/document"
+	adminGroup "github.com/perfect-panel/server/internal/handler/admin/group"
 	adminLog "github.com/perfect-panel/server/internal/handler/admin/log"
 	adminMarketing "github.com/perfect-panel/server/internal/handler/admin/marketing"
 	adminOrder "github.com/perfect-panel/server/internal/handler/admin/order"
@@ -24,6 +25,7 @@ import (
 	adminTool "github.com/perfect-panel/server/internal/handler/admin/tool"
 	adminUser "github.com/perfect-panel/server/internal/handler/admin/user"
 	auth "github.com/perfect-panel/server/internal/handler/auth"
+	authAdmin "github.com/perfect-panel/server/internal/handler/auth/admin"
 	authOauth "github.com/perfect-panel/server/internal/handler/auth/oauth"
 	common "github.com/perfect-panel/server/internal/handler/common"
 	publicAnnouncement "github.com/perfect-panel/server/internal/handler/public/announcement"
@@ -189,6 +191,53 @@ func RegisterHandlers(router *gin.Engine, serverCtx *svc.ServiceContext) {
 		adminDocumentGroupRouter.GET("/list", adminDocument.GetDocumentListHandler(serverCtx))
 	}
 
+	adminGroupGroupRouter := router.Group("/v1/admin/group")
+	adminGroupGroupRouter.Use(middleware.AuthMiddleware(serverCtx))
+
+	{
+		// Get group config
+		adminGroupGroupRouter.GET("/config", adminGroup.GetGroupConfigHandler(serverCtx))
+
+		// Update group config
+		adminGroupGroupRouter.PUT("/config", adminGroup.UpdateGroupConfigHandler(serverCtx))
+
+		// Export group result
+		adminGroupGroupRouter.GET("/export", adminGroup.ExportGroupResultHandler(serverCtx))
+
+		// Get group history
+		adminGroupGroupRouter.GET("/history", adminGroup.GetGroupHistoryHandler(serverCtx))
+
+		// Get group history detail
+		adminGroupGroupRouter.GET("/history/detail", adminGroup.GetGroupHistoryDetailHandler(serverCtx))
+
+		// Create node group
+		adminGroupGroupRouter.POST("/node", adminGroup.CreateNodeGroupHandler(serverCtx))
+
+		// Update node group
+		adminGroupGroupRouter.PUT("/node", adminGroup.UpdateNodeGroupHandler(serverCtx))
+
+		// Delete node group
+		adminGroupGroupRouter.DELETE("/node", adminGroup.DeleteNodeGroupHandler(serverCtx))
+
+		// Get node group list
+		adminGroupGroupRouter.GET("/node/list", adminGroup.GetNodeGroupListHandler(serverCtx))
+
+		// Preview user nodes
+		adminGroupGroupRouter.GET("/preview", adminGroup.PreviewUserNodesHandler(serverCtx))
+
+		// Recalculate group
+		adminGroupGroupRouter.POST("/recalculate", adminGroup.RecalculateGroupHandler(serverCtx))
+
+		// Get recalculation status
+		adminGroupGroupRouter.GET("/recalculation/status", adminGroup.GetRecalculationStatusHandler(serverCtx))
+
+		// Reset all groups
+		adminGroupGroupRouter.POST("/reset", adminGroup.ResetGroupsHandler(serverCtx))
+
+		// Get subscribe group mapping
+		adminGroupGroupRouter.GET("/subscribe/mapping", adminGroup.GetSubscribeGroupMappingHandler(serverCtx))
+	}
+
 	adminLogGroupRouter := router.Group("/v1/admin/log")
 	adminLogGroupRouter.Use(middleware.AuthMiddleware(serverCtx))
 
@@ -659,6 +708,9 @@ func RegisterHandlers(router *gin.Engine, serverCtx *svc.ServiceContext) {
 	authGroupRouter.Use(middleware.DeviceMiddleware(serverCtx))
 
 	{
+		// Generate captcha
+		authGroupRouter.POST("/captcha/generate", auth.GenerateCaptchaHandler(serverCtx))
+
 		// Check user is exist
 		authGroupRouter.GET("/check", auth.CheckUserHandler(serverCtx))
 
@@ -690,6 +742,20 @@ func RegisterHandlers(router *gin.Engine, serverCtx *svc.ServiceContext) {
 		authGroupRouter.POST("/reset/telephone", auth.TelephoneResetPasswordHandler(serverCtx))
 	}
 
+	authAdminGroupRouter := router.Group("/v1/auth/admin")
+	authAdminGroupRouter.Use(middleware.DeviceMiddleware(serverCtx))
+
+	{
+		// Generate captcha
+		authAdminGroupRouter.POST("/captcha/generate", authAdmin.AdminGenerateCaptchaHandler(serverCtx))
+
+		// Admin login
+		authAdminGroupRouter.POST("/login", authAdmin.AdminLoginHandler(serverCtx))
+
+		// Admin reset password
+		authAdminGroupRouter.POST("/reset", authAdmin.AdminResetPasswordHandler(serverCtx))
+	}
+
 	authOauthGroupRouter := router.Group("/v1/auth/oauth")
 
 	{
@@ -980,6 +1046,9 @@ func RegisterHandlers(router *gin.Engine, serverCtx *svc.ServiceContext) {
 		// Reset User Subscribe Token
 		publicUserGroupRouter.PUT("/subscribe_token", publicUser.ResetUserSubscribeTokenHandler(serverCtx))
 
+		// Get User Traffic Statistics
+		publicUserGroupRouter.GET("/traffic_stats", publicUser.GetUserTrafficStatsHandler(serverCtx))
+
 		// Unbind Device
 		publicUserGroupRouter.PUT("/unbind_device", publicUser.UnbindDeviceHandler(serverCtx))