refactor(service): 重构 TCP/UDP/Web 转发服务- 提取通用的 formData 构建逻辑

- 创建统一的 WafFormatterService 接口
- 优化代码结构，提高可维护性和可测试性
- 修复 UDP 转发中的会话超时设置问题

api/v1/tcpForwarding.go

@@ -1,6 +1,7 @@
 package v1
 
 type TcpForwardingData struct {
+	Id                int    `form:"id" json:"id"`
 	WafTcpId          int    `form:"waf_tcp_id" json:"waf_tcp_id"`
 	Tag               string `form:"tag" json:"tag" binding:"required"`
 	Port              int    `form:"port" json:"port" binding:"required"`
@@ -24,6 +25,7 @@ type DeleteTcpForwardingRequest struct {
 }
 
 type TcpForwardingRequest struct {
+	Id                int `form:"id" json:"id"`
 	HostId            int `form:"host_id" json:"host_id" binding:"required"`
 	Uid               int `form:"uid" json:"uid" binding:"required"`
 	TcpForwardingData TcpForwardingData

api/v1/udpForwarding.go

@@ -12,7 +12,7 @@ type UdpForwardingData struct {
 	CcDuration        string `form:"cc_duration" json:"cc_duration" default:"0s"`
 	CcBlockCount      int    `form:"cc_block_count" json:"cc_block_count" default:"0"`
 	CcBlockDuration   string `form:"cc_block_duration" json:"cc_block_duration" default:"0s"`
-	SessionTimeout    int    `form:"session_timeout" json:"session_timeout" default:"0s"`
+	SessionTimeout    string    `form:"session_timeout" json:"session_timeout" default:"60s"`
 	BackendList       string `form:"backend_list" json:"backend_list"`
 	AllowIpList       string `form:"allow_ip_list" json:"allow_ip_list"`
 	DenyIpList        string `form:"deny_ip_list" json:"deny_ip_list"`
@@ -27,6 +27,7 @@ type DeleteUdpForwardingRequest struct {
 type UdpForwardingRequest struct {
 	HostId            int `form:"host_id" json:"host_id" binding:"required"`
 	Uid               int `form:"uid" json:"uid" binding:"required"`
+	Id                int `form:"id" json:"id"`
 	UdpForwardingData UdpForwardingData
 }
 

api/v1/webForwarding.go

@@ -33,6 +33,7 @@ type DeleteWebForwardingRequest struct {
 }
 
 type WebForwardingRequest struct {
+	Id                 int    `form:"id" json:"id"`
 	HostId            int `form:"host_id" json:"host_id" binding:"required"`
 	Uid               int `form:"uid" json:"uid" binding:"required"`
 	WebForwardingData WebForwardingData

cmd/server/wire/wire_gen.go

@@ -58,7 +58,7 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*app.App, func(), err
 	gameShieldBackendHandler := handler.NewGameShieldBackendHandler(handlerHandler, gameShieldBackendService)
 	webForwardingRepository := repository.NewWebForwardingRepository(repositoryRepository)
 	globalLimitRepository := repository.NewGlobalLimitRepository(repositoryRepository)
-	wafFormatterService := service.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository)
+	wafFormatterService := service.NewWafFormatterService(serviceService, globalLimitRepository, hostRepository, requiredService, parserService)
 	webForwardingService := service.NewWebForwardingService(serviceService, requiredService, webForwardingRepository, crawlerService, parserService, wafFormatterService)
 	webForwardingHandler := handler.NewWebForwardingHandler(handlerHandler, webForwardingService)
 	webLimitRepository := repository.NewWebLimitRepository(repositoryRepository)

internal/service/tcpforwarding.go

@@ -2,11 +2,9 @@ package service
 
 import (
 	"context"
-	"fmt"
 	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
 	"github.com/go-nunu/nunu-layout-advanced/internal/model"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
-	"github.com/spf13/cast"
 	"strconv"
 )
 
@@ -62,6 +60,43 @@ func (s *tcpforwardingService) require(ctx context.Context,req v1.GlobalRequire)
 	return res, nil
 }
 
+func (s *tcpforwardingService) buildWafFormData(req *v1.TcpForwardingData, require v1.GlobalRequire) map[string]interface{} {
+	return map[string]interface{}{
+		"tag":                  require.Tag,
+		"port":                 req.Port,
+		"waf_gateway_group_id": require.WafGatewayGroupId,
+		"waf_tcp_limit_id": 	require.LimitRuleId,
+		"cc_count":             req.CcCount,
+		"cc_duration":          req.CcDuration,
+		"cc_block_count":       req.CcBlockCount,
+		"cc_block_duration":    req.CcBlockDuration,
+		"backend_protocol":     req.BackendProtocol,
+		"backend_timeout":      req.BackendTimeout,
+		"comment":              req.Comment,
+		"backend_list":         req.BackendList,
+		"allow_ip_list":        req.AllowIpList,
+		"deny_ip_list":         req.DenyIpList,
+		"access_rule":          req.AccessRule,
+	}
+}
+
+func (s *tcpforwardingService) buildTcpForwardingModel(req *v1.TcpForwardingData, ruleId int, require v1.GlobalRequire) *model.Tcpforwarding {
+	return &model.Tcpforwarding{
+		HostId:  require.HostId,
+		RuleId: ruleId,
+		Port: strconv.Itoa(req.Port),
+		Tag:     require.Tag,
+		Comment: req.Comment,
+		WafGatewayGroupId: require.WafGatewayGroupId,
+		CcCount: req.CcCount,
+		CcDuration: req.CcDuration,
+		CcBlockCount: req.CcBlockCount,
+		CcBlockDuration: req.CcBlockDuration,
+		BackendProtocol: req.BackendProtocol,
+		BackendTimeout: req.BackendTimeout,
+	}
+}
+
 func (s *tcpforwardingService) AddTcpForwarding(ctx context.Context, req *v1.TcpForwardingRequest)  error {
 	require, err := s.require(ctx, v1.GlobalRequire{
 		HostId: req.HostId,
@@ -71,58 +106,15 @@ func (s *tcpforwardingService) AddTcpForwarding(ctx context.Context, req *v1.Tcp
 	if err != nil {
 		return  err
 	}
-	formData := map[string]interface{}{
-		"tag":                  require.Tag,
-		"port":                 req.TcpForwardingData.Port,
-		"waf_gateway_group_id": require.WafGatewayGroupId,
-		"waf_tcp_limit_id": 	require.LimitRuleId,
-		"cc_count":             req.TcpForwardingData.CcCount,
-		"cc_duration":          req.TcpForwardingData.CcDuration,
-		"cc_block_count":       req.TcpForwardingData.CcBlockCount,
-		"cc_block_duration":    req.TcpForwardingData.CcBlockDuration,
-		"backend_protocol":     req.TcpForwardingData.BackendProtocol,
-		"backend_timeout":      req.TcpForwardingData.BackendTimeout,
-		"comment":              req.TcpForwardingData.Comment,
-		"backend_list":         req.TcpForwardingData.BackendList,
-		"allow_ip_list":        req.TcpForwardingData.AllowIpList,
-		"deny_ip_list":         req.TcpForwardingData.DenyIpList,
-		"access_rule":          req.TcpForwardingData.AccessRule,
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp/new", "admin/new/waf_tcp", formData)
-	if err != nil {
-		return err
-	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
-	if err != nil {
-		return err
-	}
-	if res != "" {
-		return fmt.Errorf(res)
-	}
-	wafTcpIdStr, err := s.parser.GetRuleId(ctx, respBody)
-	if err != nil {
-		return err
-	}
-	wafTcpId, err := cast.ToIntE(wafTcpIdStr)
+	formData := s.buildWafFormData(&req.TcpForwardingData, require)
+	wafTcpId, err := s.wafformatter.sendFormData(ctx, "admin/info/waf_tcp/new", "admin/new/waf_tcp", formData)
 	if err != nil {
 		return err
 	}
 
-	if err = s.tcpforwardingRepository.AddTcpforwarding(ctx, &model.Tcpforwarding{
-		HostId:  req.HostId,
-		RuleId: wafTcpId,
-		Port: strconv.Itoa(req.TcpForwardingData.Port),
-		Tag:     require.Tag,
-		Comment: req.TcpForwardingData.Comment,
-		WafGatewayGroupId: require.WafGatewayGroupId,
-		CcCount: req.TcpForwardingData.CcCount,
-		CcDuration: req.TcpForwardingData.CcDuration,
-		CcBlockCount: req.TcpForwardingData.CcBlockCount,
-		CcBlockDuration: req.TcpForwardingData.CcBlockDuration,
-		BackendProtocol: req.TcpForwardingData.BackendProtocol,
-		BackendTimeout: req.TcpForwardingData.BackendTimeout,
-	}) ; err != nil {
+	tcpModel := s.buildTcpForwardingModel(&req.TcpForwardingData, wafTcpId, require)
+
+	if err = s.tcpforwardingRepository.AddTcpforwarding(ctx, tcpModel); err != nil {
 		return err
 	}
 	return  nil
@@ -137,35 +129,17 @@ func (s *tcpforwardingService) EditTcpForwarding(ctx context.Context, req *v1.Tc
 	if err != nil {
 		return "", err
 	}
-	formData := map[string]interface{}{
-		"tag":                  require.Tag,
-		"port":                 req.TcpForwardingData.Port,
-		"waf_gateway_group_id": require.WafGatewayGroupId,
-		"waf_tcp_limit_id": 	require.LimitRuleId,
-		"cc_count":             req.TcpForwardingData.CcCount,
-		"cc_duration":          req.TcpForwardingData.CcDuration,
-		"cc_block_count":       req.TcpForwardingData.CcBlockCount,
-		"cc_block_duration":    req.TcpForwardingData.CcBlockDuration,
-		"backend_protocol":     req.TcpForwardingData.BackendProtocol,
-		"backend_timeout":      req.TcpForwardingData.BackendTimeout,
-		"comment":              req.TcpForwardingData.Comment,
-		"backend_list":         req.TcpForwardingData.BackendList,
-		"allow_ip_list":        req.TcpForwardingData.AllowIpList,
-		"deny_ip_list":         req.TcpForwardingData.DenyIpList,
-		"access_rule":          req.TcpForwardingData.AccessRule,
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp/edit?&__goadmin_edit_pk="+strconv.Itoa(req.TcpForwardingData.WafTcpId), "admin/edit/waf_tcp", formData)
+	formData := s.buildWafFormData(&req.TcpForwardingData, require)
+	_, err = s.wafformatter.sendFormData(ctx, "admin/info/waf_tcp/edit?&__goadmin_edit_pk="+strconv.Itoa(req.TcpForwardingData.WafTcpId), "admin/edit/waf_tcp", formData)
 	if err != nil {
 		return "", err
 	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
-	if err != nil {
+
+	tcpModel := s.buildTcpForwardingModel(&req.TcpForwardingData, req.TcpForwardingData.WafTcpId, require)
+	tcpModel.Id = req.Id
+	if err = s.tcpforwardingRepository.EditTcpforwarding(ctx, tcpModel); err != nil {
 		return "", err
 	}
-	if res != "" {
-		return "", fmt.Errorf(res)
-	}
 	return "", nil
 }
 

internal/service/udpforwarding.go

@@ -2,7 +2,7 @@ package service
 
 import (
 	"context"
-	"fmt"
+	"github.com/davecgh/go-spew/spew"
 	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"
@@ -61,69 +61,89 @@ func (s *udpForWardingService) GetUdpForWarding(ctx context.Context, id int64) (
 	return s.udpForWardingRepository.GetUdpForWarding(ctx, id)
 }
 
+func (s *udpForWardingService) buildWafFormData(req *v1.UdpForwardingData, require v1.GlobalRequire) map[string]interface{} {
+	return map[string]interface{}{
+		"tag":               require.Tag,
+		"port":              req.Port,
+		"waf_gateway_group_id": require.WafGatewayGroupId,
+		"waf_udp_limit_id":     require.LimitRuleId,
+		"cc_packet_count":      req.CcPacketCount,
+		"cc_packet_duration":   req.CcPacketDuration,
+		"cc_count":             req.CcCount,
+		"cc_duration":          req.CcDuration,
+		"cc_block_count":       req.CcBlockCount,
+		"cc_block_duration":    req.CcBlockDuration,
+		"session_timeout":      req.SessionTimeout,
+		"backend_list":         req.BackendList,
+		"allow_ip_list":        req.AllowIpList,
+		"deny_ip_list":         req.DenyIpList,
+		"access_rule":          req.AccessRule,
+		"comment":              req.Comment,
+	}
+}
+
+func (s *udpForWardingService) buildUdpForwardingModel(req *v1.UdpForwardingData, ruleId int, require v1.GlobalRequire) *model.UdpForWarding {
+	return &model.UdpForWarding{
+		HostId: 			  require.HostId,
+		RuleId:               ruleId,
+		Tag:                  require.Tag,
+		Port:                 strconv.Itoa(req.Port),
+		WafGatewayGroupId:    require.WafGatewayGroupId,
+		UdpLimitRuleId:       require.LimitRuleId,
+		CcPacketCount:        req.CcPacketCount,
+		CcPacketDuration:     req.CcPacketDuration,
+		CcPacketBlockCount:   req.CcBlockCount,
+		CcPacketBlockDuration: req.CcBlockDuration,
+		CcCount:              req.CcCount,
+		CcDuration:           req.CcDuration,
+		CcBlockCount:         req.CcBlockCount,
+		CcBlockDuration:      req.CcBlockDuration,
+		SessionTimeout:       req.SessionTimeout,
+		Comment:              req.Comment,
+	}
+}
+
 func (s *udpForWardingService) AddUdpForwarding(ctx context.Context, req *v1.UdpForwardingRequest) (string, error) {
 	require, err := s.require(ctx, v1.GlobalRequire{
 		HostId: req.HostId,
 		Uid:    req.Uid,
 		Comment: req.UdpForwardingData.Comment,
 	})
+	spew.Dump(require)
 	if err != nil {
 		return "", err
 	}
-	formData := map[string]interface{}{
-		"tag":               require.Tag,
-		"port":              req.UdpForwardingData.Port,
-		"waf_gateway_group_id": require.WafGatewayGroupId,
-		"waf_udp_limit_id":     require.LimitRuleId,
-		"cc_packet_count":      req.UdpForwardingData.CcPacketCount,
-		"cc_packet_duration":   req.UdpForwardingData.CcPacketDuration,
-		"cc_count":             req.UdpForwardingData.CcCount,
-		"cc_duration":          req.UdpForwardingData.CcDuration,
-		"cc_block_count":       req.UdpForwardingData.CcBlockCount,
-		"cc_block_duration":    req.UdpForwardingData.CcBlockDuration,
-		"session_timeout":      req.UdpForwardingData.SessionTimeout,
-		"backend_list":         req.UdpForwardingData.BackendList,
-		"allow_ip_list":        req.UdpForwardingData.AllowIpList,
-		"deny_ip_list":         req.UdpForwardingData.DenyIpList,
-		"access_rule":          req.UdpForwardingData.AccessRule,
-		"comment":              req.UdpForwardingData.Comment,
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_udp/new", "admin/new/waf_udp", formData)
-	if err != nil {
-		return "", err
-	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
+	formData := s.buildWafFormData(&req.UdpForwardingData, require)
+	wafUdpId, err := s.wafformatter.sendFormData(ctx, "admin/info/waf_udp/new", "admin/new/waf_udp", formData)
 	if err != nil {
 		return "", err
 	}
-	if res != "" {
-		return "", fmt.Errorf(res)
-	}
-
-	wafUdpId, err := s.parser.GetRuleId(ctx, respBody)
-	if err != nil {
+	udpModel := s.buildUdpForwardingModel(&req.UdpForwardingData, wafUdpId, require)
+	if err := s.udpForWardingRepository.AddUdpForwarding(ctx, udpModel); err != nil {
 		return "", err
 	}
-	fmt.Println("=================================================", wafUdpId)
 	return "", nil
 }
 
 func (s *udpForWardingService) EditUdpForwarding(ctx context.Context, req *v1.UdpForwardingRequest) (string, error) {
-	formData := map[string]interface{}{
-
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_udp/edit?&__goadmin_edit_pk="+strconv.Itoa(req.UdpForwardingData.WafUdpId), "admin/edit/waf_udp", formData)
+	require, err := s.require(ctx, v1.GlobalRequire{
+		HostId: req.HostId,
+		Uid:    req.Uid,
+		Comment: req.UdpForwardingData.Comment,
+	})
 	if err != nil {
 		return "", err
 	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
+	formData := s.buildWafFormData(&req.UdpForwardingData, require)
+	_, err = s.wafformatter.sendFormData(ctx, "admin/info/waf_udp/edit?&__goadmin_edit_pk="+strconv.Itoa(req.UdpForwardingData.WafUdpId), "admin/edit/waf_udp", formData)
 	if err != nil {
 		return "", err
 	}
-	if res != "" {
-		return "", fmt.Errorf(res)
+
+	udpMdel := s.buildUdpForwardingModel(&req.UdpForwardingData, req.UdpForwardingData.WafUdpId, require)
+	udpMdel.Id = req.Id
+	if err := s.udpForWardingRepository.EditUdpForwarding(ctx, udpMdel); err != nil {
+		return "", err
 	}
 	return "", nil
 }

internal/service/wafformatter.go

@@ -2,24 +2,31 @@ package service
 
 import (
 	"context"
+	"fmt"
 	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"github.com/spf13/cast"
 
 	"strconv"
 )
 
 type WafFormatterService interface {
 	require(ctx context.Context, req v1.GlobalRequire, category string) (v1.GlobalRequire, error)
+	sendFormData(ctx context.Context,addTokenUrl string,addSendUrl string,formData map[string]interface{}) (int, error)
 }
 func NewWafFormatterService(
     service *Service,
 	globalRep repository.GlobalLimitRepository,
 	hostRep repository.HostRepository,
+	required RequiredService,
+	parser ParserService,
 ) WafFormatterService {
 	return &wafFormatterService{
 		Service:        service,
 		globalRep: globalRep,
 		hostRep: hostRep,
+		required: required,
+		parser: parser,
 	}
 }
 
@@ -27,6 +34,8 @@ type wafFormatterService struct {
 	*Service
 	globalRep repository.GlobalLimitRepository
 	hostRep repository.HostRepository
+	required RequiredService
+	parser ParserService
 }
 
 func (s *wafFormatterService) require(ctx context.Context,req v1.GlobalRequire,category string) (v1.GlobalRequire, error) {
@@ -49,4 +58,28 @@ func (s *wafFormatterService) require(ctx context.Context,req v1.GlobalRequire,c
 	}
 	req.Tag = strconv.Itoa(req.Uid) + "_" + strconv.Itoa(req.HostId) + "_" + domain + "_" + req.Comment
 	return req, nil
+}
+
+func (s *wafFormatterService) sendFormData(ctx context.Context,addTokenUrl string,addSendUrl string,formData map[string]interface{}) (int, error) {
+	respBody, err := s.required.SendForm(ctx, addTokenUrl, addSendUrl, formData)
+	if err != nil {
+		return 0, err
+	}
+	// 解析响应内容中的 alert 消息
+	res, err := s.parser.ParseAlert(string(respBody))
+	if err != nil {
+		return 0,err
+	}
+	if res != "" {
+		return 0,fmt.Errorf(res)
+	}
+	ruleIdStr, err := s.parser.GetRuleIdByColumnName(ctx, respBody,formData["tag"].(string))
+	if err != nil {
+		return 0, err
+	}
+	ruleId, err := cast.ToIntE(ruleIdStr)
+	if err != nil {
+		return 0,err
+	}
+	return ruleId, nil
 }

internal/service/webforwarding.go

@@ -2,7 +2,6 @@ package service
 
 import (
 	"context"
-	"fmt"
 	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
 	"github.com/go-nunu/nunu-layout-advanced/internal/model"
 	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
@@ -55,6 +54,65 @@ func (s *webForwardingService) GetWebForwarding(ctx context.Context, id int64) (
 	return s.webForwardingRepository.GetWebForwarding(ctx, id)
 }
 
+// buildWafFormData 辅助函数，用于构建通用的 formData
+func (s *webForwardingService) buildWafFormData(req *v1.WebForwardingData, require v1.GlobalRequire) map[string]interface{} {
+	return map[string]interface{}{
+		"tag":                   req.Tag,
+		"port":                  req.Port,
+		"domain":                req.Domain,
+		"custom_host":           req.CustomHost,
+		"waf_gateway_group_id":  require.WafGatewayGroupId,
+		"waf_web_limit_id":      require.LimitRuleId,
+		"cc_count":              req.CcCount,
+		"cc_duration":           req.CcDuration,
+		"cc_block_count":        req.CcBlockCount,
+		"cc_block_duration":     req.CcBlockDuration,
+		"cc_4xx_count":          req.Cc4xxCount,
+		"cc_4xx_duration":       req.Cc4xxDuration,
+		"cc_4xx_block_count":    req.Cc4xxBlockCount,
+		"cc_4xx_block_duration": req.Cc4xxBlockDuration,
+		"cc_5xx_count":          req.Cc5xxCount,
+		"cc_5xx_duration":       req.Cc5xxDuration,
+		"cc_5xx_block_count":    req.Cc5xxBlockCount,
+		"cc_5xx_block_duration": req.Cc5xxBlockDuration,
+		"backend_list":          req.BackendList,
+		"allow_ip_list":         req.AllowIpList,
+		"deny_ip_list":          req.DenyIpList,
+		"access_rule":           req.AccessRule,
+		"is_https":              req.IsHttps,
+		"comment":               req.Comment,
+	}
+}
+
+// buildWebForwardingModel 辅助函数，用于构建通用的 WebForwarding 模型
+// ruleId 是从 WAF 系统获取的 ID
+func (s *webForwardingService) buildWebForwardingModel(req *v1.WebForwardingData,ruleId int, require v1.GlobalRequire) *model.WebForwarding {
+	return &model.WebForwarding{
+		HostId: 			require.HostId,
+		RuleId:             ruleId,
+		Tag:                req.Tag,
+		Port:               strconv.Itoa(req.Port),
+		Domain:             req.Domain,
+		CustomHost:         req.CustomHost,
+		WafGatewayGroupId:  require.WafGatewayGroupId,
+		WebLimitRuleId:     require.LimitRuleId,
+		CcCount:            req.CcCount,
+		CcDuration:         req.CcDuration,
+		CcBlockCount:       req.CcBlockCount,
+		CcBlockDuration:    req.CcBlockDuration,
+		Cc4xxCount:         req.Cc4xxCount,
+		Cc4xxDuration:      req.Cc4xxDuration,
+		Cc4xxBlockCount:    req.Cc4xxBlockCount,
+		Cc4xxBlockDuration: req.Cc4xxBlockDuration,
+		Cc5xxCount:         req.Cc5xxCount,
+		Cc5xxDuration:      req.Cc5xxDuration,
+		Cc5xxBlockCount:    req.Cc5xxBlockCount,
+		Cc5xxBlockDuration: req.Cc5xxBlockDuration,
+		IsHttps:            req.IsHttps,
+		Comment:            req.Comment,
+	}
+}
+
 func (s *webForwardingService) AddWebForwarding(ctx context.Context, req *v1.WebForwardingRequest) (string, error) {
 	require, err := s.require(ctx, v1.GlobalRequire{
 		HostId: req.HostId,
@@ -64,68 +122,42 @@ func (s *webForwardingService) AddWebForwarding(ctx context.Context, req *v1.Web
 	if err != nil {
 		return "", err
 	}
-	formData := map[string]interface{}{
-		"tag": req.WebForwardingData.Tag,
-		"port": req.WebForwardingData.Port,
-		"domain": req.WebForwardingData.Domain,
-		"custom_host": req.WebForwardingData.CustomHost,
-		"waf_gateway_group_id": require.WafGatewayGroupId,
-		"waf_web_limit_id": require.LimitRuleId,
-		"cc_count": req.WebForwardingData.CcCount,
-		"cc_duration": req.WebForwardingData.CcDuration,
-		"cc_block_count": req.WebForwardingData.CcBlockCount,
-		"cc_block_duration": req.WebForwardingData.CcBlockDuration,
-		"cc_4xx_count": req.WebForwardingData.Cc4xxCount,
-		"cc_4xx_duration": req.WebForwardingData.Cc4xxDuration,
-		"cc_4xx_block_count": req.WebForwardingData.Cc4xxBlockCount,
-		"cc_4xx_block_duration": req.WebForwardingData.Cc4xxBlockDuration,
-		"cc_5xx_count": req.WebForwardingData.Cc5xxCount,
-		"cc_5xx_duration": req.WebForwardingData.Cc5xxDuration,
-		"cc_5xx_block_count": req.WebForwardingData.Cc5xxBlockCount,
-		"cc_5xx_block_duration": req.WebForwardingData.Cc5xxBlockDuration,
-		"backend_list": req.WebForwardingData.BackendList,
-		"allow_ip_list": req.WebForwardingData.AllowIpList,
-		"deny_ip_list": req.WebForwardingData.DenyIpList,
-		"access_rule": req.WebForwardingData.AccessRule,
-		"is_https": req.WebForwardingData.IsHttps,
-		"comment": req.WebForwardingData.Comment,
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_web/new", "admin/new/waf_web", formData)
+	formData := s.buildWafFormData(&req.WebForwardingData, require)
+	wafWebId, err := s.wafformatter.sendFormData(ctx, "admin/info/waf_web/new", "admin/new/waf_web", formData)
 	if err != nil {
 		return "", err
 	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
-	if err != nil {
-		return "", err
-	}
-	if res != "" {
-		return "", fmt.Errorf(res)
-	}
-	wafWebId, err := s.parser.GetRuleId(ctx, respBody)
-	if err != nil {
+	webModel := s.buildWebForwardingModel(&req.WebForwardingData, wafWebId, require)
+
+	if err := s.webForwardingRepository.AddWebForwarding(ctx, webModel); err != nil {
 		return "", err
 	}
-	fmt.Println("=================================================", wafWebId)
 	return "", nil
 }
 
 func (s *webForwardingService) EditWebForwarding(ctx context.Context, req *v1.WebForwardingRequest) (string, error) {
-	formData := map[string]interface{}{
-
-	}
-	respBody, err := s.required.SendForm(ctx, "admin/info/waf_web/edit?&__goadmin_edit_pk="+strconv.Itoa(req.WebForwardingData.WafWebId), "admin/edit/waf_web", formData)
+	require, err := s.require(ctx, v1.GlobalRequire{
+		HostId: req.HostId,
+		Uid:    req.Uid,
+		Comment: req.WebForwardingData.Comment,
+	})
 	if err != nil {
 		return "", err
 	}
-	// 解析响应内容中的 alert 消息
-	res, err := s.parser.ParseAlert(string(respBody))
+	formData := s.buildWafFormData(&req.WebForwardingData, require)
+	_, err = s.wafformatter.sendFormData(ctx, "admin/info/waf_web/edit?&__goadmin_edit_pk="+strconv.Itoa(req.WebForwardingData.WafWebId), "admin/edit/waf_web", formData)
 	if err != nil {
 		return "", err
 	}
-	if res != "" {
-		return "", fmt.Errorf(res)
+
+	webModel := s.buildWebForwardingModel(&req.WebForwardingData, req.WebForwardingData.WafWebId, require)
+	webModel.Id = req.Id
+
+
+	if err := s.webForwardingRepository.AddWebForwarding(ctx, webModel); err != nil {
+		return "", err
 	}
+
 	return "", nil
 }