feat(service): 新增 GameShieldUserIp、TcpLimit、UdpLimit 和 WebLimit 相关功能- 新增 GameShieldUserIp相关的 handler、model、repository 和 service

- 新增 TcpLimit 相关的 handler、model、repository 和 service
- 新增 UdpLimit 相关的 handler、model、repository 和 service
- 新增 WebLimit 相关的 handler、model、repository 和 service

api/v1/tcpLimit.go

@@ -1,7 +1,7 @@
 package v1
 
 type TcpLimitRequest struct {
-	TcpWebLimitId int    `json:"waf_tcp_limit_id" form:"waf_tcp_limit_id"`
+	WafTcpLimitId int    `json:"waf_tcp_limit_id" form:"waf_tcp_limit_id"`
 	Tag           string `json:"tag" form:"tag" binding:"required"`
 	Uid           int    `json:"uid" form:"uid" binding:"required"`
 	ConnCount     int    `json:"conn_count" form:"conn_count" default:"0"`
@@ -12,5 +12,5 @@ type TcpLimitRequest struct {
 }
 
 type TcpLimitDeleteRequest struct {
-	TcpWebLimitId int `json:"waf_tcp_limit_id" form:"waf_tcp_limit_id"`
+	WafTcpLimitId int `json:"waf_tcp_limit_id" form:"waf_tcp_limit_id"`
 }

api/v1/udpLimit.go

@@ -1,5 +1,16 @@
 package v1
 
 type UdpLimitRequest struct {
-	Count int `json:"count"`
+	WafUdpLimitId     int    `json:"waf_udp_limit_id" form:"waf_udp_limit_id"`
+	Tag               string `json:"tag" form:"tag" binding:"required"`
+	Uid               int    `json:"uid" form:"uid" binding:"required"`
+	QosPacketCount    int    `form:"qos_packet_count" json:"qos_packet_count"`
+	QosPacketDuration string `form:"qos_packet_duration" json:"qos_packet_duration" default:"0s"`
+	MaxConnCount      int    `form:"max_conn_count" json:"max_conn_count"`
+	Bps               string `form:"bps" json:"bps" default:"0"`
+	MaxBytesMonth     int    `form:"max_bytes_month" json:"max_bytes_month" default:"0"`
+}
+
+type UdpLimitDeleteRequest struct {
+	WafUdpLimitId int `json:"waf_udp_limit_id" form:"waf_udp_limit_id"`
 }

cmd/server/wire/wire.go

@@ -32,6 +32,7 @@ var repositorySet = wire.NewSet(
 	repository.NewGameShieldUserIpRepository,
 	repository.NewWebLimitRepository,
 	repository.NewTcpLimitRepository,
+	repository.NewUdpLimitRepository,
 )
 
 var serviceSet = wire.NewSet(
@@ -50,6 +51,7 @@ var serviceSet = wire.NewSet(
 	service.NewGameShieldUserIpService,
 	service.NewWebLimitService,
 	service.NewTcpLimitService,
+	service.NewUdpLimitService,
 )
 
 var handlerSet = wire.NewSet(
@@ -63,6 +65,7 @@ var handlerSet = wire.NewSet(
 	handler.NewGameShieldUserIpHandler,
 	handler.NewWebLimitHandler,
 	handler.NewTcpLimitHandler,
+	handler.NewUdpLimitHandler,
 )
 
 var jobSet = wire.NewSet(

cmd/server/wire/wire_gen.go

@@ -60,7 +60,10 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	tcpLimitRepository := repository.NewTcpLimitRepository(repositoryRepository)
 	tcpLimitService := service.NewTcpLimitService(serviceService, tcpLimitRepository, requiredService, parserService, crawlerService)
 	tcpLimitHandler := handler.NewTcpLimitHandler(handlerHandler, tcpLimitService)
-	httpServer := server.NewHTTPServer(logger, viperViper, jwtJWT, userHandler, gameShieldHandler, webForwardingHandler, webLimitHandler, tcpforwardingHandler, udpForWardingHandler, tcpLimitHandler)
+	udpLimitRepository := repository.NewUdpLimitRepository(repositoryRepository)
+	udpLimitService := service.NewUdpLimitService(serviceService, udpLimitRepository, requiredService, crawlerService, parserService)
+	udpLimitHandler := handler.NewUdpLimitHandler(handlerHandler, udpLimitService)
+	httpServer := server.NewHTTPServer(logger, viperViper, jwtJWT, userHandler, gameShieldHandler, webForwardingHandler, webLimitHandler, tcpforwardingHandler, udpForWardingHandler, tcpLimitHandler, udpLimitHandler)
 	jobJob := job.NewJob(transaction, logger, sidSid)
 	userJob := job.NewUserJob(jobJob, userRepository)
 	jobServer := server.NewJobServer(logger, userJob)
@@ -71,11 +74,11 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 
 // wire.go:
 
-var repositorySet = wire.NewSet(repository.NewDB, repository.NewRepository, repository.NewTransaction, repository.NewUserRepository, repository.NewGameShieldRepository, repository.NewGameShieldPublicIpRepository, repository.NewWebForwardingRepository, repository.NewTcpforwardingRepository, repository.NewUdpForWardingRepository, repository.NewGameShieldUserIpRepository, repository.NewWebLimitRepository, repository.NewTcpLimitRepository)
+var repositorySet = wire.NewSet(repository.NewDB, repository.NewRepository, repository.NewTransaction, repository.NewUserRepository, repository.NewGameShieldRepository, repository.NewGameShieldPublicIpRepository, repository.NewWebForwardingRepository, repository.NewTcpforwardingRepository, repository.NewUdpForWardingRepository, repository.NewGameShieldUserIpRepository, repository.NewWebLimitRepository, repository.NewTcpLimitRepository, repository.NewUdpLimitRepository)
 
-var serviceSet = wire.NewSet(service.NewService, service.NewUserService, service.NewGameShieldService, service.NewCrawlerService, service.NewGameShieldPublicIpService, service.NewDuedateService, service.NewFormatterService, service.NewParserService, service.NewRequiredService, service.NewWebForwardingService, service.NewTcpforwardingService, service.NewUdpForWardingService, service.NewGameShieldUserIpService, service.NewWebLimitService, service.NewTcpLimitService)
+var serviceSet = wire.NewSet(service.NewService, service.NewUserService, service.NewGameShieldService, service.NewCrawlerService, service.NewGameShieldPublicIpService, service.NewDuedateService, service.NewFormatterService, service.NewParserService, service.NewRequiredService, service.NewWebForwardingService, service.NewTcpforwardingService, service.NewUdpForWardingService, service.NewGameShieldUserIpService, service.NewWebLimitService, service.NewTcpLimitService, service.NewUdpLimitService)
 
-var handlerSet = wire.NewSet(handler.NewHandler, handler.NewUserHandler, handler.NewGameShieldHandler, handler.NewGameShieldPublicIpHandler, handler.NewWebForwardingHandler, handler.NewTcpforwardingHandler, handler.NewUdpForWardingHandler, handler.NewGameShieldUserIpHandler, handler.NewWebLimitHandler, handler.NewTcpLimitHandler)
+var handlerSet = wire.NewSet(handler.NewHandler, handler.NewUserHandler, handler.NewGameShieldHandler, handler.NewGameShieldPublicIpHandler, handler.NewWebForwardingHandler, handler.NewTcpforwardingHandler, handler.NewUdpForWardingHandler, handler.NewGameShieldUserIpHandler, handler.NewWebLimitHandler, handler.NewTcpLimitHandler, handler.NewUdpLimitHandler)
 
 var jobSet = wire.NewSet(job.NewJob, job.NewUserJob)
 

internal/handler/tcplimit.go

@@ -69,7 +69,7 @@ func (h *TcpLimitHandler) DeleteTcpLimit(ctx *gin.Context) {
 		return
 	}
 	defaults.SetDefaults(req)
-	res, err := h.tcpLimitService.DeleteTcpLimit(ctx, req.TcpWebLimitId)
+	res, err := h.tcpLimitService.DeleteTcpLimit(ctx, req.WafTcpLimitId)
 	if err != nil {
 		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
 		return

internal/handler/udplimit.go

@@ -2,7 +2,10 @@ package handler
 
 import (
 	"github.com/gin-gonic/gin"
+	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
 	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/mcuadros/go-defaults"
+	"net/http"
 )
 
 type UdpLimitHandler struct {
@@ -23,3 +26,52 @@ func NewUdpLimitHandler(
 func (h *UdpLimitHandler) GetUdpLimit(ctx *gin.Context) {
 
 }
+
+func (h *UdpLimitHandler) AddUdpLimit(ctx *gin.Context) {
+	req := new(v1.UdpLimitRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.udpLimitService.AddUdpLimit(ctx, req)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+
+}
+
+func (h *UdpLimitHandler) EditUdpLimit(ctx *gin.Context) {
+	req := new(v1.UdpLimitRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.udpLimitService.UpdateUdpLimit(ctx, req)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+}
+
+func (h *UdpLimitHandler) DeleteUdpLimit(ctx *gin.Context) {
+	req := new(v1.UdpLimitDeleteRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.udpLimitService.DeleteUdpLimit(ctx, req.WafUdpLimitId)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+}

internal/server/http.go

@@ -25,7 +25,7 @@ func NewHTTPServer(
 	tcpForwardingHandler *handler.TcpforwardingHandler,
 	udpForwardingHandler *handler.UdpForWardingHandler,
 	tcpLimitHandler *handler.TcpLimitHandler,
-
+	udpLimitHandler *handler.UdpLimitHandler,
 ) *http.Server {
 	gin.SetMode(gin.DebugMode)
 	s := http.NewServer(
@@ -84,6 +84,9 @@ func NewHTTPServer(
 			noAuthRouter.POST("/tcpLimit/add", tcpLimitHandler.AddTcpLimit)
 			noAuthRouter.POST("/tcpLimit/edit", tcpLimitHandler.EditTcpLimit)
 			noAuthRouter.POST("/tcpLimit/delete", tcpLimitHandler.DeleteTcpLimit)
+			noAuthRouter.POST("/udpLimit/add", udpLimitHandler.AddUdpLimit)
+			noAuthRouter.POST("/udpLimit/edit", udpLimitHandler.EditUdpLimit)
+			noAuthRouter.POST("/udpLimit/delete", udpLimitHandler.DeleteUdpLimit)
 		}
 		// Non-strict permission routing group
 		noStrictAuthRouter := v1.Group("/").Use(middleware.NoStrictAuth(jwt, logger))

internal/service/tcplimit.go

@@ -76,14 +76,14 @@ func (s *tcpLimitService) AddTcpLimit(ctx context.Context, req *v1.TcpLimitReque
 func (s *tcpLimitService) UpdateTcpLimit(ctx context.Context, req *v1.TcpLimitRequest) (string, error) {
 	formData := map[string]interface{}{
 		"tag":              req.Tag,
-		"waf_tcp_limit_id": req.TcpWebLimitId,
+		"waf_tcp_limit_id": req.WafTcpLimitId,
 		"conn_count":       req.ConnCount,
 		"conn_duration":    req.ConnDuration,
 		"bps":              req.Bps,
 		"max_bytes_month":  req.MaxBytesMonth,
 		"expired_at":       "",
 	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp_limit/edit?&__goadmin_edit_pk="+strconv.Itoa(req.TcpWebLimitId), "admin/edit/waf_tcp_limit", formData)
+	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp_limit/edit?&__goadmin_edit_pk="+strconv.Itoa(req.WafTcpLimitId), "admin/edit/waf_tcp_limit", formData)
 	if err != nil {
 		return "", err
 	}

internal/service/udplimit.go

@@ -2,29 +2,108 @@ package service
 
 import (
 	"context"
+	"fmt"
+	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
 	"github.com/go-nunu/nunu-layout-advanced/internal/model"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"strconv"
 )
 
 type UdpLimitService interface {
 	GetUdpLimit(ctx context.Context, id int64) (*model.UdpLimit, error)
+	AddUdpLimit(ctx context.Context, req *v1.UdpLimitRequest) (string, error)
+	UpdateUdpLimit(ctx context.Context, req *v1.UdpLimitRequest) (string, error)
+	DeleteUdpLimit(ctx context.Context, UdpLimitId int) (string, error)
 }
 
 func NewUdpLimitService(
 	service *Service,
 	udpLimitRepository repository.UdpLimitRepository,
+	required RequiredService,
+	crawler CrawlerService,
+	parser ParserService,
 ) UdpLimitService {
 	return &udpLimitService{
 		Service:            service,
 		udpLimitRepository: udpLimitRepository,
+		required:           required,
+		crawler:            crawler,
+		parser:             parser,
 	}
 }
 
 type udpLimitService struct {
 	*Service
 	udpLimitRepository repository.UdpLimitRepository
+	required           RequiredService
+	crawler            CrawlerService
+	parser             ParserService
 }
 
 func (s *udpLimitService) GetUdpLimit(ctx context.Context, id int64) (*model.UdpLimit, error) {
 	return s.udpLimitRepository.GetUdpLimit(ctx, id)
 }
+
+func (s *udpLimitService) AddUdpLimit(ctx context.Context, req *v1.UdpLimitRequest) (string, error) {
+	formData := map[string]interface{}{
+		"tag":                 req.Tag,
+		"qos_packet_count":    req.QosPacketCount,
+		"qos_packet_duration": req.QosPacketDuration,
+		"max_conn_count":      req.MaxConnCount,
+		"bps":                 req.Bps,
+		"max_bytes_month":     req.MaxBytesMonth,
+		"expired_at":          "",
+	}
+	respBody, err := s.required.SendForm(ctx, "admin/info/waf_udp_limit/new", "admin/new/waf_udp_limit", formData)
+	if err != nil {
+		return "", err
+	}
+	// 解析响应内容中的 alert 消息
+	res, err := s.parser.ParseAlert(string(respBody))
+	if err != nil {
+		return "", err
+	}
+	if res != "" {
+		return "", fmt.Errorf(res)
+	}
+	udpLimitId, err := s.parser.GetRuleId(ctx, respBody)
+	if err != nil {
+		return "", err
+	}
+	fmt.Println("=================================================", udpLimitId)
+	return "", nil
+}
+
+func (s *udpLimitService) UpdateUdpLimit(ctx context.Context, req *v1.UdpLimitRequest) (string, error) {
+	formData := map[string]interface{}{
+		"tag":                 req.Tag,
+		"waf_udp_limit_id":    req.WafUdpLimitId,
+		"qos_packet_count":    req.QosPacketCount,
+		"qos_packet_duration": req.QosPacketDuration,
+		"max_conn_count":      req.MaxConnCount,
+		"bps":                 req.Bps,
+		"max_bytes_month":     req.MaxBytesMonth,
+		"expired_at":          "",
+	}
+	respBody, err := s.required.SendForm(ctx, "admin/info/waf_udp_limit/edit?&__goadmin_edit_pk="+strconv.Itoa(req.WafUdpLimitId), "admin/edit/waf_udp_limit", formData)
+	if err != nil {
+		return "", err
+	}
+	// 解析响应内容中的 alert 消息
+	res, err := s.parser.ParseAlert(string(respBody))
+	if err != nil {
+		return "", err
+	}
+	if res != "" {
+		return "", fmt.Errorf(res)
+	}
+	return "", nil
+}
+
+func (s *udpLimitService) DeleteUdpLimit(ctx context.Context, WafUdpLimitId int) (string, error) {
+	res, err := s.crawler.DeleteRule(ctx, WafUdpLimitId, "admin/delete/waf_udp_limit?page=1&__pageSize=10&__sort=waf_udp_limit_id&__sort_type=desc")
+	if err != nil {
+		return "", err
+	}
+	return res, nil
+}