refactor(internal): 重构项目内部结构

- 将 allowanddenyip、gatewayip、globallimit 等服务和仓库从根目录移动到 api/waf 目录下
- 更新了相关文件中的包路径和引用
-调整了部分变量和函数的命名，以符合新的组织结构

cmd/server/wire/wire.go

@@ -5,10 +5,14 @@ package wire
 
 import (
 	"github.com/go-nunu/nunu-layout-advanced/internal/handler"
+	waf3 "github.com/go-nunu/nunu-layout-advanced/internal/handler/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/middleware"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	waf2 "github.com/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/server"
 	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/gameShield"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/app"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/jwt"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/limiter"
@@ -32,23 +36,23 @@ var repositorySet = wire.NewSet(
 	repository.NewUserRepository,
 	repository.NewGameShieldRepository,
 	repository.NewGameShieldPublicIpRepository,
-	repository.NewWebForwardingRepository,
-	repository.NewTcpforwardingRepository,
-	repository.NewUdpForWardingRepository,
+	waf2.NewWebForwardingRepository,
+	waf2.NewTcpforwardingRepository,
+	waf2.NewUdpForWardingRepository,
 	repository.NewGameShieldUserIpRepository,
 	repository.NewGameShieldBackendRepository,
 	repository.NewGameShieldSdkIpRepository,
 	repository.NewHostRepository,
-	repository.NewGlobalLimitRepository,
+	waf2.NewGlobalLimitRepository,
 	repository.NewGatewayGroupRepository,
 	repository.NewGateWayGroupIpRepository,
 	repository.NewCdnRepository,
-	repository.NewAllowAndDenyIpRepository,
+	waf2.NewAllowAndDenyIpRepository,
 	repository.NewProxyRepository,
 	repository.NewCcRepository,
 	repository.NewExpiredRepository,
 	repository.NewLogRepository,
-	repository.NewGatewayipRepository,
+	waf2.NewGatewayipRepository,
 
 )
 
@@ -57,7 +61,7 @@ var serviceSet = wire.NewSet(
 	service.NewUserService,
 
 	service.NewAdminService,
-	service.NewGameShieldService,
+	gameShield.NewGameShieldService,
 	service.NewAoDunService,
 	service.NewGameShieldPublicIpService,
 	service.NewDuedateService,
@@ -65,26 +69,26 @@ var serviceSet = wire.NewSet(
 	service.NewParserService,
 	service.NewRequiredService,
 	service.NewCrawlerService,
-	service.NewWebForwardingService,
-	service.NewTcpforwardingService,
-	service.NewUdpForWardingService,
+	waf.NewWebForwardingService,
+	waf.NewTcpforwardingService,
+	waf.NewUdpForWardingService,
 	service.NewGameShieldUserIpService,
-	service.NewGameShieldBackendService,
+	gameShield.NewGameShieldBackendService,
 	service.NewGameShieldSdkIpService,
 	service.NewHostService,
-	service.NewGlobalLimitService,
+	waf.NewGlobalLimitService,
 	service.NewGatewayGroupService,
-	service.NewWafFormatterService,
+	waf.NewWafFormatterService,
 	service.NewGateWayGroupIpService,
 	service.NewRequestService,
 	service.NewCdnService,
-	service.NewAllowAndDenyIpService,
+	waf.NewAllowAndDenyIpService,
 	service.NewProxyService,
 	service.NewSslCertService,
 	service.NewWebsocketService,
 	service.NewCcService,
 	service.NewLogService,
-	service.NewGatewayipService,
+	waf.NewGatewayipService,
 )
 
 var handlerSet = wire.NewSet(
@@ -93,19 +97,19 @@ var handlerSet = wire.NewSet(
 	handler.NewAdminHandler,
 	handler.NewGameShieldHandler,
 	handler.NewGameShieldPublicIpHandler,
-	handler.NewWebForwardingHandler,
-	handler.NewTcpforwardingHandler,
-	handler.NewUdpForWardingHandler,
+	waf3.NewWebForwardingHandler,
+	waf3.NewTcpforwardingHandler,
+	waf3.NewUdpForWardingHandler,
 	handler.NewGameShieldUserIpHandler,
 	handler.NewGameShieldBackendHandler,
 	handler.NewGameShieldSdkIpHandler,
 	handler.NewHostHandler,
-	handler.NewGlobalLimitHandler,
+	waf3.NewGlobalLimitHandler,
 	handler.NewGatewayGroupHandler,
 	handler.NewGateWayGroupIpHandler,
-	handler.NewAllowAndDenyIpHandler,
+	waf3.NewAllowAndDenyIpHandler,
 	handler.NewCcHandler,
-	handler.NewGatewayipHandler,
+	waf3.NewGatewayipHandler,
 )
 
 

cmd/server/wire/wire_gen.go

@@ -8,10 +8,14 @@ package wire
 
 import (
 	"github.com/go-nunu/nunu-layout-advanced/internal/handler"
+	waf3 "github.com/go-nunu/nunu-layout-advanced/internal/handler/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/middleware"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/server"
 	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/gameShield"
+	waf2 "github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/app"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/jwt"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/limiter"
@@ -56,37 +60,37 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	requiredService := service.NewRequiredService(serviceService, crawlerService, viperViper)
 	gameShieldSdkIpRepository := repository.NewGameShieldSdkIpRepository(repositoryRepository)
 	gameShieldSdkIpService := service.NewGameShieldSdkIpService(serviceService, gameShieldSdkIpRepository)
-	gameShieldService := service.NewGameShieldService(serviceService, gameShieldRepository, crawlerService, gameShieldPublicIpService, duedateService, formatterService, parserService, requiredService, viperViper, gameShieldSdkIpService)
+	gameShieldService := gameShield.NewGameShieldService(serviceService, gameShieldRepository, crawlerService, gameShieldPublicIpService, duedateService, formatterService, parserService, requiredService, viperViper, gameShieldSdkIpService)
 	gameShieldHandler := handler.NewGameShieldHandler(handlerHandler, gameShieldService, crawlerService)
-	gameShieldBackendService := service.NewGameShieldBackendService(serviceService, gameShieldBackendRepository, gameShieldRepository, crawlerService, gameShieldPublicIpService, duedateService, formatterService, parserService, requiredService, viperViper, gameShieldService, hostService)
+	gameShieldBackendService := gameShield.NewGameShieldBackendService(serviceService, gameShieldBackendRepository, gameShieldRepository, crawlerService, gameShieldPublicIpService, duedateService, formatterService, parserService, requiredService, viperViper, gameShieldService, hostService)
 	gameShieldBackendHandler := handler.NewGameShieldBackendHandler(handlerHandler, gameShieldBackendService)
-	webForwardingRepository := repository.NewWebForwardingRepository(repositoryRepository)
-	globalLimitRepository := repository.NewGlobalLimitRepository(repositoryRepository)
-	tcpforwardingRepository := repository.NewTcpforwardingRepository(repositoryRepository)
-	udpForWardingRepository := repository.NewUdpForWardingRepository(repositoryRepository)
-	gatewayipRepository := repository.NewGatewayipRepository(repositoryRepository)
+	webForwardingRepository := waf.NewWebForwardingRepository(repositoryRepository)
+	globalLimitRepository := waf.NewGlobalLimitRepository(repositoryRepository)
+	tcpforwardingRepository := waf.NewTcpforwardingRepository(repositoryRepository)
+	udpForWardingRepository := waf.NewUdpForWardingRepository(repositoryRepository)
+	gatewayipRepository := waf.NewGatewayipRepository(repositoryRepository)
 	logRepository := repository.NewLogRepository(repositoryRepository)
 	logService := service.NewLogService(serviceService, logRepository)
-	gatewayipService := service.NewGatewayipService(serviceService, gatewayipRepository, hostService, logService)
+	gatewayipService := waf2.NewGatewayipService(serviceService, gatewayipRepository, hostService, logService)
 	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, gatewayipRepository, gatewayipService, cdnService)
+	wafFormatterService := waf2.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository, requiredService, parserService, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, rabbitMQ, hostService, gatewayipRepository, gatewayipService, 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, gatewayipService, globalLimitRepository, cdnService, proxyService, sslCertService, websocketService)
-	webForwardingHandler := handler.NewWebForwardingHandler(handlerHandler, webForwardingService)
-	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)
-	allowAndDenyIpRepository := repository.NewAllowAndDenyIpRepository(repositoryRepository)
-	allowAndDenyIpService := service.NewAllowAndDenyIpService(serviceService, allowAndDenyIpRepository, wafFormatterService, gatewayipService)
-	globalLimitService := service.NewGlobalLimitService(serviceService, globalLimitRepository, duedateService, crawlerService, viperViper, requiredService, parserService, hostService, hostRepository, cdnService, cdnRepository, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, allowAndDenyIpService, allowAndDenyIpRepository, tcpforwardingService, udpForWardingService, webForwardingService, gatewayipRepository, gatewayipService)
-	globalLimitHandler := handler.NewGlobalLimitHandler(handlerHandler, globalLimitService)
+	webForwardingService := waf2.NewWebForwardingService(serviceService, requiredService, webForwardingRepository, crawlerService, parserService, wafFormatterService, aoDunService, rabbitMQ, gatewayipService, globalLimitRepository, cdnService, proxyService, sslCertService, websocketService)
+	webForwardingHandler := waf3.NewWebForwardingHandler(handlerHandler, webForwardingService)
+	tcpforwardingService := waf2.NewTcpforwardingService(serviceService, tcpforwardingRepository, parserService, requiredService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
+	tcpforwardingHandler := waf3.NewTcpforwardingHandler(handlerHandler, tcpforwardingService)
+	udpForWardingService := waf2.NewUdpForWardingService(serviceService, udpForWardingRepository, requiredService, parserService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
+	udpForWardingHandler := waf3.NewUdpForWardingHandler(handlerHandler, udpForWardingService)
+	allowAndDenyIpRepository := waf.NewAllowAndDenyIpRepository(repositoryRepository)
+	allowAndDenyIpService := waf2.NewAllowAndDenyIpService(serviceService, allowAndDenyIpRepository, wafFormatterService, gatewayipService)
+	globalLimitService := waf2.NewGlobalLimitService(serviceService, globalLimitRepository, duedateService, crawlerService, viperViper, requiredService, parserService, hostService, hostRepository, cdnService, cdnRepository, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, allowAndDenyIpService, allowAndDenyIpRepository, tcpforwardingService, udpForWardingService, webForwardingService, gatewayipRepository, gatewayipService)
+	globalLimitHandler := waf3.NewGlobalLimitHandler(handlerHandler, globalLimitService)
 	adminRepository := repository.NewAdminRepository(repositoryRepository)
 	adminService := service.NewAdminService(serviceService, adminRepository)
 	adminHandler := handler.NewAdminHandler(handlerHandler, adminService)
@@ -96,7 +100,7 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	gateWayGroupIpRepository := repository.NewGateWayGroupIpRepository(repositoryRepository)
 	gateWayGroupIpService := service.NewGateWayGroupIpService(serviceService, gateWayGroupIpRepository, gatewayGroupRepository, requestService)
 	gateWayGroupIpHandler := handler.NewGateWayGroupIpHandler(handlerHandler, gateWayGroupIpService)
-	allowAndDenyIpHandler := handler.NewAllowAndDenyIpHandler(handlerHandler, allowAndDenyIpService)
+	allowAndDenyIpHandler := waf3.NewAllowAndDenyIpHandler(handlerHandler, allowAndDenyIpService)
 	ccRepository := repository.NewCcRepository(repositoryRepository)
 	ccService := service.NewCcService(serviceService, ccRepository, webForwardingRepository, cdnService)
 	ccHandler := handler.NewCcHandler(handlerHandler, ccService)
@@ -109,11 +113,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.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 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, waf.NewWebForwardingRepository, waf.NewTcpforwardingRepository, waf.NewUdpForWardingRepository, repository.NewGameShieldUserIpRepository, repository.NewGameShieldBackendRepository, repository.NewGameShieldSdkIpRepository, repository.NewHostRepository, waf.NewGlobalLimitRepository, repository.NewGatewayGroupRepository, repository.NewGateWayGroupIpRepository, repository.NewCdnRepository, waf.NewAllowAndDenyIpRepository, repository.NewProxyRepository, repository.NewCcRepository, repository.NewExpiredRepository, repository.NewLogRepository, waf.NewGatewayipRepository)
 
-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 serviceSet = wire.NewSet(service.NewService, service.NewUserService, service.NewAdminService, gameShield.NewGameShieldService, service.NewAoDunService, service.NewGameShieldPublicIpService, service.NewDuedateService, service.NewFormatterService, service.NewParserService, service.NewRequiredService, service.NewCrawlerService, waf2.NewWebForwardingService, waf2.NewTcpforwardingService, waf2.NewUdpForWardingService, service.NewGameShieldUserIpService, gameShield.NewGameShieldBackendService, service.NewGameShieldSdkIpService, service.NewHostService, waf2.NewGlobalLimitService, service.NewGatewayGroupService, waf2.NewWafFormatterService, service.NewGateWayGroupIpService, service.NewRequestService, service.NewCdnService, waf2.NewAllowAndDenyIpService, service.NewProxyService, service.NewSslCertService, service.NewWebsocketService, service.NewCcService, service.NewLogService, waf2.NewGatewayipService)
 
-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 handlerSet = wire.NewSet(handler.NewHandler, handler.NewUserHandler, handler.NewAdminHandler, handler.NewGameShieldHandler, handler.NewGameShieldPublicIpHandler, waf3.NewWebForwardingHandler, waf3.NewTcpforwardingHandler, waf3.NewUdpForWardingHandler, handler.NewGameShieldUserIpHandler, handler.NewGameShieldBackendHandler, handler.NewGameShieldSdkIpHandler, handler.NewHostHandler, waf3.NewGlobalLimitHandler, handler.NewGatewayGroupHandler, handler.NewGateWayGroupIpHandler, waf3.NewAllowAndDenyIpHandler, handler.NewCcHandler, waf3.NewGatewayipHandler)
 
 // 限流器依赖集
 var limiterSet = wire.NewSet(limiter.NewLimiter, middleware.NewRateLimitMiddleware)

cmd/task/wire/wire.go

@@ -6,8 +6,11 @@ package wire
 import (
 	"github.com/go-nunu/nunu-layout-advanced/internal/job"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	waf2 "github.com/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/server"
 	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/gameShield"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/task"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/app"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/jwt"
@@ -33,16 +36,16 @@ var repositorySet = wire.NewSet(
 	repository.NewHostRepository,
 	repository.NewGameShieldUserIpRepository,
 	repository.NewGameShieldSdkIpRepository,
-	repository.NewWebForwardingRepository,
-	repository.NewTcpforwardingRepository,
-	repository.NewUdpForWardingRepository,
-	repository.NewGlobalLimitRepository,
+	waf2.NewWebForwardingRepository,
+	waf2.NewTcpforwardingRepository,
+	waf2.NewUdpForWardingRepository,
+	waf2.NewGlobalLimitRepository,
 	repository.NewGatewayGroupRepository,
 	repository.NewGateWayGroupIpRepository,
 	repository.NewCdnRepository,
 	repository.NewExpiredRepository,
 	repository.NewProxyRepository,
-	repository.NewGatewayipRepository,
+	waf2.NewGatewayipRepository,
 	repository.NewLogRepository,
 )
 
@@ -66,7 +69,7 @@ var serverSet = wire.NewSet(
 var serviceSet = wire.NewSet(
 	service.NewService,
 	service.NewAoDunService,
-	service.NewGameShieldService,
+	gameShield.NewGameShieldService,
 	service.NewCrawlerService,
 	service.NewGameShieldPublicIpService,
 	service.NewDuedateService,
@@ -74,19 +77,19 @@ var serviceSet = wire.NewSet(
 	service.NewParserService,
 	service.NewRequiredService,
 	service.NewHostService,
-	service.NewGameShieldBackendService,
+	gameShield.NewGameShieldBackendService,
 	service.NewGameShieldSdkIpService,
 	service.NewGameShieldUserIpService,
-	service.NewWafFormatterService,
+	waf.NewWafFormatterService,
 	service.NewCdnService,
 	service.NewRequestService,
-	service.NewTcpforwardingService,
-	service.NewUdpForWardingService,
-	service.NewWebForwardingService,
+	waf.NewTcpforwardingService,
+	waf.NewUdpForWardingService,
+	waf.NewWebForwardingService,
 	service.NewProxyService,
 	service.NewSslCertService,
 	service.NewWebsocketService,
-	service.NewGatewayipService,
+	waf.NewGatewayipService,
 	service.NewLogService,
 )
 

cmd/task/wire/wire_gen.go

@@ -9,8 +9,11 @@ package wire
 import (
 	"github.com/go-nunu/nunu-layout-advanced/internal/job"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/server"
 	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/gameShield"
+	waf2 "github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/task"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/app"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/jwt"
@@ -51,30 +54,30 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	requiredService := service.NewRequiredService(serviceService, crawlerService, viperViper)
 	gameShieldSdkIpRepository := repository.NewGameShieldSdkIpRepository(repositoryRepository)
 	gameShieldSdkIpService := service.NewGameShieldSdkIpService(serviceService, gameShieldSdkIpRepository)
-	gameShieldService := service.NewGameShieldService(serviceService, gameShieldRepository, crawlerService, gameShieldPublicIpService, duedateService, formatterService, parserService, requiredService, viperViper, gameShieldSdkIpService)
-	gameShieldBackendService := service.NewGameShieldBackendService(serviceService, gameShieldBackendRepository, gameShieldRepository, crawlerService, gameShieldPublicIpService, duedateService, formatterService, parserService, requiredService, viperViper, gameShieldService, hostService)
+	gameShieldService := gameShield.NewGameShieldService(serviceService, gameShieldRepository, crawlerService, gameShieldPublicIpService, duedateService, formatterService, parserService, requiredService, viperViper, gameShieldSdkIpService)
+	gameShieldBackendService := gameShield.NewGameShieldBackendService(serviceService, gameShieldBackendRepository, gameShieldRepository, crawlerService, gameShieldPublicIpService, duedateService, formatterService, parserService, requiredService, viperViper, gameShieldService, hostService)
 	gameShieldTask := task.NewGameShieldTask(taskTask, gameShieldRepository, gameShieldBackendService)
-	webForwardingRepository := repository.NewWebForwardingRepository(repositoryRepository)
-	tcpforwardingRepository := repository.NewTcpforwardingRepository(repositoryRepository)
-	udpForWardingRepository := repository.NewUdpForWardingRepository(repositoryRepository)
+	webForwardingRepository := waf.NewWebForwardingRepository(repositoryRepository)
+	tcpforwardingRepository := waf.NewTcpforwardingRepository(repositoryRepository)
+	udpForWardingRepository := waf.NewUdpForWardingRepository(repositoryRepository)
 	requestService := service.NewRequestService(serviceService)
 	cdnRepository := repository.NewCdnRepository(repositoryRepository)
 	cdnService := service.NewCdnService(serviceService, viperViper, requestService, cdnRepository)
-	globalLimitRepository := repository.NewGlobalLimitRepository(repositoryRepository)
+	globalLimitRepository := waf.NewGlobalLimitRepository(repositoryRepository)
 	expiredRepository := repository.NewExpiredRepository(repositoryRepository)
-	gatewayipRepository := repository.NewGatewayipRepository(repositoryRepository)
+	gatewayipRepository := waf.NewGatewayipRepository(repositoryRepository)
 	logRepository := repository.NewLogRepository(repositoryRepository)
 	logService := service.NewLogService(serviceService, logRepository)
-	gatewayipService := service.NewGatewayipService(serviceService, gatewayipRepository, hostService, logService)
-	wafFormatterService := service.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository, requiredService, parserService, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, rabbitMQ, hostService, gatewayipRepository, gatewayipService, cdnService)
+	gatewayipService := waf2.NewGatewayipService(serviceService, gatewayipRepository, hostService, logService)
+	wafFormatterService := waf2.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository, requiredService, parserService, tcpforwardingRepository, udpForWardingRepository, webForwardingRepository, rabbitMQ, hostService, gatewayipRepository, gatewayipService, cdnService)
 	proxyRepository := repository.NewProxyRepository(repositoryRepository)
 	proxyService := service.NewProxyService(serviceService, proxyRepository, cdnService)
-	tcpforwardingService := service.NewTcpforwardingService(serviceService, tcpforwardingRepository, parserService, requiredService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
-	udpForWardingService := service.NewUdpForWardingService(serviceService, udpForWardingRepository, requiredService, parserService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
+	tcpforwardingService := waf2.NewTcpforwardingService(serviceService, tcpforwardingRepository, parserService, requiredService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
+	udpForWardingService := waf2.NewUdpForWardingService(serviceService, udpForWardingRepository, requiredService, parserService, crawlerService, globalLimitRepository, hostRepository, wafFormatterService, cdnService, proxyService)
 	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, gatewayipService, globalLimitRepository, cdnService, proxyService, sslCertService, websocketService)
+	webForwardingService := waf2.NewWebForwardingService(serviceService, requiredService, webForwardingRepository, crawlerService, parserService, wafFormatterService, aoDunService, rabbitMQ, gatewayipService, globalLimitRepository, cdnService, proxyService, sslCertService, websocketService)
 	wafTask := task.NewWafTask(webForwardingRepository, tcpforwardingRepository, udpForWardingRepository, cdnService, hostRepository, globalLimitRepository, expiredRepository, taskTask, gatewayipRepository, tcpforwardingService, udpForWardingService, webForwardingService)
 	taskServer := server.NewTaskServer(logger, userTask, gameShieldTask, wafTask)
 	jobJob := job.NewJob(transaction, logger, sidSid, rabbitMQ)
@@ -89,7 +92,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.NewGlobalLimitRepository, repository.NewGatewayGroupRepository, repository.NewGateWayGroupIpRepository, repository.NewCdnRepository, repository.NewExpiredRepository, repository.NewProxyRepository, repository.NewGatewayipRepository, repository.NewLogRepository)
+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, waf.NewWebForwardingRepository, waf.NewTcpforwardingRepository, waf.NewUdpForWardingRepository, waf.NewGlobalLimitRepository, repository.NewGatewayGroupRepository, repository.NewGateWayGroupIpRepository, repository.NewCdnRepository, repository.NewExpiredRepository, repository.NewProxyRepository, waf.NewGatewayipRepository, repository.NewLogRepository)
 
 var taskSet = wire.NewSet(task.NewTask, task.NewUserTask, task.NewGameShieldTask, task.NewWafTask)
 
@@ -97,7 +100,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, service.NewGatewayipService, service.NewLogService)
+var serviceSet = wire.NewSet(service.NewService, service.NewAoDunService, gameShield.NewGameShieldService, service.NewCrawlerService, service.NewGameShieldPublicIpService, service.NewDuedateService, service.NewFormatterService, service.NewParserService, service.NewRequiredService, service.NewHostService, gameShield.NewGameShieldBackendService, service.NewGameShieldSdkIpService, service.NewGameShieldUserIpService, waf2.NewWafFormatterService, service.NewCdnService, service.NewRequestService, waf2.NewTcpforwardingService, waf2.NewUdpForWardingService, waf2.NewWebForwardingService, service.NewProxyService, service.NewSslCertService, service.NewWebsocketService, waf2.NewGatewayipService, service.NewLogService)
 
 // build App
 func newApp(task2 *server.TaskServer,

internal/handler/allowanddenyip.go → internal/handler/api/waf/allowanddenyip.go

@@ -1,20 +1,21 @@
-package handler
+package waf
 
 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/go-nunu/nunu-layout-advanced/internal/handler"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"net/http"
 )
 
 type AllowAndDenyIpHandler struct {
-	*Handler
-	allowAndDenyIpService service.AllowAndDenyIpService
+	*handler.Handler
+	allowAndDenyIpService waf.AllowAndDenyIpService
 }
 
 func NewAllowAndDenyIpHandler(
-    handler *Handler,
-    allowAndDenyIpService service.AllowAndDenyIpService,
+    handler *handler.Handler,
+    allowAndDenyIpService waf.AllowAndDenyIpService,
 ) *AllowAndDenyIpHandler {
 	return &AllowAndDenyIpHandler{
 		Handler:      handler,

internal/handler/gatewayip.go → internal/handler/api/waf/gatewayip.go

@@ -1,18 +1,19 @@
-package handler
+package waf
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/go-nunu/nunu-layout-advanced/internal/handler"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 )
 
 type GatewayipHandler struct {
-	*Handler
-	gatewayipService service.GatewayipService
+	*handler.Handler
+	gatewayipService waf.GatewayipService
 }
 
 func NewGatewayipHandler(
-    handler *Handler,
-    gatewayipService service.GatewayipService,
+    handler *handler.Handler,
+    gatewayipService waf.GatewayipService,
 ) *GatewayipHandler {
 	return &GatewayipHandler{
 		Handler:      handler,

internal/handler/globallimit.go → internal/handler/api/waf/globallimit.go

@@ -1,20 +1,21 @@
-package handler
+package waf
 
 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/go-nunu/nunu-layout-advanced/internal/handler"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"net/http"
 )
 
 type GlobalLimitHandler struct {
-	*Handler
-	globalLimitService service.GlobalLimitService
+	*handler.Handler
+	globalLimitService waf.GlobalLimitService
 }
 
 func NewGlobalLimitHandler(
-	handler *Handler,
-	globalLimitService service.GlobalLimitService,
+	handler *handler.Handler,
+	globalLimitService waf.GlobalLimitService,
 ) *GlobalLimitHandler {
 	return &GlobalLimitHandler{
 		Handler:            handler,

internal/handler/tcpforwarding.go → internal/handler/api/waf/tcpforwarding.go

@@ -1,21 +1,22 @@
-package handler
+package waf
 
 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/go-nunu/nunu-layout-advanced/internal/handler"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/mcuadros/go-defaults"
 	"net/http"
 )
 
 type TcpforwardingHandler struct {
-	*Handler
-	tcpforwardingService service.TcpforwardingService
+	*handler.Handler
+	tcpforwardingService waf.TcpforwardingService
 }
 
 func NewTcpforwardingHandler(
-	handler *Handler,
-	tcpforwardingService service.TcpforwardingService,
+	handler *handler.Handler,
+	tcpforwardingService waf.TcpforwardingService,
 ) *TcpforwardingHandler {
 	return &TcpforwardingHandler{
 		Handler:              handler,

internal/handler/udpforwarding.go → internal/handler/api/waf/udpforwarding.go

@@ -1,21 +1,22 @@
-package handler
+package waf
 
 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/go-nunu/nunu-layout-advanced/internal/handler"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/mcuadros/go-defaults"
 	"net/http"
 )
 
 type UdpForWardingHandler struct {
-	*Handler
-	udpForWardingService service.UdpForWardingService
+	*handler.Handler
+	udpForWardingService waf.UdpForWardingService
 }
 
 func NewUdpForWardingHandler(
-	handler *Handler,
-	udpForWardingService service.UdpForWardingService,
+	handler *handler.Handler,
+	udpForWardingService waf.UdpForWardingService,
 ) *UdpForWardingHandler {
 	return &UdpForWardingHandler{
 		Handler:              handler,

internal/handler/webforwarding.go → internal/handler/api/waf/webforwarding.go

@@ -1,21 +1,22 @@
-package handler
+package waf
 
 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/go-nunu/nunu-layout-advanced/internal/handler"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/mcuadros/go-defaults"
 	"net/http"
 )
 
 type WebForwardingHandler struct {
-	*Handler
-	webForwardingService service.WebForwardingService
+	*handler.Handler
+	webForwardingService waf.WebForwardingService
 }
 
 func NewWebForwardingHandler(
-	handler *Handler,
-	webForwardingService service.WebForwardingService,
+	handler *handler.Handler,
+	webForwardingService waf.WebForwardingService,
 ) *WebForwardingHandler {
 	return &WebForwardingHandler{
 		Handler:              handler,

internal/handler/gameshield.go

@@ -4,18 +4,19 @@ 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/go-nunu/nunu-layout-advanced/internal/service/api/gameShield"
 	"net/http"
 )
 
 type GameShieldHandler struct {
 	*Handler
-	gameShieldService service.GameShieldService
+	gameShieldService gameShield.GameShieldService
 	crawlerService    service.CrawlerService
 }
 
 func NewGameShieldHandler(
 	handler *Handler,
-	gameShieldService service.GameShieldService,
+	gameShieldService gameShield.GameShieldService,
 	crawlerService service.CrawlerService,
 ) *GameShieldHandler {
 	return &GameShieldHandler{

internal/handler/gameshieldbackend.go

@@ -3,19 +3,19 @@ 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/go-nunu/nunu-layout-advanced/internal/service/api/gameShield"
 	"github.com/mcuadros/go-defaults"
 	"net/http"
 )
 
 type GameShieldBackendHandler struct {
 	*Handler
-	gameShieldBackendService service.GameShieldBackendService
+	gameShieldBackendService gameShield.GameShieldBackendService
 }
 
 func NewGameShieldBackendHandler(
 	handler *Handler,
-	gameShieldBackendService service.GameShieldBackendService,
+	gameShieldBackendService gameShield.GameShieldBackendService,
 ) *GameShieldBackendHandler {
 	return &GameShieldBackendHandler{
 		Handler:                  handler,

internal/job/whitelist.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/google/uuid"
 	"github.com/rabbitmq/amqp091-go"
 	"go.uber.org/zap"
@@ -29,7 +30,7 @@ type WhitelistJob interface {
 // NewWhitelistJob 创建一个新的 WhitelistJob
 func NewWhitelistJob(job *Job,
 	aoDunService service.AoDunService,
-	wafForMatter service.WafFormatterService,
+	wafForMatter waf.WafFormatterService,
 ) WhitelistJob {
 	return &whitelistJob{
 		Job:          job,
@@ -41,7 +42,7 @@ func NewWhitelistJob(job *Job,
 type whitelistJob struct {
 	*Job
 	aoDunService service.AoDunService
-	wafForMatter service.WafFormatterService
+	wafForMatter waf.WafFormatterService
 }
 
 // DomainConsumer 启动域名白名单消费者

internal/repository/allowanddenyip.go → internal/repository/api/waf/allowanddenyip.go

@@ -1,9 +1,10 @@
-package repository
+package waf
 
 import (
 	"context"
 	"fmt"
 	"github.com/go-nunu/nunu-layout-advanced/internal/model"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
 )
 
 type AllowAndDenyIpRepository interface {
@@ -17,7 +18,7 @@ type AllowAndDenyIpRepository interface {
 }
 
 func NewAllowAndDenyIpRepository(
-	repository *Repository,
+	repository *repository.Repository,
 ) AllowAndDenyIpRepository {
 	return &allowAndDenyIpRepository{
 		Repository: repository,
@@ -25,7 +26,7 @@ func NewAllowAndDenyIpRepository(
 }
 
 type allowAndDenyIpRepository struct {
-	*Repository
+	*repository.Repository
 }
 
 func (r *allowAndDenyIpRepository) GetAllowAndDenyIp(ctx context.Context, id int64) (*model.AllowAndDenyIp, error) {
@@ -37,7 +38,7 @@ func (r *allowAndDenyIpRepository) GetAllowAndDenyIp(ctx context.Context, id int
 }
 
 func (r *allowAndDenyIpRepository) AddAllowAndDenyIps(ctx context.Context, req model.AllowAndDenyIp) error {
-	if err := r.db.WithContext(ctx).Create(&req).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Create(&req).Error; err != nil {
 		return fmt.Errorf("create error: %v", err)
 	}
 	return nil
@@ -47,14 +48,14 @@ func (r *allowAndDenyIpRepository) EditAllowAndDenyIps(ctx context.Context, req
 	allowAndDenyIp := map[string]interface{}{
 		"allow_or_deny": req.AllowOrDeny,
 	}
-	if err := r.db.WithContext(ctx).Where("id = ?", req.Id).Updates(&req).Updates(allowAndDenyIp).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Where("id = ?", req.Id).Updates(&req).Updates(allowAndDenyIp).Error; err != nil {
 		return fmt.Errorf("update error: %v", err)
 	}
 	return nil
 }
 
 func (r *allowAndDenyIpRepository) DeleteAllowAndDenyIps(ctx context.Context, id int64) error {
-	if err := r.db.WithContext(ctx).Where("id = ?", id).Delete(&model.AllowAndDenyIp{}).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Where("id = ?", id).Delete(&model.AllowAndDenyIp{}).Error; err != nil {
 		return fmt.Errorf("delete error: %v", err)
 	}
 	return nil

internal/repository/gatewayip.go → internal/repository/api/waf/gatewayip.go

@@ -1,10 +1,11 @@
-package repository
+package waf
 
 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"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 )
@@ -24,7 +25,7 @@ type GatewayipRepository interface {
 }
 
 func NewGatewayipRepository(
-	repository *Repository,
+	repository *repository.Repository,
 ) GatewayipRepository {
 	return &gatewayipRepository{
 		Repository: repository,
@@ -32,7 +33,7 @@ func NewGatewayipRepository(
 }
 
 type gatewayipRepository struct {
-	*Repository
+	*repository.Repository
 }
 
 func (r *gatewayipRepository) GetGatewayip(ctx context.Context, id int64) (*model.Gatewayip, error) {

internal/repository/globallimit.go → internal/repository/api/waf/globallimit.go

@@ -1,4 +1,4 @@
-package repository
+package waf
 
 import (
 	"context"
@@ -6,6 +6,7 @@ import (
 	"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"
 	"gorm.io/gorm"
 	"time"
 )
@@ -33,7 +34,7 @@ type GlobalLimitRepository interface {
 }
 
 func NewGlobalLimitRepository(
-	repository *Repository,
+	repository *repository.Repository,
 ) GlobalLimitRepository {
 	return &globalLimitRepository{
 		Repository: repository,
@@ -41,7 +42,7 @@ func NewGlobalLimitRepository(
 }
 
 type globalLimitRepository struct {
-	*Repository
+	*repository.Repository
 }
 
 func (r *globalLimitRepository) GetGlobalLimit(ctx context.Context, id int64) (*model.GlobalLimit, error) {
@@ -133,7 +134,7 @@ func (r *globalLimitRepository) GetUserInfo(ctx context.Context, uid int64) (v1.
 
 func (r *globalLimitRepository) GetHostName(ctx context.Context,hostId int64) (string, error)  {
 	var projectName string
-	err := r.db.WithContext(ctx).Table("shd_host").
+	err := r.Db.WithContext(ctx).Table("shd_host").
 		Select("shd_products.name").
 		Joins("JOIN shd_products ON shd_host.productid = shd_products.id").
 		Where("shd_host.id = ?", hostId).

internal/repository/tcpforwarding.go → internal/repository/api/waf/tcpforwarding.go

@@ -1,4 +1,4 @@
-package repository
+package waf
 
 import (
 	"context"
@@ -6,6 +6,7 @@ import (
 	"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"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -33,7 +34,7 @@ type TcpforwardingRepository interface {
 }
 
 func NewTcpforwardingRepository(
-	repository *Repository,
+	repository *repository.Repository,
 ) TcpforwardingRepository {
 	return &tcpforwardingRepository{
 		Repository: repository,
@@ -41,19 +42,19 @@ func NewTcpforwardingRepository(
 }
 
 type tcpforwardingRepository struct {
-	*Repository
+	*repository.Repository
 }
 
 func (r *tcpforwardingRepository) GetTcpforwarding(ctx context.Context, id int64) (*model.Tcpforwarding, error) {
 	var tcpforwarding model.Tcpforwarding
-	if err := r.db.Where("id = ?", id).First(&tcpforwarding).Error; err != nil {
+	if err := r.Db.Where("id = ?", id).First(&tcpforwarding).Error; err != nil {
 		return nil, err
 	}
 	return &tcpforwarding, nil
 }
 
 func (r *tcpforwardingRepository) AddTcpforwarding(ctx context.Context, req *model.Tcpforwarding) (int, error) {
-	if err := r.db.Create(req).Error; err != nil {
+	if err := r.Db.Create(req).Error; err != nil {
 		return 0, err
 	}
 	return req.Id, nil
@@ -63,14 +64,14 @@ func (r *tcpforwardingRepository) EditTcpforwarding(ctx context.Context, req *mo
 	data := map[string]interface{}{
 		"proxy" : req.Proxy,
 	}
-	if err := r.db.Updates(req).Updates(data).Error; err != nil {
+	if err := r.Db.Updates(req).Updates(data).Error; err != nil {
 		return err
 	}
 	return nil
 }
 
 func (r *tcpforwardingRepository) DeleteTcpforwarding(ctx context.Context, id int64) error {
-	if err := r.db.Where("id = ?", id).Delete(&model.Tcpforwarding{}).Error; err != nil {
+	if err := r.Db.Where("id = ?", id).Delete(&model.Tcpforwarding{}).Error; err != nil {
 		return err
 	}
 	return nil
@@ -79,7 +80,7 @@ func (r *tcpforwardingRepository) DeleteTcpforwarding(ctx context.Context, id in
 func (r *tcpforwardingRepository) GetTcpforwardingWafTcpIdById(ctx context.Context, id int) (int, error) {
 	var WafTcpId int
 
-	if err := r.db.Model(&model.Tcpforwarding{}).Where("id = ?", id).Select("waf_tcp_id").Find(&WafTcpId).Error; err != nil {
+	if err := r.Db.Model(&model.Tcpforwarding{}).Where("id = ?", id).Select("waf_tcp_id").Find(&WafTcpId).Error; err != nil {
 		return 0, err
 	}
 	return WafTcpId, nil
@@ -88,7 +89,7 @@ func (r *tcpforwardingRepository) GetTcpforwardingWafTcpIdById(ctx context.Conte
 
 func (r *tcpforwardingRepository) GetTcpForwardingPortCountByHostId(ctx context.Context, hostId int) (int64, error) {
 	var count int64
-	if err := r.db.Model(&model.Tcpforwarding{}).Where("host_id = ?", hostId).Count(&count).Error; err != nil {
+	if err := r.Db.Model(&model.Tcpforwarding{}).Where("host_id = ?", hostId).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
@@ -96,7 +97,7 @@ func (r *tcpforwardingRepository) GetTcpForwardingPortCountByHostId(ctx context.
 
 func (r *tcpforwardingRepository) GetTcpForwardingAllIdsByID(ctx context.Context, hostId int) ([]int, error) {
 	var res []int
-	if err := r.db.WithContext(ctx).Model(&model.Tcpforwarding{}).Where("host_id = ?", hostId).Select("id").Find(&res).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Model(&model.Tcpforwarding{}).Where("host_id = ?", hostId).Select("id").Find(&res).Error; err != nil {
 		return nil, err
 	}
 	return res, nil
@@ -104,7 +105,7 @@ func (r *tcpforwardingRepository) GetTcpForwardingAllIdsByID(ctx context.Context
 
 //mongodb 插入
 func (r *tcpforwardingRepository) AddTcpforwardingIps(ctx context.Context,req model.TcpForwardingRule) (primitive.ObjectID, error) {
-	collection := r.mongoDB.Collection("tcp_forwarding_rules")
+	collection := r.MongoDB.Collection("tcp_forwarding_rules")
 	req.CreatedAt = time.Now()
 	result, err := collection.InsertOne(ctx, req)
 	if err != nil {
@@ -116,7 +117,7 @@ func (r *tcpforwardingRepository) AddTcpforwardingIps(ctx context.Context,req mo
 }
 
 func (r *tcpforwardingRepository) EditTcpforwardingIps(ctx context.Context, req model.TcpForwardingRule) error {
-	collection := r.mongoDB.Collection("tcp_forwarding_rules")
+	collection := r.MongoDB.Collection("tcp_forwarding_rules")
 	updateData := bson.M{}
 
 	if req.Uid != 0 {
@@ -162,7 +163,7 @@ func (r *tcpforwardingRepository) EditTcpforwardingIps(ctx context.Context, req
 
 func (r *tcpforwardingRepository) GetTcpForwardingIpsByID(ctx context.Context, tcpId int) (*model.TcpForwardingRule, error) {
 
-	collection := r.mongoDB.Collection("tcp_forwarding_rules")
+	collection := r.MongoDB.Collection("tcp_forwarding_rules")
 
 	var res model.TcpForwardingRule
 
@@ -180,7 +181,7 @@ func (r *tcpforwardingRepository) GetTcpForwardingIpsByID(ctx context.Context, t
 
 func (r *tcpforwardingRepository) DeleteTcpForwardingIpsById(ctx context.Context, tcpId int) error {
 
-	collection := r.mongoDB.Collection("tcp_forwarding_rules")
+	collection := r.MongoDB.Collection("tcp_forwarding_rules")
 
 	 err := collection.Remove(ctx, bson.M{"tcp_id": tcpId})
 
@@ -241,7 +242,7 @@ func (r *tcpforwardingRepository) GetIpCountByIp(ctx context.Context, ips []stri
 	}
 
 	var results []v1.IpCountResult
-	err := r.mongoDB.Collection("tcp_forwarding_rules").Aggregate(ctx, pipeline).All(&results)
+	err := r.MongoDB.Collection("tcp_forwarding_rules").Aggregate(ctx, pipeline).All(&results)
 	if err != nil {
 		return nil, fmt.Errorf("聚合查询 tcp_forwarding_rules 失败: %w", err)
 	}
@@ -250,7 +251,7 @@ func (r *tcpforwardingRepository) GetIpCountByIp(ctx context.Context, ips []stri
 
 func (r *tcpforwardingRepository) GetPortCount(ctx context.Context,hostId int64, port string) (int64, error) {
 	var count int64
-	if err := r.db.WithContext(ctx).Model(&model.Tcpforwarding{}).Where("host_id = ? AND port = ?", hostId, port).Count(&count).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Model(&model.Tcpforwarding{}).Where("host_id = ? AND port = ?", hostId, port).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
@@ -259,7 +260,7 @@ func (r *tcpforwardingRepository) GetPortCount(ctx context.Context,hostId int64,
 
 func (r *tcpforwardingRepository) GetTcpAll(ctx context.Context, hostIds []int) ([]int, error) {
 	var res []int
-	if err := r.db.WithContext(ctx).Model(&model.Tcpforwarding{}).Where("host_id IN ?", hostIds).Select("cdn_web_id").Scan(&res).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Model(&model.Tcpforwarding{}).Where("host_id IN ?", hostIds).Select("cdn_web_id").Scan(&res).Error; err != nil {
 		return nil, err
 	}
 	return res, nil

internal/repository/udpforwarding.go → internal/repository/api/waf/udpforwarding.go

@@ -1,4 +1,4 @@
-package repository
+package waf
 
 import (
 	"context"
@@ -6,6 +6,7 @@ import (
 	"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"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -32,7 +33,7 @@ type UdpForWardingRepository interface {
 }
 
 func NewUdpForWardingRepository(
-	repository *Repository,
+	repository *repository.Repository,
 ) UdpForWardingRepository {
 	return &udpForWardingRepository{
 		Repository: repository,
@@ -40,12 +41,12 @@ func NewUdpForWardingRepository(
 }
 
 type udpForWardingRepository struct {
-	*Repository
+	*repository.Repository
 }
 
 func (r *udpForWardingRepository) GetUdpForWarding(ctx context.Context, id int64) (*model.UdpForWarding, error) {
 	var udpForWarding model.UdpForWarding
-	if err := r.db.Where("id = ?", id).First(&udpForWarding).Error; err != nil {
+	if err := r.Db.Where("id = ?", id).First(&udpForWarding).Error; err != nil {
 		return nil, err
 	}
 
@@ -53,7 +54,7 @@ func (r *udpForWardingRepository) GetUdpForWarding(ctx context.Context, id int64
 }
 
 func (r *udpForWardingRepository) AddUdpForwarding(ctx context.Context, req *model.UdpForWarding) (int, error) {
-	if err := r.db.WithContext(ctx).Create(req).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Create(req).Error; err != nil {
 		return 0, err
 	}
 	return req.Id, nil
@@ -63,14 +64,14 @@ func (r *udpForWardingRepository) EditUdpForwarding(ctx context.Context, req *mo
 	data := map[string]interface{}{
 		"proxy" : req.Proxy,
 	}
-	if err := r.db.Updates(req).Updates(data).Error; err != nil {
+	if err := r.Db.Updates(req).Updates(data).Error; err != nil {
 		return err
 	}
 	return nil
 }
 
 func (r *udpForWardingRepository) DeleteUdpForwarding(ctx context.Context, id int64) error {
-	if err := r.db.Where("id = ?", id).Delete(&model.UdpForWarding{}).Error; err != nil {
+	if err := r.Db.Where("id = ?", id).Delete(&model.UdpForWarding{}).Error; err != nil {
 		return err
 	}
 	return nil
@@ -79,7 +80,7 @@ func (r *udpForWardingRepository) DeleteUdpForwarding(ctx context.Context, id in
 func (r *udpForWardingRepository) GetUdpForwardingWafUdpIdById(ctx context.Context, id int) (int, error) {
 	var WafUdpId int
 
-	if err := r.db.Model(&model.UdpForWarding{}).Where("id = ?", id).Select("waf_udp_id").Find(&WafUdpId).Error; err != nil {
+	if err := r.Db.Model(&model.UdpForWarding{}).Where("id = ?", id).Select("waf_udp_id").Find(&WafUdpId).Error; err != nil {
 		return 0, err
 	}
 	return WafUdpId, nil
@@ -87,7 +88,7 @@ func (r *udpForWardingRepository) GetUdpForwardingWafUdpIdById(ctx context.Conte
 
 func (r *udpForWardingRepository) GetUdpForwardingPortCountByHostId(ctx context.Context, hostId int) (int64, error)  {
 	var count int64
-	if err := r.db.Model(&model.UdpForWarding{}).Where("host_id = ?", hostId).Count(&count).Error; err != nil {
+	if err := r.Db.Model(&model.UdpForWarding{}).Where("host_id = ?", hostId).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
@@ -95,7 +96,7 @@ func (r *udpForWardingRepository) GetUdpForwardingPortCountByHostId(ctx context.
 
 func (r *udpForWardingRepository) GetUdpForwardingWafUdpAllIds(ctx context.Context, hostId int) ([]int, error) {
 	var res []int
-	if err:= r.db.WithContext(ctx).Model(&model.UdpForWarding{}).Where("host_id = ?", hostId).Select("id").Find(&res).Error; err != nil {
+	if err:= r.Db.WithContext(ctx).Model(&model.UdpForWarding{}).Where("host_id = ?", hostId).Select("id").Find(&res).Error; err != nil {
 		return nil, err
 	}
 	return res, nil
@@ -104,7 +105,7 @@ func (r *udpForWardingRepository) GetUdpForwardingWafUdpAllIds(ctx context.Conte
 
 // mongodb 插入
 func (r *udpForWardingRepository) AddUdpForwardingIps(ctx context.Context, req model.UdpForwardingRule) (primitive.ObjectID, error) {
-	collection := r.mongoDB.Collection("udp_forwarding_rules")
+	collection := r.MongoDB.Collection("udp_forwarding_rules")
 	req.CreatedAt = time.Now()
 	result, err := collection.InsertOne(ctx, req)
 	if err != nil {
@@ -116,7 +117,7 @@ func (r *udpForWardingRepository) AddUdpForwardingIps(ctx context.Context, req m
 }
 
 func (r *udpForWardingRepository) EditUdpForwardingIps(ctx context.Context, req model.UdpForwardingRule) error {
-	collection := r.mongoDB.Collection("udp_forwarding_rules")
+	collection := r.MongoDB.Collection("udp_forwarding_rules")
 	updateData := bson.M{}
 
 	if req.Uid != 0 {
@@ -159,7 +160,7 @@ func (r *udpForWardingRepository) EditUdpForwardingIps(ctx context.Context, req
 
 func (r *udpForWardingRepository) GetUdpForwardingIpsByID(ctx context.Context, udpId int) (*model.UdpForwardingRule, error) {
 
-	collection := r.mongoDB.Collection("udp_forwarding_rules")
+	collection := r.MongoDB.Collection("udp_forwarding_rules")
 	var result model.UdpForwardingRule
 	err := collection.Find(ctx, bson.M{"udp_id": udpId}).One(&result)
 	if err != nil {
@@ -174,7 +175,7 @@ func (r *udpForWardingRepository) GetUdpForwardingIpsByID(ctx context.Context, u
 
 func (r *udpForWardingRepository) DeleteUdpForwardingIpsById(ctx context.Context, udpId int) error {
 
-	collection := r.mongoDB.Collection("udp_forwarding_rules")
+	collection := r.MongoDB.Collection("udp_forwarding_rules")
 
 	 err := collection.Remove(ctx, bson.M{"udp_id": udpId})
 
@@ -230,7 +231,7 @@ func (r *udpForWardingRepository) GetIpCountByIp(ctx context.Context, ips []stri
 	}
 
 	var results []v1.IpCountResult
-	err := r.mongoDB.Collection("udp_forwarding_rules").Aggregate(ctx, pipeline).All(&results)
+	err := r.MongoDB.Collection("udp_forwarding_rules").Aggregate(ctx, pipeline).All(&results)
 	if err != nil {
 		return nil, fmt.Errorf("聚合查询 udp_forwarding_rules 失败: %w", err)
 	}
@@ -239,7 +240,7 @@ func (r *udpForWardingRepository) GetIpCountByIp(ctx context.Context, ips []stri
 
 func (r *udpForWardingRepository) GetPortCount(ctx context.Context, hostId int64, port string) (int64, error) {
 	var count int64
-	if err := r.db.WithContext(ctx).Model(&model.UdpForWarding{}).Where("host_id = ? AND port = ?", hostId, port).Count(&count).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Model(&model.UdpForWarding{}).Where("host_id = ? AND port = ?", hostId, port).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
@@ -247,7 +248,7 @@ func (r *udpForWardingRepository) GetPortCount(ctx context.Context, hostId int64
 
 func (r *udpForWardingRepository) GetUdpAll(ctx context.Context, hostIds []int) ([]int, error) {
 	var res []int
-	if err:= r.db.WithContext(ctx).Model(&model.UdpForWarding{}).Where("host_id IN ?", hostIds).Select("cdn_web_id").Scan(&res).Error; err != nil {
+	if err:= r.Db.WithContext(ctx).Model(&model.UdpForWarding{}).Where("host_id IN ?", hostIds).Select("cdn_web_id").Scan(&res).Error; err != nil {
 		return nil, err
 	}
 	return res, nil

internal/repository/webforwarding.go → internal/repository/api/waf/webforwarding.go

@@ -1,4 +1,4 @@
-package repository
+package waf
 
 import (
 	"context"
@@ -7,6 +7,7 @@ import (
 	"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/qiniu/qmgo"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -42,7 +43,7 @@ type WebForwardingRepository interface {
 }
 
 func NewWebForwardingRepository(
-	repository *Repository,
+	repository *repository.Repository,
 ) WebForwardingRepository {
 	return &webForwardingRepository{
 		Repository: repository,
@@ -50,19 +51,19 @@ func NewWebForwardingRepository(
 }
 
 type webForwardingRepository struct {
-	*Repository
+	*repository.Repository
 }
 
 func (r *webForwardingRepository) GetWebForwarding(ctx context.Context, id int64) (*model.WebForwarding, error) {
 	var webForwarding model.WebForwarding
-	if err := r.db.WithContext(ctx).Where("id = ?", id).First(&webForwarding).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Where("id = ?", id).First(&webForwarding).Error; err != nil {
 		return nil, err
 	}
 	return &webForwarding, nil
 }
 
 func (r *webForwardingRepository) AddWebForwarding(ctx context.Context, req *model.WebForwarding) (int, error) {
-	if err := r.db.WithContext(ctx).Create(req).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Create(req).Error; err != nil {
 		return 0, err
 	}
 	return req.Id, nil
@@ -89,7 +90,7 @@ func (r *webForwardingRepository) EditWebForwarding(ctx context.Context, req *mo
 	// - Domain 字段总能被正确更新（无论新值是不是 ""）。
 	// - 其他字段遵循 GORM 的默认行为（非零值才更新）。
 	// - 这一切都在一个 UPDATE 语句中完成。
-	db := r.db.WithContext(ctx).Model(req).Updates(req).Updates(forceUpdateFields)
+	db := r.Db.WithContext(ctx).Model(req).Updates(req).Updates(forceUpdateFields)
 
 	if db.Error != nil {
 		return db.Error
@@ -98,7 +99,7 @@ func (r *webForwardingRepository) EditWebForwarding(ctx context.Context, req *mo
 }
 
 func (r *webForwardingRepository) DeleteWebForwarding(ctx context.Context, id int64) error {
-	if err := r.db.WithContext(ctx).Where("id = ?", id).Delete(&model.WebForwarding{}).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Where("id = ?", id).Delete(&model.WebForwarding{}).Error; err != nil {
 		return err
 	}
 	return nil
@@ -106,7 +107,7 @@ func (r *webForwardingRepository) DeleteWebForwarding(ctx context.Context, id in
 
 func (r *webForwardingRepository) GetWebForwardingPortCountByHostId(ctx context.Context, hostId int) (int64, error) {
 	var count int64
-	if err := r.db.Model(&model.WebForwarding{}).WithContext(ctx).Where("host_id = ?", hostId).Count(&count).Error; err != nil {
+	if err := r.Db.Model(&model.WebForwarding{}).WithContext(ctx).Where("host_id = ?", hostId).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
@@ -114,7 +115,7 @@ func (r *webForwardingRepository) GetWebForwardingPortCountByHostId(ctx context.
 
 func (r *webForwardingRepository) GetWebForwardingDomainCountByHostId(ctx context.Context, hostId int) (int64, []string, error) {
 	var distinctDomains []string
-	err := r.db.Model(&model.WebForwarding{}).WithContext(ctx).
+	err := r.Db.Model(&model.WebForwarding{}).WithContext(ctx).
 		Distinct().                                                           // 确保我们只获取唯一的 domain 值
 		Where("host_id = ? AND domain IS NOT NULL AND domain != ''", hostId). // 额外添加 domain != '' 以排除空字符串
 		Pluck("domain", &distinctDomains).Error
@@ -129,7 +130,7 @@ func (r *webForwardingRepository) GetWebForwardingDomainCountByHostId(ctx contex
 
 func (r *webForwardingRepository) GetWebForwardingWafWebAllIds(ctx context.Context, hostId int) ([]int, error) {
 	var ids []int
-	if err := r.db.Model(&model.WebForwarding{}).WithContext(ctx).Where("host_id = ?", hostId).Select("id").Find(&ids).Error; err != nil {
+	if err := r.Db.Model(&model.WebForwarding{}).WithContext(ctx).Where("host_id = ?", hostId).Select("id").Find(&ids).Error; err != nil {
 		return nil, err
 	}
 
@@ -138,7 +139,7 @@ func (r *webForwardingRepository) GetWebForwardingWafWebAllIds(ctx context.Conte
 
 // mongodb 插入
 func (r *webForwardingRepository) AddWebForwardingIps(ctx context.Context, req model.WebForwardingRule) (primitive.ObjectID, error) {
-	collection := r.mongoDB.Collection("web_forwarding_rules")
+	collection := r.MongoDB.Collection("web_forwarding_rules")
 	req.CreatedAt = time.Now()
 	result, err := collection.InsertOne(ctx, req)
 	if err != nil {
@@ -150,7 +151,7 @@ func (r *webForwardingRepository) AddWebForwardingIps(ctx context.Context, req m
 }
 
 func (r *webForwardingRepository) EditWebForwardingIps(ctx context.Context, req model.WebForwardingRule) error {
-	collection := r.mongoDB.Collection("web_forwarding_rules")
+	collection := r.MongoDB.Collection("web_forwarding_rules")
 	updateData := bson.M{}
 
 	if req.Uid != 0 {
@@ -192,7 +193,7 @@ func (r *webForwardingRepository) EditWebForwardingIps(ctx context.Context, req
 func (r *webForwardingRepository) GetWebForwardingIpsByID(ctx context.Context, webId int) (*model.WebForwardingRule, error) {
 
 	// 获取集合
-	collection := r.mongoDB.Collection("web_forwarding_rules")
+	collection := r.MongoDB.Collection("web_forwarding_rules")
 
 	// 创建一个结构体来存储查询到的文档
 	var rule model.WebForwardingRule
@@ -215,7 +216,7 @@ func (r *webForwardingRepository) GetWebForwardingIpsByID(ctx context.Context, w
 
 func (r *webForwardingRepository) DeleteWebForwardingIpsById(ctx context.Context, webId int) error {
 
-	collection := r.mongoDB.Collection("web_forwarding_rules")
+	collection := r.MongoDB.Collection("web_forwarding_rules")
 
 	err := collection.Remove(ctx, bson.M{"web_id": webId})
 
@@ -231,7 +232,7 @@ func (r *webForwardingRepository) DeleteWebForwardingIpsById(ctx context.Context
 // 获取域名数量
 func (r *webForwardingRepository) GetDomainCount(ctx context.Context, hostId int, domain string) (int, error) {
 	var count int64
-	if err := r.db.Model(&model.WebForwarding{}).WithContext(ctx).Where("host_id = ? AND domain = ?", hostId, domain).Count(&count).Error; err != nil {
+	if err := r.Db.Model(&model.WebForwarding{}).WithContext(ctx).Where("host_id = ? AND domain = ?", hostId, domain).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return int(count), nil
@@ -294,7 +295,7 @@ func (r *webForwardingRepository) GetIpCountByIp(ctx context.Context, ips []stri
 
 	var results []v1.IpCountResult
 	// 使用 qmgo 执行聚合查询
-	err := r.mongoDB.Collection("web_forwarding_rules").Aggregate(ctx, pipeline).All(&results)
+	err := r.MongoDB.Collection("web_forwarding_rules").Aggregate(ctx, pipeline).All(&results)
 	if err != nil {
 		// 加上错误包装，方便调试
 		return nil, fmt.Errorf("聚合查询 web_forwarding_rules 失败: %w", err)
@@ -353,7 +354,7 @@ func (r *webForwardingRepository) GetWebConfigId(ctx context.Context, id int64)
 
 func (r *webForwardingRepository) GetDomainByHostIdPort(ctx context.Context, hostId int64, port string) ([]v1.Domain, error) {
 	var domains []v1.Domain
-	if err := r.db.WithContext(ctx).Model(&model.WebForwarding{}).Where("host_id = ? AND port = ?", hostId, port).Select("domain,id,is_https").Scan(&domains).Error; err != nil {
+	if err := r.Db.WithContext(ctx).Model(&model.WebForwarding{}).Where("host_id = ? AND port = ?", hostId, port).Select("domain,id,is_https").Scan(&domains).Error; err != nil {
 		return nil, err
 	}
 	return domains, nil
@@ -372,7 +373,7 @@ func (r *webForwardingRepository) GetWebId(ctx context.Context, serverId int64)
 
 func (r *webForwardingRepository) GetWebAll(ctx context.Context, hostIds []int) ([]int, error) {
 	var res []int
-	if err := r.db.Model(&model.WebForwarding{}).WithContext(ctx).Where("host_id IN ?", hostIds).Select("cdn_web_id").Scan(&res).Error; err != nil {
+	if err := r.Db.Model(&model.WebForwarding{}).WithContext(ctx).Where("host_id IN ?", hostIds).Select("cdn_web_id").Scan(&res).Error; err != nil {
 		return nil, err
 	}
 

internal/repository/gatewaygroup.go

@@ -97,7 +97,7 @@ func (r *gatewayGroupRepository) GetGatewayGroupList(ctx context.Context,req v1.
 	var res []model.GatewayGroup
 	var total int64
 
-	query := r.db.WithContext(ctx).Model(&model.GatewayGroup{})
+	query := r.Db.WithContext(ctx).Model(&model.GatewayGroup{})
 
 	if  req.Name != "" {
 		// 去除后所有的空白字符（包括空格、制表符\t、换行符等）

internal/repository/gatewaygroupip.go

@@ -92,7 +92,7 @@ func (r *gateWayGroupIpRepository) GetGatewayGroupIpList(ctx context.Context,req
 	var res []model.GateWayGroupIp
 	var total int64
 
-	query := r.db.WithContext(ctx).Model(&model.GateWayGroupIp{})
+	query := r.Db.WithContext(ctx).Model(&model.GateWayGroupIp{})
 	if  req.Ip != "" {
 		trimmedName := strings.TrimSpace(req.Ip)
 		// 使用 LIKE 进行模糊匹配

internal/repository/repository.go

@@ -24,10 +24,10 @@ import (
 const ctxTxKey = "TxKey"
 
 type Repository struct {
-	db          *gorm.DB
-	rdb         *redis.Client
+	Db  *gorm.DB
+	rdb *redis.Client
 	mongoClient *qmgo.Client
-	mongoDB     *qmgo.Database
+	MongoDB     *qmgo.Database
 	mq          *rabbitmq.RabbitMQ
 	logger      *log.Logger
 	e           *casbin.SyncedEnforcer
@@ -43,10 +43,10 @@ func NewRepository(
 	e *casbin.SyncedEnforcer,
 ) *Repository {
 	return &Repository{
-		db:          db,
+		Db:          db,
 		rdb:         rdb,
 		mongoClient: mongoClient,
-		mongoDB:     mongoDB,
+		MongoDB:     mongoDB,
 		mq:          mq,
 		logger:      logger,
 		e:           e,
@@ -72,7 +72,7 @@ func (r *Repository) DB(ctx context.Context) *gorm.DB {
 			return tx
 		}
 	}
-	return r.db.WithContext(ctx)
+	return r.Db.WithContext(ctx)
 }
 
 // DBWithName 使用特定名称的数据库连接
@@ -88,13 +88,13 @@ func (r *Repository) DBWithName(ctx context.Context, dbName string) *gorm.DB {
 	
 	// 使用指定名称的数据库连接
 	if dbName != "" {
-		return r.db.Clauses(dbresolver.Use(dbName)).WithContext(ctx)
+		return r.Db.Clauses(dbresolver.Use(dbName)).WithContext(ctx)
 	}
-	return r.db.WithContext(ctx)
+	return r.Db.WithContext(ctx)
 }
 
 func (r *Repository) Transaction(ctx context.Context, fn func(ctx context.Context) error) error {
-	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+	return r.Db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
 		ctxWithTx := context.WithValue(ctx, ctxTxKey, tx)
 		return fn(ctxWithTx)
 	})
@@ -103,7 +103,7 @@ func (r *Repository) Transaction(ctx context.Context, fn func(ctx context.Contex
 // TransactionWithDB 在特定数据库上执行事务
 func (r *Repository) TransactionWithDB(ctx context.Context, dbName string, fn func(ctx context.Context) error) error {
 	// 使用特定的数据库连接
-	db := r.db
+	db := r.Db
 	if dbName != "" {
 		db = db.Clauses(dbresolver.Use(dbName))
 	}

internal/server/http.go

@@ -6,6 +6,7 @@ import (
 	apiV1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
 	"github.com/go-nunu/nunu-layout-advanced/docs"
 	"github.com/go-nunu/nunu-layout-advanced/internal/handler"
+	"github.com/go-nunu/nunu-layout-advanced/internal/handler/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/middleware"
 	"github.com/go-nunu/nunu-layout-advanced/internal/service"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/jwt"
@@ -27,14 +28,14 @@ func NewHTTPServer(
 	userHandler *handler.UserHandler,
 	gameShieldHandler *handler.GameShieldHandler,
 	gameShieldBackendHandler *handler.GameShieldBackendHandler,
-	webForwardingHandler *handler.WebForwardingHandler,
-	tcpForwardingHandler *handler.TcpforwardingHandler,
-	udpForwardingHandler *handler.UdpForWardingHandler,
-	globalLimitHandler *handler.GlobalLimitHandler,
+	webForwardingHandler *waf.WebForwardingHandler,
+	tcpForwardingHandler *waf.TcpforwardingHandler,
+	udpForwardingHandler *waf.UdpForWardingHandler,
+	globalLimitHandler *waf.GlobalLimitHandler,
 	adminHandler *handler.AdminHandler,
 	gatewayHandler *handler.GatewayGroupHandler,
 	gatewayIpHandler *handler.GateWayGroupIpHandler,
-	allowAnddenyHandler *handler.AllowAndDenyIpHandler,
+	allowAnddenyHandler *waf.AllowAndDenyIpHandler,
 	ccHandler *handler.CcHandler,
 	logService service.LogService,
 ) *http.Server {

internal/service/admin.go

@@ -112,7 +112,7 @@ func (s *adminService) GetAdminUsers(ctx context.Context, req *v1.GetAdminUsersR
 	for _, user := range list {
 		roles, err := s.adminRepository.GetUserRoles(ctx, user.ID)
 		if err != nil {
-			s.logger.Error("GetUserRoles error", zap.Error(err))
+			s.Logger.Error("GetUserRoles error", zap.Error(err))
 			continue
 		}
 		data.List = append(data.List, v1.AdminUserDataItem{
@@ -337,7 +337,7 @@ func (s *adminService) GetMenus(ctx context.Context, uid uint) (*v1.GetMenuRespo
 	// 建议在这里就进行初步排序，确保基础顺序
 	menuList, err := s.adminRepository.GetMenuList(ctx) // 最好让此方法返回按 Weight, ID 排序后的结果
 	if err != nil {
-		s.logger.WithContext(ctx).Error("GetMenuList error", zap.Error(err))
+		s.Logger.WithContext(ctx).Error("GetMenuList error", zap.Error(err))
 		return nil, err
 	}
 
@@ -431,7 +431,7 @@ func (s *adminService) GetMenus(ctx context.Context, uid uint) (*v1.GetMenuRespo
 func (s *adminService) GetAdminMenus(ctx context.Context) (*v1.GetMenuResponseData, error) {
 	menuList, err := s.adminRepository.GetMenuList(ctx)
 	if err != nil {
-		s.logger.WithContext(ctx).Error("GetMenuList error", zap.Error(err))
+		s.Logger.WithContext(ctx).Error("GetMenuList error", zap.Error(err))
 		return nil, err
 	}
 	data := &v1.GetMenuResponseData{

internal/service/aodun.go

@@ -183,7 +183,7 @@ func (s *aoDunService) AddWhiteStaticList(ctx context.Context, isSmall bool, req
 
 	if res.Code != 0 {
 		if strings.Contains(res.Msg, "操作部分成功，重复IP如下") {
-			s.logger.Info(res.Msg, zap.String("isSmall", strconv.FormatBool(isSmall)))
+			s.Logger.Info(res.Msg, zap.String("isSmall", strconv.FormatBool(isSmall)))
 			return nil
 		}
 		return fmt.Errorf("API 错误 (isSmall: %t): color %s,code %d, msg '%s'", isSmall, color, res.Code, res.Msg)

internal/service/gameshield.go → internal/service/api/gameShield/gameshield.go

@@ -1,4 +1,4 @@
-package service
+package gameShield
 
 import (
 	"context"
@@ -6,6 +6,7 @@ import (
 	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/go-nunu/nunu-layout-advanced/internal/service"
 	"github.com/spf13/viper"
 	"strconv"
 	"time"
@@ -22,16 +23,16 @@ type GameShieldService interface {
 }
 
 func NewGameShieldService(
-	service *Service,
+	service *service.Service,
 	gameShieldRepository repository.GameShieldRepository,
-	crawlerService CrawlerService,
-	gameShieldPublicIpService GameShieldPublicIpService,
-	duedate DuedateService,
-	formatter FormatterService,
-	parser ParserService,
-	required RequiredService,
+	crawlerService service.CrawlerService,
+	gameShieldPublicIpService service.GameShieldPublicIpService,
+	duedate service.DuedateService,
+	formatter service.FormatterService,
+	parser service.ParserService,
+	required service.RequiredService,
 	conf *viper.Viper,
-	gameShieldSdkIp GameShieldSdkIpService,
+	gameShieldSdkIp service.GameShieldSdkIpService,
 ) GameShieldService {
 	return &gameShieldService{
 		Service:                   service,
@@ -48,17 +49,17 @@ func NewGameShieldService(
 }
 
 type gameShieldService struct {
-	*Service
+	*service.Service
 	config                    *viper.Viper
-	crawlerService            CrawlerService
+	crawlerService            service.CrawlerService
 	gameShieldRepository      repository.GameShieldRepository
-	gameShieldPublicIpService GameShieldPublicIpService
-	duedate                   DuedateService
-	formatter                 FormatterService
+	gameShieldPublicIpService service.GameShieldPublicIpService
+	duedate                   service.DuedateService
+	formatter                 service.FormatterService
 	Url                       string
-	parser                    ParserService
-	required                  RequiredService
-	gameShieldSdkIp           GameShieldSdkIpService
+	parser                    service.ParserService
+	required                  service.RequiredService
+	gameShieldSdkIp           service.GameShieldSdkIpService
 }
 
 func (service *gameShieldService) SubmitGameShield(ctx context.Context, req *v1.GameShieldSubmitRequest) (string, error) {

internal/service/gameshieldbackend.go → internal/service/api/gameShield/gameshieldbackend.go

@@ -1,4 +1,4 @@
-package service
+package gameShield
 
 import (
 	"context"
@@ -7,6 +7,7 @@ import (
 	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/go-nunu/nunu-layout-advanced/internal/service"
 	"github.com/jinzhu/copier"
 	"github.com/spf13/cast"
 	"github.com/spf13/viper"
@@ -25,18 +26,18 @@ type GameShieldBackendService interface {
 }
 
 func NewGameShieldBackendService(
-	service *Service,
+	service *service.Service,
 	gameShieldBackendRepository repository.GameShieldBackendRepository,
 	gameShieldRepository repository.GameShieldRepository,
-	crawlerService CrawlerService,
-	gameShieldPublicIpService GameShieldPublicIpService,
-	duedate DuedateService,
-	formatter FormatterService,
-	parser ParserService,
-	required RequiredService,
+	crawlerService service.CrawlerService,
+	gameShieldPublicIpService service.GameShieldPublicIpService,
+	duedate service.DuedateService,
+	formatter service.FormatterService,
+	parser service.ParserService,
+	required service.RequiredService,
 	conf *viper.Viper,
 	shieldService GameShieldService,
-	hostService HostService,
+	hostService service.HostService,
 ) GameShieldBackendService {
 	return &gameShieldBackendService{
 		Service:                     service,
@@ -55,18 +56,18 @@ func NewGameShieldBackendService(
 }
 
 type gameShieldBackendService struct {
-	*Service
+	*service.Service
 	gameShieldBackendRepository repository.GameShieldBackendRepository
-	crawlerService              CrawlerService
+	crawlerService              service.CrawlerService
 	gameShieldRepository        repository.GameShieldRepository
-	gameShieldPublicIpService   GameShieldPublicIpService
-	duedate                     DuedateService
-	formatter                   FormatterService
+	gameShieldPublicIpService   service.GameShieldPublicIpService
+	duedate                     service.DuedateService
+	formatter                   service.FormatterService
 	Url                         string
-	parser                      ParserService
-	required                    RequiredService
-	shieldService               GameShieldService
-	hostService                 HostService
+	parser                      service.ParserService
+	required      service.RequiredService
+	shieldService GameShieldService
+	hostService   service.HostService
 }
 
 func (s *gameShieldBackendService) GetGameShieldRequired(ctx context.Context, req *v1.GameShieldBackendArrayRequest) (*v1.GetGameShieldRequiredResponse, int, error) {

internal/service/allowanddenyip.go → internal/service/api/waf/allowanddenyip.go

@@ -1,11 +1,12 @@
-package service
+package waf
 
 import (
-    "context"
+	"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/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
 )
 
 type AllowAndDenyIpService interface {
@@ -16,8 +17,8 @@ type AllowAndDenyIpService interface {
 	DeleteAllowAndDenyIps(ctx context.Context, req v1.DelAllowAndDenyIpRequest) error
 }
 func NewAllowAndDenyIpService(
-    service *Service,
-    allowAndDenyIpRepository repository.AllowAndDenyIpRepository,
+    service *service.Service,
+    allowAndDenyIpRepository waf.AllowAndDenyIpRepository,
 	wafformatter WafFormatterService,
 	gatewayIp GatewayipService,
 
@@ -31,10 +32,10 @@ func NewAllowAndDenyIpService(
 }
 
 type allowAndDenyIpService struct {
-	*Service
-	allowAndDenyIpRepository repository.AllowAndDenyIpRepository
-	wafformatter WafFormatterService
-	gatewayIp GatewayipService
+	*service.Service
+	allowAndDenyIpRepository waf.AllowAndDenyIpRepository
+	wafformatter             WafFormatterService
+	gatewayIp                GatewayipService
 }
 
 func (s *allowAndDenyIpService) GetAllowAndDenyIp(ctx context.Context, id int64) (*model.AllowAndDenyIp, error) {

internal/service/gatewayip.go → internal/service/api/waf/gatewayip.go

@@ -1,11 +1,12 @@
-package service
+package waf
 
 import (
 	"context"
 	"encoding/json"
 	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/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
 )
 
 type GatewayipService interface {
@@ -15,10 +16,10 @@ type GatewayipService interface {
 	AddIpWhereHostIdNull(ctx context.Context, hostId int64,uid int64) error
 }
 func NewGatewayipService(
-    service *Service,
-    gatewayipRepository repository.GatewayipRepository,
-	host HostService,
-	log LogService,
+    service *service.Service,
+    gatewayipRepository waf.GatewayipRepository,
+	host service.HostService,
+	log service.LogService,
 ) GatewayipService {
 	return &gatewayipService{
 		Service:        service,
@@ -29,10 +30,10 @@ func NewGatewayipService(
 }
 
 type gatewayipService struct {
-	*Service
-	gatewayipRepository repository.GatewayipRepository
-	host HostService
-	log LogService
+	*service.Service
+	gatewayipRepository waf.GatewayipRepository
+	host                service.HostService
+	log                 service.LogService
 }
 
 func (s *gatewayipService) GetGatewayip(ctx context.Context, id int64) (*model.Gatewayip, error) {

internal/service/globallimit.go → internal/service/api/waf/globallimit.go

@@ -1,4 +1,4 @@
-package service
+package waf
 
 import (
 	"context"
@@ -7,6 +7,8 @@ import (
 	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/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
 	"github.com/mozillazg/go-pinyin"
 	"github.com/spf13/viper"
 	"go.uber.org/zap"
@@ -26,26 +28,26 @@ type GlobalLimitService interface {
 }
 
 func NewGlobalLimitService(
-	service *Service,
-	globalLimitRepository repository.GlobalLimitRepository,
-	duedate DuedateService,
-	crawler CrawlerService,
+	service *service.Service,
+	globalLimitRepository waf.GlobalLimitRepository,
+	duedate service.DuedateService,
+	crawler service.CrawlerService,
 	conf *viper.Viper,
-	required RequiredService,
-	parser ParserService,
-	host HostService,
+	required service.RequiredService,
+	parser service.ParserService,
+	host service.HostService,
 	hostRep repository.HostRepository,
-	cdnService CdnService,
+	cdnService service.CdnService,
 	cdnRep repository.CdnRepository,
-	tcpforwardingRep repository.TcpforwardingRepository,
-	udpForWardingRep repository.UdpForWardingRepository,
-	webForWardingRep repository.WebForwardingRepository,
+	tcpforwardingRep waf.TcpforwardingRepository,
+	udpForWardingRep waf.UdpForWardingRepository,
+	webForWardingRep waf.WebForwardingRepository,
 	allowAndDeny AllowAndDenyIpService,
-	allowAndDenyRep repository.AllowAndDenyIpRepository,
+	allowAndDenyRep waf.AllowAndDenyIpRepository,
 	tcpforwarding TcpforwardingService,
 	udpForWarding UdpForWardingService,
 	webForWarding WebForwardingService,
-	gatewayIpRep repository.GatewayipRepository,
+	gatewayIpRep waf.GatewayipRepository,
 	gatywayIp GatewayipService,
 ) GlobalLimitService {
 	return &globalLimitService{
@@ -74,27 +76,27 @@ func NewGlobalLimitService(
 }
 
 type globalLimitService struct {
-	*Service
-	globalLimitRepository repository.GlobalLimitRepository
-	duedate               DuedateService
-	crawler               CrawlerService
+	*service.Service
+	globalLimitRepository waf.GlobalLimitRepository
+	duedate               service.DuedateService
+	crawler               service.CrawlerService
 	Url                   string
-	required              RequiredService
-	parser                ParserService
-	host                  HostService
+	required              service.RequiredService
+	parser                service.ParserService
+	host                  service.HostService
 	hostRep               repository.HostRepository
-	cdnService            CdnService
+	cdnService            service.CdnService
 	cdnRep                repository.CdnRepository
-	tcpforwardingRep      repository.TcpforwardingRepository
-	udpForWardingRep      repository.UdpForWardingRepository
-	webForWardingRep      repository.WebForwardingRepository
+	tcpforwardingRep      waf.TcpforwardingRepository
+	udpForWardingRep      waf.UdpForWardingRepository
+	webForWardingRep      waf.WebForwardingRepository
 	allowAndDeny          AllowAndDenyIpService
-	allowAndDenyRep       repository.AllowAndDenyIpRepository
-	tcpforwarding         TcpforwardingService
-	udpForWarding         UdpForWardingService
+	allowAndDenyRep waf.AllowAndDenyIpRepository
+	tcpforwarding   TcpforwardingService
+	udpForWarding UdpForWardingService
 	webForWarding         WebForwardingService
-	gatewayIpRep          repository.GatewayipRepository
-	gatewayIp 			GatewayipService
+	gatewayIpRep          waf.GatewayipRepository
+	gatewayIp             GatewayipService
 }
 
 func (s *globalLimitService) GetCdnUserId(ctx context.Context, uid int64) (int64, error) {
@@ -301,7 +303,7 @@ func (s *globalLimitService) AddGlobalLimit(ctx context.Context, req v1.GlobalLi
 	if planId == 0 {
 		// 安全冗余套餐
 		planId = 6
-		s.logger.Warn("获取套餐Id失败",  zap.String("节点区域", NodeAreaName), zap.String("防御阈值", require.ConfigMaxProtection),zap.Int64("套餐Id", int64(req.Uid)),zap.Int64("魔方套餐Id", int64(req.HostId)))
+		s.Logger.Warn("获取套餐Id失败",  zap.String("节点区域", NodeAreaName), zap.String("防御阈值", require.ConfigMaxProtection),zap.Int64("套餐Id", int64(req.Uid)),zap.Int64("魔方套餐Id", int64(req.HostId)))
 	}
 
 

internal/service/tcpforwarding.go → internal/service/api/waf/tcpforwarding.go

@@ -1,4 +1,4 @@
-package service
+package waf
 
 import (
 	"context"
@@ -7,6 +7,8 @@ import (
 	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/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
 	"golang.org/x/sync/errgroup"
 	"maps"
 	"net"
@@ -22,16 +24,16 @@ type TcpforwardingService interface {
 }
 
 func NewTcpforwardingService(
-	service *Service,
-	tcpforwardingRepository repository.TcpforwardingRepository,
-	parser ParserService,
-	required RequiredService,
-	crawler CrawlerService,
-	globalRep repository.GlobalLimitRepository,
+	service *service.Service,
+	tcpforwardingRepository waf.TcpforwardingRepository,
+	parser service.ParserService,
+	required service.RequiredService,
+	crawler service.CrawlerService,
+	globalRep waf.GlobalLimitRepository,
 	hostRep repository.HostRepository,
 	wafformatter WafFormatterService,
-	cdn CdnService,
-	proxy ProxyService,
+	cdn service.CdnService,
+	proxy service.ProxyService,
 ) TcpforwardingService {
 	return &tcpforwardingService{
 		Service:                 service,
@@ -48,16 +50,16 @@ func NewTcpforwardingService(
 }
 
 type tcpforwardingService struct {
-	*Service
-	tcpforwardingRepository repository.TcpforwardingRepository
-	parser                  ParserService
-	required                RequiredService
-	crawler                 CrawlerService
-	globalRep               repository.GlobalLimitRepository
-	hostRep      repository.HostRepository
+	*service.Service
+	tcpforwardingRepository waf.TcpforwardingRepository
+	parser                  service.ParserService
+	required                service.RequiredService
+	crawler                 service.CrawlerService
+	globalRep               waf.GlobalLimitRepository
+	hostRep                 repository.HostRepository
 	wafformatter WafFormatterService
-	cdn CdnService
-	proxy ProxyService
+	cdn          service.CdnService
+	proxy                   service.ProxyService
 }
 
 

internal/service/udpforwarding.go → internal/service/api/waf/udpforwarding.go

@@ -1,4 +1,4 @@
-package service
+package waf
 
 import (
 	"context"
@@ -7,6 +7,8 @@ import (
 	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/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
 	"golang.org/x/sync/errgroup"
 	"maps"
 	"net"
@@ -22,16 +24,16 @@ type UdpForWardingService interface {
 }
 
 func NewUdpForWardingService(
-	service *Service,
-	udpForWardingRepository repository.UdpForWardingRepository,
-	required RequiredService,
-	parser ParserService,
-	crawler CrawlerService,
-	globalRep repository.GlobalLimitRepository,
+	service *service.Service,
+	udpForWardingRepository waf.UdpForWardingRepository,
+	required service.RequiredService,
+	parser service.ParserService,
+	crawler service.CrawlerService,
+	globalRep waf.GlobalLimitRepository,
 	hostRep repository.HostRepository,
 	wafformatter WafFormatterService,
-	cdn CdnService,
-	proxy ProxyService,
+	cdn service.CdnService,
+	proxy service.ProxyService,
 ) UdpForWardingService {
 	return &udpForWardingService{
 		Service:                 service,
@@ -49,16 +51,16 @@ func NewUdpForWardingService(
 
 
 type udpForWardingService struct {
-	*Service
-	udpForWardingRepository repository.UdpForWardingRepository
-	required                RequiredService
-	parser                  ParserService
-	crawler                 CrawlerService
-	globalRep               repository.GlobalLimitRepository
-	hostRep      repository.HostRepository
+	*service.Service
+	udpForWardingRepository waf.UdpForWardingRepository
+	required                service.RequiredService
+	parser                  service.ParserService
+	crawler                 service.CrawlerService
+	globalRep               waf.GlobalLimitRepository
+	hostRep                 repository.HostRepository
 	wafformatter WafFormatterService
-	cdn CdnService
-	proxy ProxyService
+	cdn          service.CdnService
+	proxy                   service.ProxyService
 }
 
 

internal/service/wafformatter.go → internal/service/api/waf/wafformatter.go

@@ -1,4 +1,4 @@
-package service
+package waf
 
 import (
 	"context"
@@ -7,6 +7,8 @@ import (
 	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/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/rabbitmq"
 	amqp "github.com/rabbitmq/amqp091-go"
 	"go.uber.org/zap"
@@ -42,19 +44,19 @@ type WafFormatterService interface {
 }
 
 func NewWafFormatterService(
-	service *Service,
-	globalRep repository.GlobalLimitRepository,
+	service *service.Service,
+	globalRep waf.GlobalLimitRepository,
 	hostRep repository.HostRepository,
-	required RequiredService,
-	parser ParserService,
-	tcpforwardingRep repository.TcpforwardingRepository,
-	udpForWardingRep repository.UdpForWardingRepository,
-	webForwardingRep repository.WebForwardingRepository,
+	required service.RequiredService,
+	parser service.ParserService,
+	tcpforwardingRep waf.TcpforwardingRepository,
+	udpForWardingRep waf.UdpForWardingRepository,
+	webForwardingRep waf.WebForwardingRepository,
 	mq *rabbitmq.RabbitMQ,
-	host HostService,
-	gatewayIpRep repository.GatewayipRepository,
+	host service.HostService,
+	gatewayIpRep waf.GatewayipRepository,
 	gatewayIp GatewayipService,
-	cdn CdnService,
+	cdn service.CdnService,
 ) WafFormatterService {
 	return &wafFormatterService{
 		Service:           service,
@@ -74,19 +76,19 @@ func NewWafFormatterService(
 }
 
 type wafFormatterService struct {
-	*Service
-	globalRep         repository.GlobalLimitRepository
-	hostRep           repository.HostRepository
-	required          RequiredService
-	parser            ParserService
-	tcpforwardingRep  repository.TcpforwardingRepository
-	udpForWardingRep  repository.UdpForWardingRepository
-	webForwardingRep  repository.WebForwardingRepository
-	host              HostService
-	mq                *rabbitmq.RabbitMQ
-	gatewayIpRep      repository.GatewayipRepository
-	cdn               CdnService
-	gatewayIp GatewayipService
+	*service.Service
+	globalRep        waf.GlobalLimitRepository
+	hostRep          repository.HostRepository
+	required         service.RequiredService
+	parser           service.ParserService
+	tcpforwardingRep waf.TcpforwardingRepository
+	udpForWardingRep waf.UdpForWardingRepository
+	webForwardingRep waf.WebForwardingRepository
+	host             service.HostService
+	mq               *rabbitmq.RabbitMQ
+	gatewayIpRep     waf.GatewayipRepository
+	cdn              service.CdnService
+	gatewayIp        GatewayipService
 }
 
 type RequireResponse struct {
@@ -183,7 +185,7 @@ func (s *wafFormatterService) ConvertToWildcardDomain(ctx context.Context, domai
 	}
 	registrableDomain, err := publicsuffix.EffectiveTLDPlusOne(domain)
 	if err != nil {
-		s.logger.Error("无效的域名", zap.String("domain", domain), zap.Error(err))
+		s.Logger.Error("无效的域名", zap.String("domain", domain), zap.Error(err))
 		// 如果域名无效（如 IP 地址、localhost），则返回错误。
 		return "", nil
 	}
@@ -259,14 +261,14 @@ func (s *wafFormatterService) PublishDomainWhitelistTask(domain, ip, action stri
 	// Serialize the message
 	msgBody, err := json.Marshal(payload)
 	if err != nil {
-		s.logger.Error("Failed to serialize domain whitelist task message", zap.Error(err), zap.String("domain", domain), zap.String("ip", ip), zap.String("action", action))
+		s.Logger.Error("Failed to serialize domain whitelist task message", zap.Error(err), zap.String("domain", domain), zap.String("ip", ip), zap.String("action", action))
 		return
 	}
 
 	// Get task configuration
 	taskCfg, ok := s.mq.GetTaskConfig("domain_whitelist")
 	if !ok {
-		s.logger.Error("Failed to get 'domain_whitelist' task configuration")
+		s.Logger.Error("Failed to get 'domain_whitelist' task configuration")
 		return
 	}
 
@@ -283,9 +285,9 @@ func (s *wafFormatterService) PublishDomainWhitelistTask(domain, ip, action stri
 	// Publish the message
 	err = s.mq.PublishWithCh(taskCfg.Exchange, routingKey, publishingMsg)
 	if err != nil {
-		s.logger.Error("发布 域名 白名单任务到 MQ 失败", zap.Error(err), zap.String("domain", domain), zap.String("action", action))
+		s.Logger.Error("发布 域名 白名单任务到 MQ 失败", zap.Error(err), zap.String("domain", domain), zap.String("action", action))
 	} else {
-		s.logger.Info("成功将 域名 白名单任务发布到 MQ", zap.String("domain", domain), zap.String("action", action))
+		s.Logger.Info("成功将 域名 白名单任务发布到 MQ", zap.String("domain", domain), zap.String("action", action))
 	}
 }
 
@@ -307,14 +309,14 @@ func (s *wafFormatterService) PublishIpWhitelistTask(ips []string, action string
 	// Serialize the message
 	msgBody, err := json.Marshal(payload)
 	if err != nil {
-		s.logger.Error("序列化 IP 白名单任务消息失败", zap.Error(err), zap.Any("IPs", ips), zap.String("action", action), zap.String("color", color))
+		s.Logger.Error("序列化 IP 白名单任务消息失败", zap.Error(err), zap.Any("IPs", ips), zap.String("action", action), zap.String("color", color))
 		return
 	}
 
 	// Get task configuration
 	taskCfg, ok := s.mq.GetTaskConfig("ip_white")
 	if !ok {
-		s.logger.Error("无法获取“ip_white”任务配置")
+		s.Logger.Error("无法获取“ip_white”任务配置")
 		return
 	}
 
@@ -331,9 +333,9 @@ func (s *wafFormatterService) PublishIpWhitelistTask(ips []string, action string
 	// Publish the message
 	err = s.mq.PublishWithCh(taskCfg.Exchange, routingKey, publishingMsg)
 	if err != nil {
-		s.logger.Error("发布 IP 白名单任务到 MQ 失败", zap.Error(err), zap.String("action", action), zap.String("color", color))
+		s.Logger.Error("发布 IP 白名单任务到 MQ 失败", zap.Error(err), zap.String("action", action), zap.String("color", color))
 	} else {
-		s.logger.Info("成功将 IP 白名单任务发布到 MQ", zap.String("action", action), zap.String("color", color))
+		s.Logger.Info("成功将 IP 白名单任务发布到 MQ", zap.String("action", action), zap.String("color", color))
 	}
 }
 

internal/service/webforwarding.go → internal/service/api/waf/webforwarding.go

@@ -1,4 +1,4 @@
-package service
+package waf
 
 import (
 	"context"
@@ -6,7 +6,8 @@ import (
 	"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/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
 	"github.com/go-nunu/nunu-layout-advanced/pkg/rabbitmq"
 	"golang.org/x/sync/errgroup"
 	"maps"
@@ -23,20 +24,20 @@ type WebForwardingService interface {
 }
 
 func NewWebForwardingService(
-	service *Service,
-	required RequiredService,
-	webForwardingRepository repository.WebForwardingRepository,
-	crawler CrawlerService,
-	parser ParserService,
+	service *service.Service,
+	required service.RequiredService,
+	webForwardingRepository waf.WebForwardingRepository,
+	crawler service.CrawlerService,
+	parser service.ParserService,
 	wafformatter WafFormatterService,
-	aoDun AoDunService,
+	aoDun service.AoDunService,
 	mq *rabbitmq.RabbitMQ,
 	gatewayIp GatewayipService,
-	globalLimitRep repository.GlobalLimitRepository,
-	cdn CdnService,
-	proxy ProxyService,
-	sslCert SslCertService,
-	websocket WebsocketService,
+	globalLimitRep waf.GlobalLimitRepository,
+	cdn service.CdnService,
+	proxy service.ProxyService,
+	sslCert service.SslCertService,
+	websocket service.WebsocketService,
 ) WebForwardingService {
 	return &webForwardingService{
 		Service:                 service,
@@ -64,20 +65,20 @@ const (
 )
 
 type webForwardingService struct {
-	*Service
-	webForwardingRepository repository.WebForwardingRepository
-	required                RequiredService
-	parser                  ParserService
-	crawler                 CrawlerService
+	*service.Service
+	webForwardingRepository waf.WebForwardingRepository
+	required                service.RequiredService
+	parser                  service.ParserService
+	crawler                 service.CrawlerService
 	wafformatter            WafFormatterService
-	aoDun                   AoDunService
+	aoDun                   service.AoDunService
 	mq                      *rabbitmq.RabbitMQ
 	gatewayIp               GatewayipService
-	cdn                     CdnService
-	globalLimitRep          repository.GlobalLimitRepository
-	proxy                   ProxyService
-	sslCert                 SslCertService
-	websocket               WebsocketService
+	cdn                     service.CdnService
+	globalLimitRep          waf.GlobalLimitRepository
+	proxy                   service.ProxyService
+	sslCert                 service.SslCertService
+	websocket               service.WebsocketService
 }
 
 func (s *webForwardingService) require(ctx context.Context, req v1.GlobalRequire) (v1.GlobalRequire, error) {

internal/service/cc.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
 	"time"
 )
 
@@ -15,7 +16,7 @@ type CcService interface {
 func NewCcService(
     service *Service,
     ccRepository repository.CcRepository,
-	webForwardingRep repository.WebForwardingRepository,
+	webForwardingRep waf.WebForwardingRepository,
 	cdn CdnService,
 ) CcService {
 	return &ccService{
@@ -28,9 +29,9 @@ func NewCcService(
 
 type ccService struct {
 	*Service
-	ccRepository repository.CcRepository
-	webForwardingRep repository.WebForwardingRepository
-	cdn CdnService
+	ccRepository     repository.CcRepository
+	webForwardingRep waf.WebForwardingRepository
+	cdn              CdnService
 }
 
 func (s *ccService) GetCcList(ctx context.Context, req v1.CCListRequest) ([]v1.CCListResponse, error) {

internal/service/service.go

@@ -8,7 +8,7 @@ import (
 )
 
 type Service struct {
-	logger *log.Logger
+	Logger *log.Logger
 	sid    *sid.Sid
 	jwt    *jwt.JWT
 	tm     repository.Transaction
@@ -21,7 +21,7 @@ func NewService(
 	jwt *jwt.JWT,
 ) *Service {
 	return &Service{
-		logger: logger,
+		Logger: logger,
 		sid:    sid,
 		jwt:    jwt,
 		tm:     tm,

internal/service/sslcert.go

@@ -7,7 +7,7 @@ import (
 	"encoding/json"
 	"fmt"
 	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
-	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
 )
 
 type SslCertService interface {
@@ -19,7 +19,7 @@ type SslCertService interface {
 }
 func NewSslCertService(
     service *Service,
-   	webForwardingRep repository.WebForwardingRepository,
+   	webForwardingRep waf.WebForwardingRepository,
 	cdn CdnService,
 ) SslCertService {
 	return &sslCertService{
@@ -31,8 +31,8 @@ func NewSslCertService(
 
 type sslCertService struct {
 	*Service
-	webForwardingRep repository.WebForwardingRepository
-	cdn CdnService
+	webForwardingRep waf.WebForwardingRepository
+	cdn              CdnService
 }
 
 func (s *sslCertService) ParseCert(ctx context.Context, httpsCert string, httpKey string) (serverName string, commonName []string, DNSNames []string, before int64, after int64, isSelfSigned bool, err error) {

internal/service/websocket.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
-	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
 )
 
 type WebsocketService interface {
@@ -14,7 +14,7 @@ type WebsocketService interface {
 func NewWebsocketService(
     service *Service,
 	cdn CdnService,
-	webForwardingRep repository.WebForwardingRepository,
+	webForwardingRep waf.WebForwardingRepository,
 ) WebsocketService {
 	return &websocketService{
 		Service:        service,
@@ -25,8 +25,8 @@ func NewWebsocketService(
 
 type websocketService struct {
 	*Service
-	cdn CdnService
-	webForwardingRep repository.WebForwardingRepository
+	cdn              CdnService
+	webForwardingRep waf.WebForwardingRepository
 }
 
 func (s *websocketService) AddWebsocket(ctx context.Context) (int64, error) {

internal/task/gameShield.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
-	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/gameShield"
 	"go.uber.org/zap"
 	"strconv"
 	"time"
@@ -18,7 +18,7 @@ type GameShieldTask interface {
 func NewGameShieldTask(
 	task *Task,
 	gameShieldRepo repository.GameShieldRepository,
-	gameShieldBackendService service.GameShieldBackendService,
+	gameShieldBackendService gameShield.GameShieldBackendService,
 
 ) GameShieldTask {
 	return &gameShieldTask{
@@ -31,7 +31,7 @@ func NewGameShieldTask(
 type gameShieldTask struct {
 	*Task
 	gameShieldRepo           repository.GameShieldRepository
-	gameShieldBackendService service.GameShieldBackendService
+	gameShieldBackendService gameShield.GameShieldBackendService
 }
 
 // 检查已过期的记录

internal/task/waf.go

@@ -6,7 +6,9 @@ import (
 	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"
+	waf2 "github.com/go-nunu/nunu-layout-advanced/internal/repository/api/waf"
 	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service/api/waf"
 	"github.com/hashicorp/go-multierror"
 	"go.uber.org/zap"
 	"sync"
@@ -32,18 +34,18 @@ type WafTask interface {
 // =================================================================
 
 func NewWafTask(
-	webForWardingRep repository.WebForwardingRepository,
-	tcpforwardingRep repository.TcpforwardingRepository,
-	udpForWardingRep repository.UdpForWardingRepository,
+	webForWardingRep waf2.WebForwardingRepository,
+	tcpforwardingRep waf2.TcpforwardingRepository,
+	udpForWardingRep waf2.UdpForWardingRepository,
 	cdn service.CdnService,
 	hostRep repository.HostRepository,
-	globalLimitRep repository.GlobalLimitRepository,
+	globalLimitRep waf2.GlobalLimitRepository,
 	expiredRep repository.ExpiredRepository,
 	task *Task,
-	gatewayIpRep repository.GatewayipRepository,
-	tcp service.TcpforwardingService,
-	udp service.UdpForWardingService,
-	web service.WebForwardingService,
+	gatewayIpRep waf2.GatewayipRepository,
+	tcp waf.TcpforwardingService,
+	udp waf.UdpForWardingService,
+	web waf.WebForwardingService,
 ) WafTask {
 	return &wafTask{
 		Task:              task,
@@ -63,17 +65,17 @@ func NewWafTask(
 
 type wafTask struct {
 	*Task
-	webForWardingRep  repository.WebForwardingRepository
-	tcpforwardingRep  repository.TcpforwardingRepository
-	udpForWardingRep  repository.UdpForWardingRepository
-	cdn               service.CdnService
-	hostRep           repository.HostRepository
-	globalLimitRep    repository.GlobalLimitRepository
-	expiredRep        repository.ExpiredRepository
-	gatewayIpRep      repository.GatewayipRepository
-	tcp               service.TcpforwardingService
-	udp               service.UdpForWardingService
-	web               service.WebForwardingService
+	webForWardingRep waf2.WebForwardingRepository
+	tcpforwardingRep waf2.TcpforwardingRepository
+	udpForWardingRep waf2.UdpForWardingRepository
+	cdn              service.CdnService
+	hostRep          repository.HostRepository
+	globalLimitRep   waf2.GlobalLimitRepository
+	expiredRep       repository.ExpiredRepository
+	gatewayIpRep     waf2.GatewayipRepository
+	tcp              waf.TcpforwardingService
+	udp waf.UdpForWardingService
+	web waf.WebForwardingService
 }
 
 const (