go_gameshield/internal/service/host.go

package service

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

// HostService 接口定义
type HostService interface {
	GetHost(ctx context.Context, id int64) (*model.Host, error)
	GetGameShieldConfig(ctx context.Context, hostId int) (v1.GameShieldHostBackendConfigResponse, error)
	GetGlobalLimitConfig(ctx context.Context, hostId int) (v1.GlobalLimitConfigResponse, error)
	GetTcpLimitConfig(ctx context.Context, hostId int) (v1.TcpLimitRequest, error)
	GetUdpLimitConfig(ctx context.Context, hostId int) (v1.UdpLimitRequest, error)
	GetWebLimitConfig(ctx context.Context, hostId int) (v1.WebLimitRequest, error)
}

func NewHostService(
	service *Service,
	hostRepository repository.HostRepository,
) HostService {
	return &hostService{
		Service:        service,
		hostRepository: hostRepository,
	}
}

// 常量定义，包含新增的配置项名称
const (
	ConfigOnlineDevices        = "在线设备数"
	ConfigRuleEntries          = "规则条目"
	ConfigMaxBandwidth         = "高带宽转发规则条目"
	ConfigSourceMachines       = "支持源机"
	ConfigBps                  = "最大带宽"
	ConfigMaxBytesMonth        = "每月流量"
	ConfigTcpConnCount         = "TCP连接次数"
	ConfigTcpConnDuration      = "TCP连接时长"
	ConfigTcpMaxConnCount      = "TCP最大连接数"
	ConfigUdpQosPacketCount    = "UDPQPS包数"
	ConfigUdpQosPacketDuration = "UDPQPS周期"
	ConfigUdpMaxConnCount      = "UDP最大会话数"
	ConfigWebQpsCount          = "WebQPS连接次数"
	ConfigWebQpsDuration       = "WebQPS周期"
)

// unitSuffixMap 存储需要去除的单位后缀
var unitSuffixMap = map[string]string{
	ConfigOnlineDevices: "个",
	ConfigRuleEntries:   "个",
	ConfigMaxBandwidth:  "条",
}

type hostService struct {
	*Service
	hostRepository repository.HostRepository
}

func (s *hostService) GetHost(ctx context.Context, id int64) (*model.Host, error) {
	return s.hostRepository.GetHost(ctx, id)
}

// GetHostConfig 保持不变，它是一个通用的底层数据获取方法。
func (s *hostService) GetHostConfig(ctx context.Context, hostId int) ([]map[string]string, error) {
	configOptions, err := s.hostRepository.GetHostConfig(ctx, hostId)
	if err != nil {
		return nil, err
	}
	// 2. 收集ID和建立映射关系
	var configIDs []int
	var optionIDs []int
	optionMap := make(map[int]int)
	for _, item := range configOptions {
		configIDs = append(configIDs, item.Configid)
		optionIDs = append(optionIDs, item.Optionid)
		optionMap[item.Configid] = item.Optionid
	}
	// 3. 获取配置和选项数据
	var configs []v1.ProductConfigOption
	if len(configIDs) > 0 {
		configs, err = s.hostRepository.GetProductConfigOption(ctx, configIDs)
		if err != nil {
			return nil, err
		}
	}
	var options []v1.ProductConfigOptionSub
	if len(optionIDs) > 0 {
		options, err = s.hostRepository.GetProductConfigOptionSub(ctx, optionIDs)
		if err != nil {
			return nil, err
		}
	}
	// 4. 转换选项为关联数组
	optionsByID := make(map[int]v1.ProductConfigOptionSub)
	for _, option := range options {
		optionsByID[option.ID] = option
	}

	// 5. 构建结果数据
	var data []map[string]string
	for _, config := range configs {
		optionID := optionMap[config.ID]

		var optionName string
		if opt, ok := optionsByID[optionID]; ok {
			optionName = opt.OptionName
		}

		data = append(data, map[string]string{
			"config_name": config.OptionName,
			"option_name": optionName,
		})
	}
	return data, nil
}

// cleanConfigOptionName 简化后的清理函数，直接返回清理后的字符串。
func (s *hostService) cleanConfigOptionName(configName string, optionName string) string {
	// 根据配置名称去除相应的单位后缀
	if suffix, ok := unitSuffixMap[configName]; ok {
		optionName = strings.TrimSuffix(optionName, suffix)
	}
	return optionName
}

// getHostConfigsMap 新增的辅助函数，用于获取所有清理后的配置映射。
func (s *hostService) getHostConfigsMap(ctx context.Context, hostId int) (map[string]string, error) {
	baseData, err := s.GetHostConfig(ctx, hostId)
	if err != nil {
		return nil, err
	}

	configsMap := make(map[string]string)
	for _, item := range baseData {
		configName := item["config_name"]
		optionName := item["option_name"]
		// 将清理后的值存储到 map 中
		configsMap[configName] = s.cleanConfigOptionName(configName, optionName)
	}
	return configsMap, nil
}

