go_gameshield/internal/service/aodun.go

package service

import (
	"bytes"
	"context"
	"crypto/tls"
	"encoding/json"
	"fmt"
	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
	"github.com/spf13/viper"
	"io"
	"net/http"
	"strings"
	"time"
)

type AoDunService interface {
	AddDomainWhiteList(ctx context.Context, req []string) error
	DeleteDomainWhiteList(ctx context.Context, req []string) error
}
func NewAoDunService(
    service *Service,
	conf *viper.Viper,

) AoDunService {
	return &aoDunService{
		Service:        service,
		Url:                       conf.GetString("aodun.Url"),
		clientID:          conf.GetString("aodun.clientID"),
		username:          conf.GetString("aodun.username"),
		password:          conf.GetString("aodun.password"),
	}
}

type aoDunService struct {
	*Service
	Url string
	clientID string
	username string
	password string
}

func (s *aoDunService) DeleteDomainWhiteList(ctx context.Context, req []string) error {
	//TODO implement me
	panic("implement me")
}

func (s *aoDunService) sendFormData(ctx context.Context,apiUrl string,tokenType string,token string,formData map[string]interface{})  ([]byte,error) {
	URL := s.Url + apiUrl
	jsonData, err := json.Marshal(formData)
	if err != nil {
		return nil, fmt.Errorf("序列化请求数据失败: %w", err)
	}
	req, err := http.NewRequest("POST", URL, bytes.NewBuffer(jsonData))
	if err != nil {
		return nil, fmt.Errorf("创建 HTTP 请求失败: %w", err)
	}
	// 设置请求头 Content-Type 为 "application/json"
	req.Header.Set("Content-Type", "application/json")
	if tokenType == "" {
		req.Header.Set("Authorization", tokenType + " " + token)
	}


	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // <--- 关键修改：忽略 SSL 验证
	}

	// 5. 使用 HTTP 客户端发送请求
	client := &http.Client{
		Transport: tr,
		Timeout: 15 * time.Second, // 设置一个合理的超时时间，例如15秒
	}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("发送 HTTP 请求失败: %w", err)
	}
	// defer 确保在函数返回前关闭响应体，防止资源泄露
	defer resp.Body.Close()

	// 6. 读取响应体内容
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("读取响应体失败: %w", err)
	}
	return body, nil
}


func (s *aoDunService) GetToken(ctx context.Context)  (string,string,error) {

	formData := map[string]interface{}{
		"ClientID":  s.clientID,
		"GrantType": "password",
		"Username":  s.username,
		"Password":  s.password,
	}

	resBody, err := s.sendFormData(ctx,"/oauth/token","","",formData)
	if err != nil {
		return "", "", err
	}
	// 7. 将响应体 JSON 数据反序列化到 ResponsePayload 结构体
	var responsePayload v1.GetTokenRespone
	if err := json.Unmarshal(resBody, &responsePayload); err != nil {
		// 如果反序列化失败，可能是响应格式不符合预期
		return "", "", fmt.Errorf("反序列化响应 JSON 失败 ( 内容: %s): %w", string(resBody), err)
	}

	// 8. 检查 API 返回的操作结果代码
	if responsePayload.Code != 0 {
		return "", "", fmt.Errorf("API 错误: code %d, msg '%s', remote_ip '%s'",
			responsePayload.Code, responsePayload.Msg, responsePayload.RemoteIP)
	}

	// 9. 成功：返回 access_token
	if responsePayload.AccessToken == "" {
		// 理论上 code 为 0 时应该有 access_token，这是一个额外的健壮性检查
		return "", "", fmt.Errorf("API 成功 (code 0) 但 access_token 为空")
	}
	return responsePayload.TokenType,responsePayload.AccessToken, nil
}

func (s *aoDunService) AddWhiteStaticList(ctx context.Context,req []v1.IpInfo) error {
	tokenType,token, err := s.GetToken(ctx)
	if err != nil {
		return err
	}

	formData := map[string]interface{}{
		"action" : "add",
		"bwflag" : "white",
		"insert_bw_list": req,
	}

	resBody, err := s.sendFormData(ctx,"/v1.0/firewall/static_bw_list",tokenType,token,formData)
	if err != nil {
		return  err
	}
	// 7. 将响应体 JSON 数据反序列化到 ResponsePayload 结构体
	var res v1.IpResponse
	if err := json.Unmarshal(resBody, &res); err != nil {
		// 如果反序列化失败，可能是响应格式不符合预期
		return  fmt.Errorf("反序列化响应 JSON 失败 ( 内容: %s): %w", string(resBody), err)
	}
	if res.Code != 0 {
		return  fmt.Errorf("API 错误: code %d, msg '%s'",
			res.Code, res.Msg)
	}

	return nil
}

