go_gameshield/internal/service/udpforwarding.go

package service

import (
	"context"
	"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"
	"strconv"
)

type UdpForWardingService interface {
	GetUdpForWarding(ctx context.Context, id int64) (*model.UdpForWarding, error)
	AddUdpForwarding(ctx context.Context, req *v1.UdpForwardingRequest) (string, error)
	EditUdpForwarding(ctx context.Context, req *v1.UdpForwardingRequest) (string, error)
	DeleteUdpForwarding(ctx context.Context, wafUdpId int) (string, error)
}

func NewUdpForWardingService(
	service *Service,
	udpForWardingRepository repository.UdpForWardingRepository,
	required RequiredService,
	parser ParserService,
	crawler CrawlerService,
	globalRep repository.GlobalLimitRepository,
	hostRep repository.HostRepository,
	wafformatter WafFormatterService,
) UdpForWardingService {
	return &udpForWardingService{
		Service:                 service,
		udpForWardingRepository: udpForWardingRepository,
		required:                required,
		parser:                  parser,
		crawler:                 crawler,
		globalRep:               globalRep,
		hostRep:                 hostRep,
		wafformatter:            wafformatter,
	}
}

type udpForWardingService struct {
	*Service
	udpForWardingRepository repository.UdpForWardingRepository
	required                RequiredService
	parser                  ParserService
	crawler                 CrawlerService
	globalRep               repository.GlobalLimitRepository
	hostRep      repository.HostRepository
	wafformatter WafFormatterService
}


func (s *udpForWardingService) require(ctx context.Context,req v1.GlobalRequire) (v1.GlobalRequire, error) {
	res, err := s.wafformatter.require(ctx, req, "udp")
	if err != nil {
		return v1.GlobalRequire{}, err
	}
	return res, nil
}
func (s *udpForWardingService) GetUdpForWarding(ctx context.Context, id int64) (*model.UdpForWarding, error) {
	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 := 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
	}
	udpModel := s.buildUdpForwardingModel(&req.UdpForwardingData, wafUdpId, require)
	if err := s.udpForWardingRepository.AddUdpForwarding(ctx, udpModel); err != nil {
		return "", err
	}
	return "", nil
}

func (s *udpForWardingService) EditUdpForwarding(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,
	})
	if err != nil {
		return "", err
	}
	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
	}

	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
}

func (s *udpForWardingService) DeleteUdpForwarding(ctx context.Context, wafUdpId int) (string, error) {
	res, err := s.crawler.DeleteRule(ctx, wafUdpId, "admin/delete/waf_udp?page=1&__pageSize=10&__sort=waf_udp_id&__sort_type=desc")
	if err != nil {
		return "", err
	}
	return res, nil
}