refactor(gatewayip): 重构网关 IP 相关代码- 在 Gatewayip 模型中添加 NodeArea 字段

- 修改 GetGatewayipByHostId 方法，返回第一个 IP 地址
- 更新 GetGatewayipByHostIdAll 方法，返回所有 IP 地址
- 移除未使用的 TcpLimit、UdpLimit 和 WebLimit 相关代码
- 优化 WebForwarding 服务中的 IP 获取逻辑
- 更新 TaskWaf 中的网关 IP 相关操作

cmd/server/wire/wire.go

@@ -36,9 +36,6 @@ var repositorySet = wire.NewSet(
 	repository.NewTcpforwardingRepository,
 	repository.NewUdpForWardingRepository,
 	repository.NewGameShieldUserIpRepository,
-	repository.NewWebLimitRepository,
-	repository.NewTcpLimitRepository,
-	repository.NewUdpLimitRepository,
 	repository.NewGameShieldBackendRepository,
 	repository.NewGameShieldSdkIpRepository,
 	repository.NewHostRepository,
@@ -51,16 +48,17 @@ var repositorySet = wire.NewSet(
 	repository.NewCcRepository,
 	repository.NewExpiredRepository,
 	repository.NewLogRepository,
+	repository.NewGatewayipRepository,
 
 )
 
 var serviceSet = wire.NewSet(
 	service.NewService,
 	service.NewUserService,
-	service.NewLogService,
+
 	service.NewAdminService,
 	service.NewGameShieldService,
-	
+	service.NewAoDunService,
 	service.NewGameShieldPublicIpService,
 	service.NewDuedateService,
 	service.NewFormatterService,
@@ -71,9 +69,6 @@ var serviceSet = wire.NewSet(
 	service.NewTcpforwardingService,
 	service.NewUdpForWardingService,
 	service.NewGameShieldUserIpService,
-	service.NewWebLimitService,
-	service.NewTcpLimitService,
-	service.NewUdpLimitService,
 	service.NewGameShieldBackendService,
 	service.NewGameShieldSdkIpService,
 	service.NewHostService,
@@ -89,6 +84,7 @@ var serviceSet = wire.NewSet(
 	service.NewWebsocketService,
 	service.NewCcService,
 	service.NewLogService,
+	service.NewGatewayipService,
 )
 
 var handlerSet = wire.NewSet(
@@ -101,9 +97,6 @@ var handlerSet = wire.NewSet(
 	handler.NewTcpforwardingHandler,
 	handler.NewUdpForWardingHandler,
 	handler.NewGameShieldUserIpHandler,
-	handler.NewWebLimitHandler,
-	handler.NewTcpLimitHandler,
-	handler.NewUdpLimitHandler,
 	handler.NewGameShieldBackendHandler,
 	handler.NewGameShieldSdkIpHandler,
 	handler.NewHostHandler,
@@ -112,6 +105,7 @@ var handlerSet = wire.NewSet(
 	handler.NewGateWayGroupIpHandler,
 	handler.NewAllowAndDenyIpHandler,
 	handler.NewCcHandler,
+	handler.NewGatewayipHandler,
 )
 
 

cmd/server/wire/wire_gen.go

@@ -64,42 +64,34 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	globalLimitRepository := repository.NewGlobalLimitRepository(repositoryRepository)
 	tcpforwardingRepository := repository.NewTcpforwardingRepository(repositoryRepository)
 	udpForWardingRepository := repository.NewUdpForWardingRepository(repositoryRepository)
-	gatewayGroupRepository := repository.NewGatewayGroupRepository(repositoryRepository)
-	gateWayGroupIpRepository := repository.NewGateWayGroupIpRepository(repositoryRepository)
+	gatewayipRepository := repository.NewGatewayipRepository(repositoryRepository)
 	requestService := service.NewRequestService(serviceService)
 	cdnRepository := repository.NewCdnRepository(repositoryRepository)
 	cdnService := service.NewCdnService(serviceService, viperViper, requestService, cdnRepository)
-	wafFormatterService := service.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository, requiredService, parserService, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, rabbitMQ, hostService, gatewayGroupRepository, gateWayGroupIpRepository, cdnService)
+	wafFormatterService := service.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository, requiredService, parserService, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, rabbitMQ, hostService, gatewayipRepository, cdnService)
 	aoDunService := service.NewAoDunService(serviceService, viperViper)
 	proxyRepository := repository.NewProxyRepository(repositoryRepository)
 	proxyService := service.NewProxyService(serviceService, proxyRepository, cdnService)
 	sslCertService := service.NewSslCertService(serviceService, webForwardingRepository, cdnService)
 	websocketService := service.NewWebsocketService(serviceService, cdnService, webForwardingRepository)
-	webForwardingService := service.NewWebForwardingService(serviceService, requiredService, webForwardingRepository, crawlerService, parserService, wafFormatterService, aoDunService, rabbitMQ, gateWayGroupIpRepository, gatewayGroupRepository, globalLimitRepository, cdnService, proxyService, sslCertService, websocketService)
+	webForwardingService := service.NewWebForwardingService(serviceService, requiredService, webForwardingRepository, crawlerService, parserService, wafFormatterService, aoDunService, rabbitMQ, gatewayipRepository, globalLimitRepository, cdnService, proxyService, sslCertService, websocketService)
 	webForwardingHandler := handler.NewWebForwardingHandler(handlerHandler, webForwardingService)
-	webLimitRepository := repository.NewWebLimitRepository(repositoryRepository)
-	webLimitService := service.NewWebLimitService(serviceService, webLimitRepository, requiredService, parserService, crawlerService, hostService)
-	webLimitHandler := handler.NewWebLimitHandler(handlerHandler, webLimitService)
 	tcpforwardingService := service.NewTcpforwardingService(serviceService, tcpforwardingRepository, parserService, requiredService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
 	tcpforwardingHandler := handler.NewTcpforwardingHandler(handlerHandler, tcpforwardingService)
 	udpForWardingService := service.NewUdpForWardingService(serviceService, udpForWardingRepository, requiredService, parserService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
 	udpForWardingHandler := handler.NewUdpForWardingHandler(handlerHandler, udpForWardingService)
-	tcpLimitRepository := repository.NewTcpLimitRepository(repositoryRepository)
-	tcpLimitService := service.NewTcpLimitService(serviceService, tcpLimitRepository, requiredService, parserService, crawlerService, hostService)
-	tcpLimitHandler := handler.NewTcpLimitHandler(handlerHandler, tcpLimitService)
-	udpLimitRepository := repository.NewUdpLimitRepository(repositoryRepository)
-	udpLimitService := service.NewUdpLimitService(serviceService, udpLimitRepository, requiredService, crawlerService, parserService, hostService)
-	udpLimitHandler := handler.NewUdpLimitHandler(handlerHandler, udpLimitService)
-	gatewayGroupService := service.NewGatewayGroupService(serviceService, gatewayGroupRepository, requiredService, parserService, requestService)
 	allowAndDenyIpRepository := repository.NewAllowAndDenyIpRepository(repositoryRepository)
-	gateWayGroupIpService := service.NewGateWayGroupIpService(serviceService, gateWayGroupIpRepository, gatewayGroupRepository, requestService)
-	allowAndDenyIpService := service.NewAllowAndDenyIpService(serviceService, allowAndDenyIpRepository, gateWayGroupIpService, wafFormatterService)
-	globalLimitService := service.NewGlobalLimitService(serviceService, globalLimitRepository, duedateService, crawlerService, viperViper, requiredService, parserService, hostService, gatewayGroupService, hostRepository, gatewayGroupRepository, cdnService, cdnRepository, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, allowAndDenyIpService, allowAndDenyIpRepository, tcpforwardingService, udpForWardingService, webForwardingService)
+	allowAndDenyIpService := service.NewAllowAndDenyIpService(serviceService, allowAndDenyIpRepository, wafFormatterService, gatewayipRepository)
+	globalLimitService := service.NewGlobalLimitService(serviceService, globalLimitRepository, duedateService, crawlerService, viperViper, requiredService, parserService, hostService, hostRepository, cdnService, cdnRepository, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, allowAndDenyIpService, allowAndDenyIpRepository, tcpforwardingService, udpForWardingService, webForwardingService, gatewayipRepository)
 	globalLimitHandler := handler.NewGlobalLimitHandler(handlerHandler, globalLimitService)
 	adminRepository := repository.NewAdminRepository(repositoryRepository)
 	adminService := service.NewAdminService(serviceService, adminRepository)
 	adminHandler := handler.NewAdminHandler(handlerHandler, adminService)
+	gatewayGroupRepository := repository.NewGatewayGroupRepository(repositoryRepository)
+	gatewayGroupService := service.NewGatewayGroupService(serviceService, gatewayGroupRepository, requiredService, parserService, requestService)
 	gatewayGroupHandler := handler.NewGatewayGroupHandler(handlerHandler, gatewayGroupService)
+	gateWayGroupIpRepository := repository.NewGateWayGroupIpRepository(repositoryRepository)
+	gateWayGroupIpService := service.NewGateWayGroupIpService(serviceService, gateWayGroupIpRepository, gatewayGroupRepository, requestService)
 	gateWayGroupIpHandler := handler.NewGateWayGroupIpHandler(handlerHandler, gateWayGroupIpService)
 	allowAndDenyIpHandler := handler.NewAllowAndDenyIpHandler(handlerHandler, allowAndDenyIpService)
 	ccRepository := repository.NewCcRepository(repositoryRepository)
@@ -107,7 +99,7 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	ccHandler := handler.NewCcHandler(handlerHandler, ccService)
 	logRepository := repository.NewLogRepository(repositoryRepository)
 	logService := service.NewLogService(serviceService, logRepository)
-	httpServer := server.NewHTTPServer(logger, viperViper, jwtJWT, syncedEnforcer, limiterLimiter, handlerFunc, userHandler, gameShieldHandler, gameShieldBackendHandler, webForwardingHandler, webLimitHandler, tcpforwardingHandler, udpForWardingHandler, tcpLimitHandler, udpLimitHandler, globalLimitHandler, adminHandler, gatewayGroupHandler, gateWayGroupIpHandler, allowAndDenyIpHandler, ccHandler, logService)
+	httpServer := server.NewHTTPServer(logger, viperViper, jwtJWT, syncedEnforcer, limiterLimiter, handlerFunc, userHandler, gameShieldHandler, gameShieldBackendHandler, webForwardingHandler, tcpforwardingHandler, udpForWardingHandler, globalLimitHandler, adminHandler, gatewayGroupHandler, gateWayGroupIpHandler, allowAndDenyIpHandler, ccHandler, logService)
 	appApp := newApp(httpServer)
 	return appApp, func() {
 		cleanup()
@@ -116,11 +108,11 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 
 // wire.go:
 
-var repositorySet = wire.NewSet(repository.NewDB, repository.NewRedis, repository.NewCasbinEnforcer, repository.NewMongoClient, repository.NewMongoDB, repository.NewRabbitMQ, repository.NewRepository, repository.NewTransaction, repository.NewAdminRepository, repository.NewUserRepository, repository.NewGameShieldRepository, repository.NewGameShieldPublicIpRepository, repository.NewWebForwardingRepository, repository.NewTcpforwardingRepository, repository.NewUdpForWardingRepository, repository.NewGameShieldUserIpRepository, repository.NewWebLimitRepository, repository.NewTcpLimitRepository, repository.NewUdpLimitRepository, repository.NewGameShieldBackendRepository, repository.NewGameShieldSdkIpRepository, repository.NewHostRepository, repository.NewGlobalLimitRepository, repository.NewGatewayGroupRepository, repository.NewGateWayGroupIpRepository, repository.NewCdnRepository, repository.NewAllowAndDenyIpRepository, repository.NewProxyRepository, repository.NewCcRepository, repository.NewExpiredRepository, repository.NewLogRepository)
+var repositorySet = wire.NewSet(repository.NewDB, repository.NewRedis, repository.NewCasbinEnforcer, repository.NewMongoClient, repository.NewMongoDB, repository.NewRabbitMQ, repository.NewRepository, repository.NewTransaction, repository.NewAdminRepository, repository.NewUserRepository, repository.NewGameShieldRepository, repository.NewGameShieldPublicIpRepository, repository.NewWebForwardingRepository, repository.NewTcpforwardingRepository, repository.NewUdpForWardingRepository, repository.NewGameShieldUserIpRepository, repository.NewGameShieldBackendRepository, repository.NewGameShieldSdkIpRepository, repository.NewHostRepository, repository.NewGlobalLimitRepository, repository.NewGatewayGroupRepository, repository.NewGateWayGroupIpRepository, repository.NewCdnRepository, repository.NewAllowAndDenyIpRepository, repository.NewProxyRepository, repository.NewCcRepository, repository.NewExpiredRepository, repository.NewLogRepository, repository.NewGatewayipRepository)
 
-var serviceSet = wire.NewSet(service.NewService, service.NewAoDunService, service.NewUserService, service.NewAdminService, service.NewGameShieldService, service.NewGameShieldPublicIpService, service.NewDuedateService, service.NewFormatterService, service.NewParserService, service.NewRequiredService, service.NewCrawlerService, service.NewWebForwardingService, service.NewTcpforwardingService, service.NewUdpForWardingService, service.NewGameShieldUserIpService, service.NewWebLimitService, service.NewTcpLimitService, service.NewUdpLimitService, service.NewGameShieldBackendService, service.NewGameShieldSdkIpService, service.NewHostService, service.NewGlobalLimitService, service.NewGatewayGroupService, service.NewWafFormatterService, service.NewGateWayGroupIpService, service.NewRequestService, service.NewCdnService, service.NewAllowAndDenyIpService, service.NewProxyService, service.NewSslCertService, service.NewWebsocketService, service.NewCcService, service.NewLogService)
+var serviceSet = wire.NewSet(service.NewService, service.NewUserService, service.NewAdminService, service.NewGameShieldService, service.NewAoDunService, service.NewGameShieldPublicIpService, service.NewDuedateService, service.NewFormatterService, service.NewParserService, service.NewRequiredService, service.NewCrawlerService, service.NewWebForwardingService, service.NewTcpforwardingService, service.NewUdpForWardingService, service.NewGameShieldUserIpService, service.NewGameShieldBackendService, service.NewGameShieldSdkIpService, service.NewHostService, service.NewGlobalLimitService, service.NewGatewayGroupService, service.NewWafFormatterService, service.NewGateWayGroupIpService, service.NewRequestService, service.NewCdnService, service.NewAllowAndDenyIpService, service.NewProxyService, service.NewSslCertService, service.NewWebsocketService, service.NewCcService, service.NewLogService, service.NewGatewayipService)
 
-var handlerSet = wire.NewSet(handler.NewHandler, handler.NewUserHandler, handler.NewAdminHandler, handler.NewGameShieldHandler, handler.NewGameShieldPublicIpHandler, handler.NewWebForwardingHandler, handler.NewTcpforwardingHandler, handler.NewUdpForWardingHandler, handler.NewGameShieldUserIpHandler, handler.NewWebLimitHandler, handler.NewTcpLimitHandler, handler.NewUdpLimitHandler, handler.NewGameShieldBackendHandler, handler.NewGameShieldSdkIpHandler, handler.NewHostHandler, handler.NewGlobalLimitHandler, handler.NewGatewayGroupHandler, handler.NewGateWayGroupIpHandler, handler.NewAllowAndDenyIpHandler, handler.NewCcHandler)
+var handlerSet = wire.NewSet(handler.NewHandler, handler.NewUserHandler, handler.NewAdminHandler, handler.NewGameShieldHandler, handler.NewGameShieldPublicIpHandler, handler.NewWebForwardingHandler, handler.NewTcpforwardingHandler, handler.NewUdpForWardingHandler, handler.NewGameShieldUserIpHandler, handler.NewGameShieldBackendHandler, handler.NewGameShieldSdkIpHandler, handler.NewHostHandler, handler.NewGlobalLimitHandler, handler.NewGatewayGroupHandler, handler.NewGateWayGroupIpHandler, handler.NewAllowAndDenyIpHandler, handler.NewCcHandler, handler.NewGatewayipHandler)
 
 // 限流器依赖集
 var limiterSet = wire.NewSet(limiter.NewLimiter, middleware.NewRateLimitMiddleware)

cmd/task/wire/wire.go

@@ -36,16 +36,13 @@ var repositorySet = wire.NewSet(
 	repository.NewWebForwardingRepository,
 	repository.NewTcpforwardingRepository,
 	repository.NewUdpForWardingRepository,
-	repository.NewWebLimitRepository,
-	repository.NewTcpLimitRepository,
-	repository.NewUdpLimitRepository,
 	repository.NewGlobalLimitRepository,
 	repository.NewGatewayGroupRepository,
 	repository.NewGateWayGroupIpRepository,
 	repository.NewCdnRepository,
 	repository.NewExpiredRepository,
 	repository.NewProxyRepository,
-
+	repository.NewGatewayipRepository,
 )
 
 var taskSet = wire.NewSet(
@@ -88,6 +85,7 @@ var serviceSet = wire.NewSet(
 	service.NewProxyService,
 	service.NewSslCertService,
 	service.NewWebsocketService,
+	service.NewGatewayipService,
 )
 
 // build App

cmd/task/wire/wire_gen.go

@@ -63,8 +63,8 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	globalLimitRepository := repository.NewGlobalLimitRepository(repositoryRepository)
 	expiredRepository := repository.NewExpiredRepository(repositoryRepository)
 	gateWayGroupIpRepository := repository.NewGateWayGroupIpRepository(repositoryRepository)
-	gatewayGroupRepository := repository.NewGatewayGroupRepository(repositoryRepository)
-	wafFormatterService := service.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository, requiredService, parserService, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, rabbitMQ, hostService, gatewayGroupRepository, gateWayGroupIpRepository, cdnService)
+	gatewayipRepository := repository.NewGatewayipRepository(repositoryRepository)
+	wafFormatterService := service.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository, requiredService, parserService, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, rabbitMQ, hostService, gatewayipRepository, cdnService)
 	proxyRepository := repository.NewProxyRepository(repositoryRepository)
 	proxyService := service.NewProxyService(serviceService, proxyRepository, cdnService)
 	tcpforwardingService := service.NewTcpforwardingService(serviceService, tcpforwardingRepository, parserService, requiredService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
@@ -72,7 +72,7 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	aoDunService := service.NewAoDunService(serviceService, viperViper)
 	sslCertService := service.NewSslCertService(serviceService, webForwardingRepository, cdnService)
 	websocketService := service.NewWebsocketService(serviceService, cdnService, webForwardingRepository)
-	webForwardingService := service.NewWebForwardingService(serviceService, requiredService, webForwardingRepository, crawlerService, parserService, wafFormatterService, aoDunService, rabbitMQ, gateWayGroupIpRepository, gatewayGroupRepository, globalLimitRepository, cdnService, proxyService, sslCertService, websocketService)
+	webForwardingService := service.NewWebForwardingService(serviceService, requiredService, webForwardingRepository, crawlerService, parserService, wafFormatterService, aoDunService, rabbitMQ, gatewayipRepository, globalLimitRepository, cdnService, proxyService, sslCertService, websocketService)
 	wafTask := task.NewWafTask(webForwardingRepository, tcpforwardingRepository, udpForWardingRepository, cdnService, hostRepository, globalLimitRepository, expiredRepository, taskTask, gateWayGroupIpRepository, tcpforwardingService, udpForWardingService, webForwardingService)
 	taskServer := server.NewTaskServer(logger, userTask, gameShieldTask, wafTask)
 	jobJob := job.NewJob(transaction, logger, sidSid, rabbitMQ)
@@ -87,7 +87,7 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 
 // wire.go:
 
-var repositorySet = wire.NewSet(repository.NewDB, repository.NewRedis, repository.NewMongoClient, repository.NewCasbinEnforcer, repository.NewMongoDB, repository.NewRabbitMQ, repository.NewRepository, repository.NewTransaction, repository.NewUserRepository, repository.NewGameShieldRepository, repository.NewGameShieldBackendRepository, repository.NewGameShieldPublicIpRepository, repository.NewHostRepository, repository.NewGameShieldUserIpRepository, repository.NewGameShieldSdkIpRepository, repository.NewWebForwardingRepository, repository.NewTcpforwardingRepository, repository.NewUdpForWardingRepository, repository.NewWebLimitRepository, repository.NewTcpLimitRepository, repository.NewUdpLimitRepository, repository.NewGlobalLimitRepository, repository.NewGatewayGroupRepository, repository.NewGateWayGroupIpRepository, repository.NewCdnRepository, repository.NewExpiredRepository, repository.NewProxyRepository)
+var repositorySet = wire.NewSet(repository.NewDB, repository.NewRedis, repository.NewMongoClient, repository.NewCasbinEnforcer, repository.NewMongoDB, repository.NewRabbitMQ, repository.NewRepository, repository.NewTransaction, repository.NewUserRepository, repository.NewGameShieldRepository, repository.NewGameShieldBackendRepository, repository.NewGameShieldPublicIpRepository, repository.NewHostRepository, repository.NewGameShieldUserIpRepository, repository.NewGameShieldSdkIpRepository, repository.NewWebForwardingRepository, repository.NewTcpforwardingRepository, repository.NewUdpForWardingRepository, repository.NewGlobalLimitRepository, repository.NewGatewayGroupRepository, repository.NewGateWayGroupIpRepository, repository.NewCdnRepository, repository.NewExpiredRepository, repository.NewProxyRepository, repository.NewGatewayipRepository)
 
 var taskSet = wire.NewSet(task.NewTask, task.NewUserTask, task.NewGameShieldTask, task.NewWafTask)
 
@@ -95,7 +95,7 @@ var jobSet = wire.NewSet(job.NewJob, job.NewUserJob, job.NewWhitelistJob)
 
 var serverSet = wire.NewSet(server.NewTaskServer, server.NewJobServer)
 
-var serviceSet = wire.NewSet(service.NewService, service.NewAoDunService, service.NewGameShieldService, service.NewCrawlerService, service.NewGameShieldPublicIpService, service.NewDuedateService, service.NewFormatterService, service.NewParserService, service.NewRequiredService, service.NewHostService, service.NewGameShieldBackendService, service.NewGameShieldSdkIpService, service.NewGameShieldUserIpService, service.NewWafFormatterService, service.NewCdnService, service.NewRequestService, service.NewTcpforwardingService, service.NewUdpForWardingService, service.NewWebForwardingService, service.NewProxyService, service.NewSslCertService, service.NewWebsocketService)
+var serviceSet = wire.NewSet(service.NewService, service.NewAoDunService, service.NewGameShieldService, service.NewCrawlerService, service.NewGameShieldPublicIpService, service.NewDuedateService, service.NewFormatterService, service.NewParserService, service.NewRequiredService, service.NewHostService, service.NewGameShieldBackendService, service.NewGameShieldSdkIpService, service.NewGameShieldUserIpService, service.NewWafFormatterService, service.NewCdnService, service.NewRequestService, service.NewTcpforwardingService, service.NewUdpForWardingService, service.NewWebForwardingService, service.NewProxyService, service.NewSslCertService, service.NewWebsocketService, service.NewGatewayipService)
 
 // build App
 func newApp(task2 *server.TaskServer,

internal/handler/tcplimit.go

@@ -1,79 +0,0 @@
-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 TcpLimitHandler struct {
-	*Handler
-	tcpLimitService service.TcpLimitService
-}
-
-func NewTcpLimitHandler(
-	handler *Handler,
-	tcpLimitService service.TcpLimitService,
-) *TcpLimitHandler {
-	return &TcpLimitHandler{
-		Handler:         handler,
-		tcpLimitService: tcpLimitService,
-	}
-}
-
-func (h *TcpLimitHandler) GetTcpLimit(ctx *gin.Context) {
-
-}
-
-func (h *TcpLimitHandler) AddTcpLimit(ctx *gin.Context) {
-	req := new(v1.GeneralLimitRequireRequest)
-
-	if err := ctx.ShouldBind(req); err != nil {
-		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
-		return
-	}
-	defaults.SetDefaults(req)
-	res, err := h.tcpLimitService.AddTcpLimit(ctx, req)
-	if err != nil {
-		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
-		return
-	}
-	v1.HandleSuccess(ctx, res)
-
-}
-
-func (h *TcpLimitHandler) EditTcpLimit(ctx *gin.Context) {
-	req := new(v1.TcpLimitSendRequest)
-
-	if err := ctx.ShouldBind(req); err != nil {
-		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
-		return
-	}
-	defaults.SetDefaults(req)
-	err := h.tcpLimitService.UpdateTcpLimit(ctx, req)
-	if err != nil {
-		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
-		return
-	}
-	v1.HandleSuccess(ctx, nil)
-
-}
-
-func (h *TcpLimitHandler) DeleteTcpLimit(ctx *gin.Context) {
-	req := new(v1.TcpLimitDeleteRequest)
-
-	if err := ctx.ShouldBind(req); err != nil {
-		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
-		return
-	}
-	defaults.SetDefaults(req)
-	res, err := h.tcpLimitService.DeleteTcpLimit(ctx, req.WafTcpLimitId)
-	if err != nil {
-		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
-		return
-	}
-	v1.HandleSuccess(ctx, res)
-
-}

internal/handler/udplimit.go

@@ -1,77 +0,0 @@
-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 {
-	*Handler
-	udpLimitService service.UdpLimitService
-}
-
-func NewUdpLimitHandler(
-	handler *Handler,
-	udpLimitService service.UdpLimitService,
-) *UdpLimitHandler {
-	return &UdpLimitHandler{
-		Handler:         handler,
-		udpLimitService: udpLimitService,
-	}
-}
-
-func (h *UdpLimitHandler) GetUdpLimit(ctx *gin.Context) {
-
-}
-
-func (h *UdpLimitHandler) AddUdpLimit(ctx *gin.Context) {
-	req := new(v1.GeneralLimitRequireRequest)
-
-	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.UdpLimitSendRequest)
-
-	if err := ctx.ShouldBind(req); err != nil {
-		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
-		return
-	}
-	defaults.SetDefaults(req)
-	err := h.udpLimitService.UpdateUdpLimit(ctx, req)
-	if err != nil {
-		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
-		return
-	}
-	v1.HandleSuccess(ctx, nil)
-}
-
-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/handler/weblimit.go

@@ -1,78 +0,0 @@
-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 WebLimitHandler struct {
-	*Handler
-	webLimitService service.WebLimitService
-}
-
-func NewWebLimitHandler(
-	handler *Handler,
-	webLimitService service.WebLimitService,
-) *WebLimitHandler {
-	return &WebLimitHandler{
-		Handler:         handler,
-		webLimitService: webLimitService,
-	}
-}
-
-func (h *WebLimitHandler) GetWebLimit(ctx *gin.Context) {
-
-}
-
-func (h *WebLimitHandler) AddWebLimit(ctx *gin.Context) {
-	req := new(v1.GeneralLimitRequireRequest)
-
-	if err := ctx.ShouldBind(req); err != nil {
-		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
-		return
-	}
-	defaults.SetDefaults(req)
-	res, err := h.webLimitService.AddWebLimit(ctx, req)
-	if err != nil {
-		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
-		return
-	}
-	v1.HandleSuccess(ctx, res)
-
-}
-
-func (h *WebLimitHandler) EditWebLimit(ctx *gin.Context) {
-	req := new(v1.WebLimitSendRequest)
-
-	if err := ctx.ShouldBind(req); err != nil {
-		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
-		return
-	}
-	defaults.SetDefaults(req)
-	err := h.webLimitService.UpdateWebLimit(ctx, req)
-	if err != nil {
-		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
-		return
-	}
-	v1.HandleSuccess(ctx, nil)
-}
-
-func (h *WebLimitHandler) DeleteWebLimit(ctx *gin.Context) {
-	req := new(v1.WebLimitDeleteRequest)
-
-	if err := ctx.ShouldBind(req); err != nil {
-		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
-		return
-	}
-	defaults.SetDefaults(req)
-	res, err := h.webLimitService.DeleteWebLimit(ctx, req.WafWebLimitId)
-	if err != nil {
-		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
-		return
-	}
-	v1.HandleSuccess(ctx, res)
-
-}

internal/model/gatewayip.go

@@ -9,6 +9,7 @@ type Gatewayip struct {
 	HostId       int `gorm:"not null"`
 	Ip           string `gorm:"not null"`
 	Name         string `gorm:"null"`
+	NodeArea     string `gorm:"null"`
 	Operator     int `gorm:"not null;default:1"`
 	BanOverseas  int `gorm:"null;default:0"`
 	BanUdp       int `gorm:"null;default:0"`
@@ -18,5 +19,5 @@ type Gatewayip struct {
 }
 
 func (m *Gatewayip) TableName() string {
-    return "shd_waf_gateway_group"
+    return "shd_waf_gateway_ip"
 }

internal/model/tcplimit.go

@@ -1,11 +0,0 @@
-package model
-
-import "gorm.io/gorm"
-
-type TcpLimit struct {
-	gorm.Model
-}
-
-func (m *TcpLimit) TableName() string {
-	return "tcp_limit"
-}

internal/model/udplimit.go

@@ -1,11 +0,0 @@
-package model
-
-import "gorm.io/gorm"
-
-type UdpLimit struct {
-	gorm.Model
-}
-
-func (m *UdpLimit) TableName() string {
-	return "udp_limit"
-}

internal/model/weblimit.go

@@ -1,11 +0,0 @@
-package model
-
-import "gorm.io/gorm"
-
-type WebLimit struct {
-	gorm.Model
-}
-
-func (m *WebLimit) TableName() string {
-	return "web_limit"
-}

internal/repository/gatewayip.go

@@ -13,7 +13,7 @@ type GatewayipRepository interface {
 	AddGatewayip(ctx context.Context, req model.Gatewayip) error
 	EditGatewayip(ctx context.Context, req model.Gatewayip) error
 	DeleteGatewayip(ctx context.Context, req model.Gatewayip) error
-	GetGatewayipByHostId(ctx context.Context, hostId int64) (*model.Gatewayip, error)
+	GetGatewayipByHostIdFirst(ctx context.Context, hostId int64) (string, error)
 	GetGatewayipByHostIdAll(ctx context.Context, hostId int64) (*model.Gatewayip, error)
 	UpdateGatewayipByHostId(ctx context.Context, req model.Gatewayip) error
 	DeleteGatewayipByHostId(ctx context.Context, hostId int64) error
@@ -51,9 +51,9 @@ func (r *gatewayipRepository) DeleteGatewayip(ctx context.Context, req model.Gat
 	return r.DB(ctx).Model(&model.Gatewayip{}).Where("id = ?", req.Id).Delete(req).Error
 }
 
-func (r *gatewayipRepository) GetGatewayipByHostId(ctx context.Context, hostId int64) (*model.Gatewayip, error) {
-	var req model.Gatewayip
-	return &req, r.DB(ctx).Where("host_id = ?", hostId).First(&req).Error
+func (r *gatewayipRepository) GetGatewayipByHostIdFirst(ctx context.Context, hostId int64) (string, error) {
+	var req string
+	return req, r.DB(ctx).Where("host_id = ?", hostId).Pluck("ip", &req).Error
 }
 
 func (r *gatewayipRepository) GetGatewayipByHostIdAll(ctx context.Context, hostId int64) (*model.Gatewayip, error) {
@@ -87,6 +87,7 @@ func (r *gatewayipRepository) GetIpWhereHostIdNull(ctx context.Context,req v1.Gl
 			Where("operator = ?", req.Operator).
 			Where("ban_udp = ?", req.IsBanUdp).
 			Where("ban_overseas = ?", req.IsBanOverseas).
+			Where("node_area = ?",req.NodeArea).
 			Where("host_id IS NULL OR host_id = ?", 0).
 			Order("id ASC").
 			Limit(req.IpCount). // 优化点：直接用Limit限制查询数量

internal/repository/tcplimit.go

@@ -1,28 +0,0 @@
-package repository
-
-import (
-	"context"
-	"github.com/go-nunu/nunu-layout-advanced/internal/model"
-)
-
-type TcpLimitRepository interface {
-	GetTcpLimit(ctx context.Context, id int64) (*model.TcpLimit, error)
-}
-
-func NewTcpLimitRepository(
-	repository *Repository,
-) TcpLimitRepository {
-	return &tcpLimitRepository{
-		Repository: repository,
-	}
-}
-
-type tcpLimitRepository struct {
-	*Repository
-}
-
-func (r *tcpLimitRepository) GetTcpLimit(ctx context.Context, id int64) (*model.TcpLimit, error) {
-	var tcpLimit model.TcpLimit
-
-	return &tcpLimit, nil
-}

internal/repository/udplimit.go

@@ -1,28 +0,0 @@
-package repository
-
-import (
-	"context"
-	"github.com/go-nunu/nunu-layout-advanced/internal/model"
-)
-
-type UdpLimitRepository interface {
-	GetUdpLimit(ctx context.Context, id int64) (*model.UdpLimit, error)
-}
-
-func NewUdpLimitRepository(
-	repository *Repository,
-) UdpLimitRepository {
-	return &udpLimitRepository{
-		Repository: repository,
-	}
-}
-
-type udpLimitRepository struct {
-	*Repository
-}
-
-func (r *udpLimitRepository) GetUdpLimit(ctx context.Context, id int64) (*model.UdpLimit, error) {
-	var udpLimit model.UdpLimit
-
-	return &udpLimit, nil
-}

internal/repository/weblimit.go

@@ -1,28 +0,0 @@
-package repository
-
-import (
-	"context"
-	"github.com/go-nunu/nunu-layout-advanced/internal/model"
-)
-
-type WebLimitRepository interface {
-	GetWebLimit(ctx context.Context, id int64) (*model.WebLimit, error)
-}
-
-func NewWebLimitRepository(
-	repository *Repository,
-) WebLimitRepository {
-	return &webLimitRepository{
-		Repository: repository,
-	}
-}
-
-type webLimitRepository struct {
-	*Repository
-}
-
-func (r *webLimitRepository) GetWebLimit(ctx context.Context, id int64) (*model.WebLimit, error) {
-	var webLimit model.WebLimit
-
-	return &webLimit, nil
-}

internal/server/http.go

@@ -28,11 +28,8 @@ func NewHTTPServer(
 	gameShieldHandler *handler.GameShieldHandler,
 	gameShieldBackendHandler *handler.GameShieldBackendHandler,
 	webForwardingHandler *handler.WebForwardingHandler,
-	weblimitHandler *handler.WebLimitHandler,
 	tcpForwardingHandler *handler.TcpforwardingHandler,
 	udpForwardingHandler *handler.UdpForWardingHandler,
-	tcpLimitHandler *handler.TcpLimitHandler,
-	udpLimitHandler *handler.UdpLimitHandler,
 	globalLimitHandler *handler.GlobalLimitHandler,
 	adminHandler *handler.AdminHandler,
 	gatewayHandler *handler.GatewayGroupHandler,
@@ -105,9 +102,7 @@ func NewHTTPServer(
 			noAuthRouter.POST("/webForward/add", ipAllowlistMiddleware, webForwardingHandler.AddWebForwarding)
 			noAuthRouter.POST("/webForward/edit", ipAllowlistMiddleware, webForwardingHandler.EditWebForwarding)
 			noAuthRouter.POST("/webForward/delete", ipAllowlistMiddleware, webForwardingHandler.DeleteWebForwarding)
-			noAuthRouter.POST("/webLimit/add", ipAllowlistMiddleware, weblimitHandler.AddWebLimit)
-			noAuthRouter.POST("/webLimit/edit", ipAllowlistMiddleware, weblimitHandler.EditWebLimit)
-			noAuthRouter.POST("/webLimit/delete", ipAllowlistMiddleware, weblimitHandler.DeleteWebLimit)
+
 			noAuthRouter.POST("/tcpForward/add", ipAllowlistMiddleware, tcpForwardingHandler.AddTcpForwarding)
 			noAuthRouter.POST("/tcpForward/get", ipAllowlistMiddleware, tcpForwardingHandler.GetTcpforwarding)
 			noAuthRouter.POST("/tcpForward/getList", ipAllowlistMiddleware, tcpForwardingHandler.GetTcpForwardingList)
@@ -118,12 +113,7 @@ func NewHTTPServer(
 			noAuthRouter.POST("/udpForward/add", ipAllowlistMiddleware, udpForwardingHandler.AddUdpForWarding)
 			noAuthRouter.POST("/udpForward/edit", ipAllowlistMiddleware, udpForwardingHandler.EditUdpForWarding)
 			noAuthRouter.POST("/udpForward/delete", ipAllowlistMiddleware, udpForwardingHandler.DeleteUdpForWarding)
-			noAuthRouter.POST("/tcpLimit/add", ipAllowlistMiddleware, tcpLimitHandler.AddTcpLimit)
-			noAuthRouter.POST("/tcpLimit/edit", ipAllowlistMiddleware, tcpLimitHandler.EditTcpLimit)
-			noAuthRouter.POST("/tcpLimit/delete", ipAllowlistMiddleware, tcpLimitHandler.DeleteTcpLimit)
-			noAuthRouter.POST("/udpLimit/add", ipAllowlistMiddleware, udpLimitHandler.AddUdpLimit)
-			noAuthRouter.POST("/udpLimit/edit", ipAllowlistMiddleware, udpLimitHandler.EditUdpLimit)
-			noAuthRouter.POST("/udpLimit/delete", ipAllowlistMiddleware, udpLimitHandler.DeleteUdpLimit)
+
 			noAuthRouter.POST("/gameShieldBackend/add", ipAllowlistMiddleware, gameShieldBackendHandler.AddGameShieldBackend)
 			noAuthRouter.POST("/gameShieldBackend/edit", ipAllowlistMiddleware, gameShieldBackendHandler.EditGameShieldBackend)
 			noAuthRouter.POST("/gameShieldBackend/delete", ipAllowlistMiddleware, gameShieldBackendHandler.DeleteGameShieldBackend)

internal/service/tcpforwarding.go

@@ -32,7 +32,6 @@ func NewTcpforwardingService(
 	wafformatter WafFormatterService,
 	cdn CdnService,
 	proxy ProxyService,
-	gatewayIpRep repository.GatewayipRepository,
 ) TcpforwardingService {
 	return &tcpforwardingService{
 		Service:                 service,
@@ -45,7 +44,6 @@ func NewTcpforwardingService(
 		wafformatter:            wafformatter,
 		cdn:                     cdn,
 		proxy:                   proxy,
-		gatewayIpRep:            gatewayIpRep,
 	}
 }
 
@@ -60,7 +58,6 @@ type tcpforwardingService struct {
 	wafformatter WafFormatterService
 	cdn CdnService
 	proxy ProxyService
-	gatewayIpRep repository.GatewayipRepository
 }
 
 
@@ -138,14 +135,8 @@ func (s *tcpforwardingService) prepareWafData(ctx context.Context, req *v1.TcpFo
 	}
 
 
-	gatewayIps, err := s.gatewayIpRep.GetGatewayipOnlyIpByHostIdAll(ctx, int64(req.HostId))
-	if err != nil {
-		return RequireResponse{}, v1.WebsiteSend{}, err
-	}
-	require.GatewayIps = gatewayIps
-
 
-	if require.GatewayIps == nil || require.Uid == 0 {
+	if require.Uid == 0 {
 		return RequireResponse{}, v1.WebsiteSend{}, fmt.Errorf("请先配置实例")
 	}
 

internal/service/tcplimit.go

@@ -1,137 +0,0 @@
-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"
-	"github.com/spf13/cast"
-	"strconv"
-)
-
-type TcpLimitService interface {
-	GetTcpLimit(ctx context.Context, id int64) (*model.TcpLimit, error)
-	AddTcpLimit(ctx context.Context, req *v1.GeneralLimitRequireRequest) (int, error)
-	UpdateTcpLimit(ctx context.Context, req *v1.TcpLimitSendRequest) error
-	DeleteTcpLimit(ctx context.Context, TcpWebLimitId int) (string, error)
-}
-
-func NewTcpLimitService(
-	service *Service,
-	tcpLimitRepository repository.TcpLimitRepository,
-	required RequiredService,
-	parser ParserService,
-	crawler CrawlerService,
-	host HostService,
-) TcpLimitService {
-	return &tcpLimitService{
-		Service:            service,
-		tcpLimitRepository: tcpLimitRepository,
-		required:           required,
-		parser:             parser,
-		crawler:            crawler,
-		host:               host,
-	}
-}
-
-type tcpLimitService struct {
-	*Service
-	tcpLimitRepository repository.TcpLimitRepository
-	required           RequiredService
-	parser             ParserService
-	crawler            CrawlerService
-	host               HostService
-}
-
-func (s *tcpLimitService) GetTcpLimit(ctx context.Context, id int64) (*model.TcpLimit, error) {
-	return s.tcpLimitRepository.GetTcpLimit(ctx, id)
-}
-
-func (s *tcpLimitService) Required(ctx context.Context, req v1.GeneralLimitRequireRequest) (*v1.TcpLimitSendRequest, error) {
-	configCount, err := s.host.GetTcpLimitConfig(ctx, req.HostId)
-	if err != nil {
-		return nil, fmt.Errorf("获取配置限制失败: %w", err)
-	}
-	return &v1.TcpLimitSendRequest{
-		Tag:          req.Tag,
-		ConnCount:    configCount.ConnCount,
-		ConnDuration: configCount.ConnDuration,
-		MaxConnCount: configCount.MaxConnCount,
-		RuleId:       req.RuleId,
-	}, nil
-}
-func (s *tcpLimitService) AddTcpLimit(ctx context.Context, req *v1.GeneralLimitRequireRequest) (int, error) {
-	required, err := s.Required(ctx, *req)
-	if err != nil {
-		return 0, err
-	}
-	formData := map[string]interface{}{
-		"tag":                 req.Tag,
-		"conn_count":          required.ConnCount,
-		"conn_duration":       required.ConnDuration,
-		"max_conn_count":      required.MaxConnCount,
-		"waf_common_limit_id": required.RuleId,
-		"comment":             "",
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp_limit/new", "admin/new/waf_tcp_limit", formData)
-	if err != nil {
-		return 0, err
-	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
-	if err != nil {
-		return 0, err
-	}
-	if res != "" {
-		return 0, fmt.Errorf(res)
-	}
-	tcpLimitIdBase, err := s.parser.GetRuleIdByColumnName(ctx, respBody, req.Tag)
-	if err != nil {
-		return 0, err
-	}
-	tcpLimitId, err := cast.ToIntE(tcpLimitIdBase)
-	if err != nil {
-		return 0, err
-	}
-	if tcpLimitId == 0 {
-		res, err := s.parser.ParseAlert(string(respBody))
-		if err != nil {
-			return 0, err
-		}
-		return 0, fmt.Errorf(res)
-	}
-	return tcpLimitId, nil
-}
-
-func (s *tcpLimitService) UpdateTcpLimit(ctx context.Context, req *v1.TcpLimitSendRequest) error {
-	formData := map[string]interface{}{
-		"tag":                 req.Tag,
-		"conn_count":          req.ConnCount,
-		"conn_duration":       req.ConnDuration,
-		"max_conn_count":      req.MaxConnCount,
-		"waf_common_limit_id": req.RuleId,
-		"comment":             "",
-	}
-	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
-	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
-	if err != nil {
-		return err
-	}
-	if res != "" {
-		return fmt.Errorf(res)
-	}
-	return nil
-}
-
-func (s *tcpLimitService) DeleteTcpLimit(ctx context.Context, TcpWebLimitId int) (string, error) {
-	res, err := s.crawler.DeleteRule(ctx, TcpWebLimitId, "admin/delete/waf_tcp_limit?page=1&__pageSize=10&__sort=waf_tcp_limit_id&__sort_type=desc")
-	if err != nil {
-		return "", err
-	}
-	return res, nil
-}

internal/service/udpforwarding.go

@@ -131,7 +131,7 @@ func (s *udpForWardingService) prepareWafData(ctx context.Context, req *v1.UdpFo
 	if err != nil {
 		return RequireResponse{}, v1.WebsiteSend{}, err
 	}
-	if require.GatewayGroupId == 0 || require.Uid == 0 {
+	if require.Uid == 0 {
 		return RequireResponse{}, v1.WebsiteSend{}, fmt.Errorf("请先配置实例")
 	}
 	var jsonData v1.TypeJSON

internal/service/udplimit.go

@@ -1,138 +0,0 @@
-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"
-	"github.com/spf13/cast"
-	"strconv"
-)
-
-type UdpLimitService interface {
-	GetUdpLimit(ctx context.Context, id int64) (*model.UdpLimit, error)
-	AddUdpLimit(ctx context.Context, req *v1.GeneralLimitRequireRequest) (int, error)
-	UpdateUdpLimit(ctx context.Context, req *v1.UdpLimitSendRequest) error
-	DeleteUdpLimit(ctx context.Context, UdpLimitId int) (string, error)
-}
-
-func NewUdpLimitService(
-	service *Service,
-	udpLimitRepository repository.UdpLimitRepository,
-	required RequiredService,
-	crawler CrawlerService,
-	parser ParserService,
-	host HostService,
-) UdpLimitService {
-	return &udpLimitService{
-		Service:            service,
-		udpLimitRepository: udpLimitRepository,
-		required:           required,
-		crawler:            crawler,
-		parser:             parser,
-		host:               host,
-	}
-}
-
-type udpLimitService struct {
-	*Service
-	udpLimitRepository repository.UdpLimitRepository
-	required           RequiredService
-	crawler            CrawlerService
-	parser             ParserService
-	host               HostService
-}
-
-func (s *udpLimitService) Required(ctx context.Context, req v1.GeneralLimitRequireRequest) (v1.UdpLimitSendRequest, error) {
-	config, err := s.host.GetUdpLimitConfig(ctx, req.HostId)
-	if err != nil {
-		return v1.UdpLimitSendRequest{}, fmt.Errorf("获取配置限制失败: %w", err)
-	}
-	return v1.UdpLimitSendRequest{
-		Tag:               req.Tag,
-		QosPacketCount:    config.QosPacketCount,
-		QosPacketDuration: config.QosPacketDuration,
-		MaxConnCount:      config.MaxConnCount,
-		RuleId:            req.RuleId,
-	}, nil
-}
-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.GeneralLimitRequireRequest) (int, error) {
-	required, err := s.Required(ctx, *req)
-	if err != nil {
-		return 0, err
-	}
-	formData := map[string]interface{}{
-		"tag":                 req.Tag,
-		"qos_packet_count":    required.QosPacketCount,
-		"qos_packet_duration": required.QosPacketDuration,
-		"max_conn_count":      required.MaxConnCount,
-		"waf_common_limit_id": required.RuleId,
-		"comment":             "",
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_udp_limit/new", "admin/new/waf_udp_limit", formData)
-	if err != nil {
-		return 0, err
-	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
-	if err != nil {
-		return 0, err
-	}
-	if res != "" {
-		return 0, fmt.Errorf(res)
-	}
-	udpLimitIdBase, err := s.parser.GetRuleIdByColumnName(ctx, respBody, req.Tag)
-	if err != nil {
-		return 0, err
-	}
-	udpLimitId, err := cast.ToIntE(udpLimitIdBase)
-	if err != nil {
-		return 0, err
-	}
-	if udpLimitId == 0 {
-		res, err := s.parser.ParseAlert(string(respBody))
-		if err != nil {
-			return 0, err
-		}
-		return 0, fmt.Errorf(res)
-	}
-	return udpLimitId, nil
-}
-
-func (s *udpLimitService) UpdateUdpLimit(ctx context.Context, req *v1.UdpLimitSendRequest) 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,
-		"waf_common_limit_id": req.RuleId,
-		"comment":             "",
-	}
-	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
-}

internal/service/wafformatter.go

@@ -52,8 +52,7 @@ func NewWafFormatterService(
 	webForwardingRep repository.WebForwardingRepository,
 	mq *rabbitmq.RabbitMQ,
 	host HostService,
-	gatewayGroupRep repository.GatewayGroupRepository,
-	gatewayGroupIpRep repository.GateWayGroupIpRepository,
+	gatewayIpRep repository.GatewayipRepository,
 	cdn CdnService,
 ) WafFormatterService {
 	return &wafFormatterService{
@@ -67,8 +66,7 @@ func NewWafFormatterService(
 		webForwardingRep:  webForwardingRep,
 		host:              host,
 		mq:                mq,
-		gatewayGroupRep:   gatewayGroupRep,
-		gatewayGroupIpRep: gatewayGroupIpRep,
+		gatewayIpRep: gatewayIpRep,
 		cdn:               cdn,
 	}
 }
@@ -84,8 +82,7 @@ type wafFormatterService struct {
 	webForwardingRep  repository.WebForwardingRepository
 	host              HostService
 	mq                *rabbitmq.RabbitMQ
-	gatewayGroupRep   repository.GatewayGroupRepository
-	gatewayGroupIpRep repository.GateWayGroupIpRepository
+	gatewayIpRep      repository.GatewayipRepository
 	cdn               CdnService
 }
 
@@ -111,10 +108,14 @@ func (s *wafFormatterService) Require(ctx context.Context, req v1.GlobalRequire)
 		return RequireResponse{}, err
 	}
 	res.Tag = strconv.Itoa(req.Uid) + "_" + strconv.Itoa(req.HostId) + "_" + domain + "_" + req.Comment
-	res.GatewayIps, err = s.gatewayGroupIpRep.GetGateWayGroupAllIpByGatewayGroupId(ctx, res.GatewayGroupId)
+
+	res.GatewayIps, err = s.gatewayIpRep.GetGatewayipOnlyIpByHostIdAll(ctx, int64(req.HostId))
 	if err != nil {
 		return RequireResponse{}, err
 	}
+	if res.GatewayIps == nil {
+		return RequireResponse{}, fmt.Errorf("请先配置实例")
+	}
 
 	// 检查是否过期
 	expired, err := s.host.CheckExpired(ctx, int64(req.Uid), int64(req.HostId))

internal/service/webforwarding.go

@@ -31,8 +31,7 @@ func NewWebForwardingService(
 	wafformatter WafFormatterService,
 	aoDun AoDunService,
 	mq *rabbitmq.RabbitMQ,
-	gatewayGroupIpRep repository.GateWayGroupIpRepository,
-	gatewayGroupRep repository.GatewayGroupRepository,
+	gatewayIpRep repository.GatewayipRepository,
 	globalLimitRep repository.GlobalLimitRepository,
 	cdn CdnService,
 	proxy ProxyService,
@@ -48,8 +47,7 @@ func NewWebForwardingService(
 		wafformatter:            wafformatter,
 		aoDun:                   aoDun,
 		mq:                      mq,
-		gatewayGroupIpRep:       gatewayGroupIpRep,
-		gatewayGroupRep:         gatewayGroupRep,
+		gatewayIpRep:            gatewayIpRep,
 		cdn:                     cdn,
 		globalLimitRep:          globalLimitRep,
 		proxy:                   proxy,
@@ -74,8 +72,7 @@ type webForwardingService struct {
 	wafformatter            WafFormatterService
 	aoDun                   AoDunService
 	mq                      *rabbitmq.RabbitMQ
-	gatewayGroupIpRep       repository.GateWayGroupIpRepository
-	gatewayGroupRep         repository.GatewayGroupRepository
+	gatewayIpRep            repository.GatewayipRepository
 	cdn                     CdnService
 	globalLimitRep          repository.GlobalLimitRepository
 	proxy                   ProxyService
@@ -210,7 +207,7 @@ func (s *webForwardingService) prepareWafData(ctx context.Context, req *v1.WebFo
 	if err != nil {
 		return RequireResponse{}, v1.Website{}, fmt.Errorf("获取WAF前置配置失败: %w", err)
 	}
-	if require.GatewayGroupId == 0 || require.Uid == 0 {
+	if require.Uid == 0 {
 		return RequireResponse{}, v1.Website{}, fmt.Errorf("请先配置实例")
 	}
 
@@ -510,7 +507,7 @@ func (s *webForwardingService) AddWebForwarding(ctx context.Context, req *v1.Web
 		if len(require.GatewayIps) == 0 {
 			return fmt.Errorf("网关组不存在")
 		}
-		firstIp, err := s.GetGatewayFirstIp(ctx, require.HostId)
+		firstIp, err := s.gatewayIpRep.GetGatewayipByHostIdFirst(ctx, int64(require.HostId))
 		if err != nil {
 			return err
 		}
@@ -704,7 +701,7 @@ func (s *webForwardingService) EditWebForwarding(ctx context.Context, req *v1.We
 
 	// 异步任务：将域名添加到白名单
 	if webData.Domain != req.WebForwardingData.Domain {
-		firstIp, err := s.GetGatewayFirstIp(ctx, req.HostId)
+		firstIp, err := s.gatewayIpRep.GetGatewayipByHostIdFirst(ctx, int64(req.HostId))
 		if err != nil {
 			return err
 		}
@@ -839,7 +836,7 @@ func (s *webForwardingService) DeleteWebForwarding(ctx context.Context, Ids []in
 		}
 
 		// 异步任务：将域名添加到白名单
-		firstIp, err := s.GetGatewayFirstIp(ctx, oldData.HostId)
+		firstIp, err := s.gatewayIpRep.GetGatewayipByHostIdFirst(ctx, int64(oldData.HostId))
 		if err != nil {
 			return err
 		}
@@ -1031,24 +1028,6 @@ func (s *webForwardingService) GetWebForwardingWafWebAllIps(ctx context.Context,
 	return finalResults, nil
 }
 
-func (s *webForwardingService) GetGatewayFirstIp(ctx context.Context, hostId int) (string, error) {
-	gateWayGroup, err := s.gatewayGroupRep.GetGatewayGroupByHostId(ctx, int64(hostId))
-	if err != nil {
-		return "", err
-	}
-	if gateWayGroup == nil {
-		return "", fmt.Errorf("网关组不存在")
-	}
-	gateWayIps, err := s.gatewayGroupIpRep.GetGateWayGroupFirstIpByGatewayGroupId(ctx, gateWayGroup.Id)
-	if err != nil {
-		return "", err
-	}
-	if len(gateWayIps) == 0 {
-		return "", fmt.Errorf("网关组IP为空")
-	}
-	return gateWayIps, nil
-}
-
 // 清洗IP
 func (s *webForwardingService) WashDifferentIp(newIpList []string, oldIpList []string) (addedDenyIps []string, removedDenyIps []string) {
 	var newAllowIps []string

internal/service/weblimit.go

@@ -1,137 +0,0 @@
-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"
-	"github.com/spf13/cast"
-	"strconv"
-)
-
-type WebLimitService interface {
-	GetWebLimit(ctx context.Context, id int64) (*model.WebLimit, error)
-	AddWebLimit(ctx context.Context, req *v1.GeneralLimitRequireRequest) (int, error)
-	UpdateWebLimit(ctx context.Context, req *v1.WebLimitSendRequest) error
-	DeleteWebLimit(ctx context.Context, wafWebId int) (string, error)
-}
-
-func NewWebLimitService(
-	service *Service,
-	webLimitRepository repository.WebLimitRepository,
-	require RequiredService,
-	parser ParserService,
-	crawler CrawlerService,
-	host HostService,
-) WebLimitService {
-	return &webLimitService{
-		Service:            service,
-		webLimitRepository: webLimitRepository,
-		required:           require,
-		parser:             parser,
-		crawler:            crawler,
-		host:               host,
-	}
-}
-
-type webLimitService struct {
-	*Service
-	webLimitRepository repository.WebLimitRepository
-	required           RequiredService
-	parser             ParserService
-	crawler            CrawlerService
-	host               HostService
-}
-
-func (s *webLimitService) Required(ctx context.Context, req v1.GeneralLimitRequireRequest) (v1.WebLimitSendRequest, error) {
-	config, err := s.host.GetWebLimitConfig(ctx, req.HostId)
-	if err != nil {
-		return v1.WebLimitSendRequest{}, fmt.Errorf("获取配置限制失败: %w", err)
-	}
-	return v1.WebLimitSendRequest{
-		Tag:         req.Tag,
-		QpsCount:    config.QpsCount,
-		QpsDuration: config.QpsDuration,
-		RuleId:      req.RuleId,
-	}, nil
-}
-
-func (s *webLimitService) GetWebLimit(ctx context.Context, id int64) (*model.WebLimit, error) {
-	return s.webLimitRepository.GetWebLimit(ctx, id)
-}
-
-func (s *webLimitService) AddWebLimit(ctx context.Context, req *v1.GeneralLimitRequireRequest) (int, error) {
-	required, err := s.Required(ctx, *req)
-	if err != nil {
-		return 0, err
-	}
-	formData := map[string]interface{}{
-		"tag":                 req.Tag,
-		"qps_count":           required.QpsCount,
-		"qps_duration":        required.QpsDuration,
-		"waf_common_limit_id": required.RuleId,
-		"comment":             "",
-	}
-
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_web_limit/new", "admin/new/waf_web_limit", formData)
-	if err != nil {
-		return 0, err
-	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
-	if err != nil {
-		return 0, err
-	}
-	if res != "" {
-		return 0, fmt.Errorf(res)
-	}
-	webLimitIdBase, err := s.parser.GetRuleIdByColumnName(ctx, respBody, req.Tag)
-	if err != nil {
-		return 0, err
-	}
-	webLimitId, err := cast.ToIntE(webLimitIdBase)
-	if err != nil {
-		return 0, err
-	}
-	if webLimitId == 0 {
-		res, err := s.parser.ParseAlert(string(respBody))
-		if err != nil {
-			return 0, err
-		}
-		return 0, fmt.Errorf(res)
-	}
-	return webLimitId, nil
-}
-
-func (s *webLimitService) UpdateWebLimit(ctx context.Context, req *v1.WebLimitSendRequest) error {
-	formData := map[string]interface{}{
-		"waf_web_limit_id":    req.WafWebLimitId,
-		"tag":                 req.Tag,
-		"qps_count":           req.QpsCount,
-		"qps_duration":        req.QpsDuration,
-		"waf_common_limit_id": req.RuleId,
-		"comment":             "",
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_web_limit/edit?&__goadmin_edit_pk="+strconv.Itoa(req.WafWebLimitId), "admin/edit/waf_web_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 *webLimitService) DeleteWebLimit(ctx context.Context, WafWebLimitId int) (string, error) {
-	res, err := s.crawler.DeleteRule(ctx, WafWebLimitId, "admin/delete/waf_web_limit?page=1&__pageSize=10&__sort=waf_web_limit_id&__sort_type=desc")
-	if err != nil {
-		return "", err
-	}
-	return res, nil
-}

internal/task/waf.go

@@ -297,7 +297,6 @@ func (t *wafTask) executeSinglePlanCleanup(ctx context.Context, limit model.Glob
 	if allErrors.ErrorOrNil() == nil {
 		// 执行您指定的数据库“重置”操作
 		err = t.globalLimitRep.UpdateGlobalLimitByHostId(ctx, &model.GlobalLimit{
-			GatewayGroupId: 0,
 			HostId:         limit.HostId,
 			State:          true,
 		})