//func (s *aoDunService) GetWhiteStaticList(ctx context.Context,ip string) (int,error) {
//	tokenType,token, err := s.GetToken(ctx)
//	if err != nil {
//		return 0, err
//	}
//
//	formData := map[string]interface{}{
//		"action" : "get",
//		"bwflag" : "white",
//		"page" : 1,
//		"ids": ip,
//	}
//
//	resBody, err := s.sendFormData(ctx,"/v1.0/firewall/static_bw_list",tokenType,token,formData)
//	if err != nil {
//		return nil, err
//	}
//	// 7. 将响应体 JSON 数据反序列化到 ResponsePayload 结构体
//	var res IpResponse // 使用我们定义的 IpResponse 结构体
//	if err := json.Unmarshal(resBody, &res); err != nil {
//		// 如果反序列化失败，说明响应格式不符合预期
//		return 0, fmt.Errorf("反序列化响应 JSON 失败 (内容: %s): %w", string(resBody), err)
//	}
//
//	// 2. 检查 API 返回的 code，这是处理业务失败的关键
//	if res.Code != 0 {
//		// API 返回了错误码，例如 IP 不存在、参数错误等
//		return 0, fmt.Errorf("API 错误: code %d, msg '%s'", res.Code, res.Msg)
//	}
//
//	// 3. 检查 data 数组是否为空
//	// 即使 code 为 0，也可能因为没有匹配的数据而返回一个空数组
//	if len(res.Data) == 0 {
//		return 0, fmt.Errorf("API 调用成功，但未找到与 IP '%s' 相关的记录", ip)
//	}
//
//	// 4. 获取 ID 并返回
//	// 假设我们总是取返回结果中的第一个元素的 ID
//	id := res.Data[0].ID
//	return id, nil // 成功！返回获取到的 id 和 nil 错误
//}

func (s *aoDunService) DelWhiteStaticList(ctx context.Context, req v1.DeleteIp) error {
	tokenType, token, err := s.GetToken(ctx)
	if err != nil {
		return err
	}

	formData := map[string]interface{}{
		"action": "del",
		"bwflag": "white",
		"flag":   0,
		"ids":    req.Ids,
	}

	resBody, err := s.sendFormData(ctx, "/v1.0/firewall/static_bw_list", tokenType, token, formData)
	if err != nil {
		return err
	}
	var res v1.IpResponse
	if err := json.Unmarshal(resBody, &res); err != nil {
		return fmt.Errorf("反序列化响应 JSON 失败 ( 内容: %s): %w", string(resBody), err)
	}
	if res.Code != 0 {
		return fmt.Errorf("API 错误: code %d, msg '%s'", res.Code, res.Msg)
	}
	return nil
}

func (s *aoDunService) AddDomainWhiteList(ctx context.Context, req []string) error {
	tokenType, token, err := s.GetToken(ctx)
	if err != nil {
		return err
	}
	formData := map[string]interface{}{
		"domain": req,
	}
	resBody, err := s.sendFormData(ctx, "/v1.0/firewall/addDomainWhiteList", tokenType, token, formData)
	if err != nil {
		return err
	}
	var res v1.DomainResponse
	if err := json.Unmarshal(resBody, &res); err != nil {
		return fmt.Errorf("反序列化响应 JSON 失败 ( 内容: %s): %w", string(resBody), err)
	}
	if res.Code != 0 {
		if strings.Contains(string(res.Msg), "重复列表") {
			return nil
		}
		return fmt.Errorf("API 错误: code %d, msg '%s'", res.Code, res.Msg)
	}
	return nil
}

func (s *aoDunService) DelDomainWhiteList(ctx context.Context, req []string) error {
	tokenType, token, err := s.GetToken(ctx)
	if err != nil {
		return err
	}
	formData := map[string]interface{}{
		"type":   1,
		"domain": req,
	}
	resBody, err := s.sendFormData(ctx, "/v1.0/firewall/delDomainWhiteList", tokenType, token, formData)
	if err != nil {
		return err
	}
	var res v1.DomainResponse
	if err := json.Unmarshal(resBody, &res); err != nil {
		return fmt.Errorf("反序列化响应 JSON 失败 ( 内容: %s): %w", string(resBody), err)
	}
	if res.Code != 0 {
		if strings.Contains(string(res.Msg), "重复列表") {
			return nil
		}
		return fmt.Errorf("API 错误: code %d, msg '%s'", res.Code, res.Msg)
	}
	return nil
}