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

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

internal/handler/gameshielduserip.go

@@ -0,0 +1,25 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+)
+
+type GameShieldUserIpHandler struct {
+	*Handler
+	gameShieldUserIpService service.GameShieldUserIpService
+}
+
+func NewGameShieldUserIpHandler(
+	handler *Handler,
+	gameShieldUserIpService service.GameShieldUserIpService,
+) *GameShieldUserIpHandler {
+	return &GameShieldUserIpHandler{
+		Handler:                 handler,
+		gameShieldUserIpService: gameShieldUserIpService,
+	}
+}
+
+func (h *GameShieldUserIpHandler) GetGameShieldUserIp(ctx *gin.Context) {
+
+}

internal/handler/tcplimit.go

@@ -0,0 +1,79 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/mcuadros/go-defaults"
+	"net/http"
+)
+
+type TcpLimitHandler struct {
+	*Handler
+	tcpLimitService service.TcpLimitService
+}
+
+func NewTcpLimitHandler(
+	handler *Handler,
+	tcpLimitService service.TcpLimitService,
+) *TcpLimitHandler {
+	return &TcpLimitHandler{
+		Handler:         handler,
+		tcpLimitService: tcpLimitService,
+	}
+}
+
+func (h *TcpLimitHandler) GetTcpLimit(ctx *gin.Context) {
+
+}
+
+func (h *TcpLimitHandler) AddTcpLimit(ctx *gin.Context) {
+	req := new(v1.TcpLimitRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.tcpLimitService.AddTcpLimit(ctx, req)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+
+}
+
+func (h *TcpLimitHandler) EditTcpLimit(ctx *gin.Context) {
+	req := new(v1.TcpLimitRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.tcpLimitService.UpdateTcpLimit(ctx, req)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+
+}
+
+func (h *TcpLimitHandler) DeleteTcpLimit(ctx *gin.Context) {
+	req := new(v1.TcpLimitDeleteRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.tcpLimitService.DeleteTcpLimit(ctx, req.TcpWebLimitId)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+
+}

internal/handler/udplimit.go

@@ -0,0 +1,25 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+)
+
+type UdpLimitHandler struct {
+	*Handler
+	udpLimitService service.UdpLimitService
+}
+
+func NewUdpLimitHandler(
+	handler *Handler,
+	udpLimitService service.UdpLimitService,
+) *UdpLimitHandler {
+	return &UdpLimitHandler{
+		Handler:         handler,
+		udpLimitService: udpLimitService,
+	}
+}
+
+func (h *UdpLimitHandler) GetUdpLimit(ctx *gin.Context) {
+
+}

internal/handler/weblimit.go

@@ -0,0 +1,78 @@
+package handler
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
+	"github.com/go-nunu/nunu-layout-advanced/internal/service"
+	"github.com/mcuadros/go-defaults"
+	"net/http"
+)
+
+type WebLimitHandler struct {
+	*Handler
+	webLimitService service.WebLimitService
+}
+
+func NewWebLimitHandler(
+	handler *Handler,
+	webLimitService service.WebLimitService,
+) *WebLimitHandler {
+	return &WebLimitHandler{
+		Handler:         handler,
+		webLimitService: webLimitService,
+	}
+}
+
+func (h *WebLimitHandler) GetWebLimit(ctx *gin.Context) {
+
+}
+
+func (h *WebLimitHandler) AddWebLimit(ctx *gin.Context) {
+	req := new(v1.WebLimitRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.webLimitService.AddWebLimit(ctx, req)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+
+}
+
+func (h *WebLimitHandler) EditWebLimit(ctx *gin.Context) {
+	req := new(v1.WebLimitRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.webLimitService.UpdateWebLimit(ctx, req)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+}
+
+func (h *WebLimitHandler) DeleteWebLimit(ctx *gin.Context) {
+	req := new(v1.WebLimitDeleteRequest)
+
+	if err := ctx.ShouldBind(req); err != nil {
+		v1.HandleError(ctx, http.StatusBadRequest, v1.ErrBadRequest, err.Error())
+		return
+	}
+	defaults.SetDefaults(req)
+	res, err := h.webLimitService.DeleteWebLimit(ctx, req.WafWebLimitId)
+	if err != nil {
+		v1.HandleError(ctx, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+	v1.HandleSuccess(ctx, res)
+
+}

internal/model/gameshielduserip.go

@@ -0,0 +1,14 @@
+package model
+
+import "time"
+
+type GameShieldUserIp struct {
+	Id        int       `gorm:"primarykey"`
+	Uid       int       `gorm:"null"`
+	IpId      int       `gorm:"null"`
+	CreatedAt time.Time `gorm:"column:create_time"`
+}
+
+func (m *GameShieldUserIp) TableName() string {
+	return "shd_game_shield_user_ip"
+}

internal/model/tcplimit.go

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

internal/model/udplimit.go

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

internal/model/weblimit.go

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

internal/repository/gameshielduserip.go

@@ -0,0 +1,61 @@
+package repository
+
+import (
+	"context"
+	"github.com/go-nunu/nunu-layout-advanced/internal/model"
+)
+
+type GameShieldUserIpRepository interface {
+	GetGameShieldUserIp(ctx context.Context, id int64) (*model.GameShieldUserIp, error)
+	GetGameShieldUserIpByUid(ctx context.Context, uid int64) (int, error)
+	AddGameShieldUserIp(ctx context.Context, req *model.GameShieldUserIp) error
+	UpdateGameShieldUserIp(ctx context.Context, req *model.GameShieldUserIp) error
+	DeleteGameShieldUserIp(ctx context.Context, id int64) error
+}
+
+func NewGameShieldUserIpRepository(
+	repository *Repository,
+) GameShieldUserIpRepository {
+	return &gameShieldUserIpRepository{
+		Repository: repository,
+	}
+}
+
+type gameShieldUserIpRepository struct {
+	*Repository
+}
+
+func (r *gameShieldUserIpRepository) GetGameShieldUserIp(ctx context.Context, id int64) (*model.GameShieldUserIp, error) {
+	var gameShieldUserIp model.GameShieldUserIp
+
+	return &gameShieldUserIp, nil
+}
+
+func (r *gameShieldUserIpRepository) GetGameShieldUserIpByUid(ctx context.Context, uid int64) (int, error) {
+	var ipId int
+	if err := r.DB(ctx).Model(&model.GameShieldUserIp{}).Select("ip_id").Where("uid = ?", uid).Scan(&ipId).Error; err != nil {
+		return 0, err
+	}
+	return ipId, nil
+}
+
+func (r *gameShieldUserIpRepository) AddGameShieldUserIp(ctx context.Context, req *model.GameShieldUserIp) error {
+	if err := r.DB(ctx).Create(req).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func (r *gameShieldUserIpRepository) UpdateGameShieldUserIp(ctx context.Context, req *model.GameShieldUserIp) error {
+	if err := r.DB(ctx).Updates(req).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func (r *gameShieldUserIpRepository) DeleteGameShieldUserIp(ctx context.Context, id int64) error {
+	if err := r.DB(ctx).Where("id = ?", id).Delete(&model.GameShieldUserIp{}).Error; err != nil {
+		return err
+	}
+	return nil
+}

internal/repository/tcplimit.go

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

internal/repository/udplimit.go

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

internal/repository/weblimit.go

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

internal/service/gameshielduserip.go

@@ -0,0 +1,30 @@
+package service
+
+import (
+	"context"
+	"github.com/go-nunu/nunu-layout-advanced/internal/model"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+)
+
+type GameShieldUserIpService interface {
+	GetGameShieldUserIp(ctx context.Context, id int64) (*model.GameShieldUserIp, error)
+}
+
+func NewGameShieldUserIpService(
+	service *Service,
+	gameShieldUserIpRepository repository.GameShieldUserIpRepository,
+) GameShieldUserIpService {
+	return &gameShieldUserIpService{
+		Service:                    service,
+		gameShieldUserIpRepository: gameShieldUserIpRepository,
+	}
+}
+
+type gameShieldUserIpService struct {
+	*Service
+	gameShieldUserIpRepository repository.GameShieldUserIpRepository
+}
+
+func (s *gameShieldUserIpService) GetGameShieldUserIp(ctx context.Context, id int64) (*model.GameShieldUserIp, error) {
+	return s.gameShieldUserIpRepository.GetGameShieldUserIp(ctx, id)
+}

internal/service/tcplimit.go

@@ -0,0 +1,107 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
+	"github.com/go-nunu/nunu-layout-advanced/internal/model"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"strconv"
+)
+
+type TcpLimitService interface {
+	GetTcpLimit(ctx context.Context, id int64) (*model.TcpLimit, error)
+	AddTcpLimit(ctx context.Context, req *v1.TcpLimitRequest) (string, error)
+	UpdateTcpLimit(ctx context.Context, req *v1.TcpLimitRequest) (string, error)
+	DeleteTcpLimit(ctx context.Context, TcpWebLimitId int) (string, error)
+}
+
+func NewTcpLimitService(
+	service *Service,
+	tcpLimitRepository repository.TcpLimitRepository,
+	required RequiredService,
+	parser ParserService,
+	crawler CrawlerService,
+) TcpLimitService {
+	return &tcpLimitService{
+		Service:            service,
+		tcpLimitRepository: tcpLimitRepository,
+		required:           required,
+		parser:             parser,
+		crawler:            crawler,
+	}
+}
+
+type tcpLimitService struct {
+	*Service
+	tcpLimitRepository repository.TcpLimitRepository
+	required           RequiredService
+	parser             ParserService
+	crawler            CrawlerService
+}
+
+func (s *tcpLimitService) GetTcpLimit(ctx context.Context, id int64) (*model.TcpLimit, error) {
+	return s.tcpLimitRepository.GetTcpLimit(ctx, id)
+}
+
+func (s *tcpLimitService) AddTcpLimit(ctx context.Context, req *v1.TcpLimitRequest) (string, error) {
+	formData := map[string]interface{}{
+		"tag":             req.Tag,
+		"conn_count":      req.ConnCount,
+		"conn_duration":   req.ConnDuration,
+		"bps":             req.Bps,
+		"max_bytes_month": req.MaxBytesMonth,
+		"expired_at":      "",
+	}
+	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp_limit/new", "admin/new/waf_tcp_limit", formData)
+	if err != nil {
+		return "", err
+	}
+	// 解析响应内容中的 alert 消息
+	res, err := s.parser.ParseAlert(string(respBody))
+	if err != nil {
+		return "", err
+	}
+	if res != "" {
+		return "", fmt.Errorf(res)
+	}
+	tcpLimitId, err := s.parser.GetRuleId(ctx, respBody)
+	if err != nil {
+		return "", err
+	}
+	fmt.Println("=================================================", tcpLimitId)
+	return "", nil
+}
+
+func (s *tcpLimitService) UpdateTcpLimit(ctx context.Context, req *v1.TcpLimitRequest) (string, error) {
+	formData := map[string]interface{}{
+		"tag":              req.Tag,
+		"waf_tcp_limit_id": req.TcpWebLimitId,
+		"conn_count":       req.ConnCount,
+		"conn_duration":    req.ConnDuration,
+		"bps":              req.Bps,
+		"max_bytes_month":  req.MaxBytesMonth,
+		"expired_at":       "",
+	}
+	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp_limit/edit?&__goadmin_edit_pk="+strconv.Itoa(req.TcpWebLimitId), "admin/edit/waf_tcp_limit", formData)
+	if err != nil {
+		return "", err
+	}
+	// 解析响应内容中的 alert 消息
+	res, err := s.parser.ParseAlert(string(respBody))
+	if err != nil {
+		return "", err
+	}
+	if res != "" {
+		return "", fmt.Errorf(res)
+	}
+	return "", nil
+}
+
+func (s *tcpLimitService) DeleteTcpLimit(ctx context.Context, TcpWebLimitId int) (string, error) {
+	res, err := s.crawler.DeleteRule(ctx, TcpWebLimitId, "admin/delete/waf_tcp_limit?page=1&__pageSize=10&__sort=waf_tcp_limit_id&__sort_type=desc")
+	if err != nil {
+		return "", err
+	}
+	return res, nil
+}

internal/service/udplimit.go

@@ -0,0 +1,30 @@
+package service
+
+import (
+	"context"
+	"github.com/go-nunu/nunu-layout-advanced/internal/model"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+)
+
+type UdpLimitService interface {
+	GetUdpLimit(ctx context.Context, id int64) (*model.UdpLimit, error)
+}
+
+func NewUdpLimitService(
+	service *Service,
+	udpLimitRepository repository.UdpLimitRepository,
+) UdpLimitService {
+	return &udpLimitService{
+		Service:            service,
+		udpLimitRepository: udpLimitRepository,
+	}
+}
+
+type udpLimitService struct {
+	*Service
+	udpLimitRepository repository.UdpLimitRepository
+}
+
+func (s *udpLimitService) GetUdpLimit(ctx context.Context, id int64) (*model.UdpLimit, error) {
+	return s.udpLimitRepository.GetUdpLimit(ctx, id)
+}

internal/service/weblimit.go

@@ -0,0 +1,108 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
+	"github.com/go-nunu/nunu-layout-advanced/internal/model"
+	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
+	"strconv"
+)
+
+type WebLimitService interface {
+	GetWebLimit(ctx context.Context, id int64) (*model.WebLimit, error)
+	AddWebLimit(ctx context.Context, req *v1.WebLimitRequest) (string, error)
+	UpdateWebLimit(ctx context.Context, req *v1.WebLimitRequest) (string, error)
+	DeleteWebLimit(ctx context.Context, wafWebId int) (string, error)
+}
+
+func NewWebLimitService(
+	service *Service,
+	webLimitRepository repository.WebLimitRepository,
+	require RequiredService,
+	parser ParserService,
+	crawler CrawlerService,
+) WebLimitService {
+	return &webLimitService{
+		Service:            service,
+		webLimitRepository: webLimitRepository,
+		required:           require,
+		parser:             parser,
+		crawler:            crawler,
+	}
+}
+
+type webLimitService struct {
+	*Service
+	webLimitRepository repository.WebLimitRepository
+	required           RequiredService
+	parser             ParserService
+	crawler            CrawlerService
+}
+
+func (s *webLimitService) GetWebLimit(ctx context.Context, id int64) (*model.WebLimit, error) {
+	return s.webLimitRepository.GetWebLimit(ctx, id)
+}
+
+func (s *webLimitService) AddWebLimit(ctx context.Context, req *v1.WebLimitRequest) (string, error) {
+	formData := map[string]interface{}{
+		"tag":             req.Tag,
+		"qps_count":       req.QpsCount,
+		"qps_duration":    req.QpsDuration,
+		"bps":             req.Bps,
+		"max_bytes_month": req.MaxBytesMonth,
+		"expired_at":      "",
+	}
+
+	respBody, err := s.required.SendForm(ctx, "admin/info/waf_web_limit/new", "admin/new/waf_web_limit", formData)
+	if err != nil {
+		return "", err
+	}
+	// 解析响应内容中的 alert 消息
+	res, err := s.parser.ParseAlert(string(respBody))
+	if err != nil {
+		return "", err
+	}
+	if res != "" {
+		return "", fmt.Errorf(res)
+	}
+	webLimitId, err := s.parser.GetRuleId(ctx, respBody)
+	if err != nil {
+		return "", err
+	}
+	fmt.Println("=================================================", webLimitId)
+	return "", nil
+}
+
+func (s *webLimitService) UpdateWebLimit(ctx context.Context, req *v1.WebLimitRequest) (string, error) {
+	formData := map[string]interface{}{
+		"tag":              req.Tag,
+		"waf_web_limit_id": req.WafWebLimitId,
+		"qps_count":        req.QpsCount,
+		"qps_duration":     req.QpsDuration,
+		"bps":              req.Bps,
+		"max_bytes_month":  req.MaxBytesMonth,
+		"expired_at":       "",
+	}
+	respBody, err := s.required.SendForm(ctx, "admin/info/waf_web_limit/edit?&__goadmin_edit_pk="+strconv.Itoa(req.WafWebLimitId), "admin/edit/waf_web_limit", formData)
+	if err != nil {
+		return "", err
+	}
+	// 解析响应内容中的 alert 消息
+	res, err := s.parser.ParseAlert(string(respBody))
+	if err != nil {
+		return "", err
+	}
+	if res != "" {
+		return "", fmt.Errorf(res)
+	}
+	return "", nil
+}
+
+func (s *webLimitService) DeleteWebLimit(ctx context.Context, WafWebLimitId int) (string, error) {
+	res, err := s.crawler.DeleteRule(ctx, WafWebLimitId, "admin/delete/waf_web_limit?page=1&__pageSize=10&__sort=waf_web_limit_id&__sort_type=desc")
+	if err != nil {
+		return "", err
+	}
+	return res, nil
+}