func (s *hostService) GetGameShieldConfig(ctx context.Context, hostId int) (v1.GameShieldHostBackendConfigResponse, error) {
	// 调用新辅助函数获取处理好的配置映射
	configsMap, err := s.getHostConfigsMap(ctx, hostId)
	if err != nil {
		return v1.GameShieldHostBackendConfigResponse{}, err
	}

	var data v1.GameShieldHostBackendConfigResponse
	var parseErr error // 用于统一处理类型转换错误

	// 从映射中获取值并进行类型转换
	if val, ok := configsMap[ConfigOnlineDevices]; ok {
		data.OnlineDevicesCount, parseErr = cast.ToInt64E(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	if val, ok := configsMap[ConfigRuleEntries]; ok {
		data.RuleEntriesCount, parseErr = cast.ToInt64E(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	if val, ok := configsMap[ConfigMaxBandwidth]; ok {
		data.MaxBandwidthCount, parseErr = cast.ToInt64E(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	if val, ok := configsMap[ConfigSourceMachines]; ok {
		data.SourceMachinesCount, parseErr = cast.ToInt64E(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	return data, nil
}

func (s *hostService) GetGlobalLimitConfig(ctx context.Context, hostId int) (v1.GlobalLimitConfigResponse, error) {
	configsMap, err := s.getHostConfigsMap(ctx, hostId)
	if err != nil {
		return v1.GlobalLimitConfigResponse{}, err
	}
	data := v1.GlobalLimitConfigResponse{
		MaxBytesMonth: "0",
		Bps:           "0",
	}
	if val, ok := configsMap[ConfigBps]; ok {
		data.Bps = val
	}
	if val, ok := configsMap[ConfigMaxBytesMonth]; ok {
		data.MaxBytesMonth = val
	}
	return data, nil
}

// GetTcpLimitConfig 修正返回类型，并使用新的辅助函数
func (s *hostService) GetTcpLimitConfig(ctx context.Context, hostId int) (v1.TcpLimitRequest, error) {
	configsMap, err := s.getHostConfigsMap(ctx, hostId)
	if err != nil {
		return v1.TcpLimitRequest{}, err
	}
	data := v1.TcpLimitRequest{
		ConnCount:    0,
		ConnDuration: "0s",
		MaxConnCount: 0,
	}
	var parseErr error

	if val, ok := configsMap[ConfigTcpConnCount]; ok {
		data.ConnCount, parseErr = cast.ToIntE(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	if val, ok := configsMap[ConfigTcpConnDuration]; ok {
		data.ConnDuration = val
	}
	if val, ok := configsMap[ConfigTcpMaxConnCount]; ok {
		data.MaxConnCount, parseErr = cast.ToIntE(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	return data, nil // 返回结构体
}

// GetUdpLimitConfig
func (s *hostService) GetUdpLimitConfig(ctx context.Context, hostId int) (v1.UdpLimitRequest, error) {
	configsMap, err := s.getHostConfigsMap(ctx, hostId)
	if err != nil {
		return v1.UdpLimitRequest{}, err
	}
	data := v1.UdpLimitRequest{
		QosPacketCount:    0,
		QosPacketDuration: "0s",
		MaxConnCount:      0,
	}
	var parseErr error

	if val, ok := configsMap[ConfigUdpQosPacketCount]; ok {
		data.QosPacketCount, parseErr = cast.ToIntE(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	if val, ok := configsMap[ConfigUdpQosPacketDuration]; ok {
		data.QosPacketDuration = val
	}
	if val, ok := configsMap[ConfigUdpMaxConnCount]; ok {
		data.MaxConnCount, parseErr = cast.ToIntE(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	return data, nil
}

// GetWebLimitConfig 修正返回类型，并使用新的辅助函数
func (s *hostService) GetWebLimitConfig(ctx context.Context, hostId int) (v1.WebLimitRequest, error) {
	configsMap, err := s.getHostConfigsMap(ctx, hostId)
	if err != nil {
		return v1.WebLimitRequest{}, err
	}
	data := v1.WebLimitRequest{
		QpsCount:    0,
		QpsDuration: "0s",
	}
	var parseErr error

	if val, ok := configsMap[ConfigWebQpsCount]; ok {
		data.QpsCount, parseErr = cast.ToIntE(val)
		if parseErr != nil {
			return data, parseErr
		}
	}
	if val, ok := configsMap[ConfigWebQpsDuration]; ok {
		data.QpsDuration = val
	}
	return data, nil
}