videoplayer/worker/req.go

package worker

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"strings"
	"videoplayer/dao"
	"videoplayer/proto"
)

var client *http.Client

// 初始化
func InitReq() {
	client = &http.Client{}
}

// 发起post请求
func Post(url string, bodyType string, body string) (*http.Response, error) {
	req, err := http.NewRequest("POST", url, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", bodyType)
	req.Body = io.NopCloser(strings.NewReader(body))
	return client.Do(req)
}

// 发送到机器人
func SendToRobot(url string, body string) (map[string]interface{}, error) {
	resp, err := Post(url, "application/json", body)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	m := make(map[string]interface{})
	err = json.NewDecoder(resp.Body).Decode(&m)
	if err != nil {
		return nil, err
	}
	return m, nil
}

// 生成补全的函数
func GenerateCompletion(url, prompt string, model string) (map[string]interface{}, error) {
	data := map[string]interface{}{
		"model":  model,
		"prompt": prompt,
		"stream": false,
	}
	jsonData, err := json.Marshal(data)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")

	client_ := &http.Client{}
	resp, err := client_.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var result map[string]interface{}
	err = json.Unmarshal(body, &result)
	if err != nil {
		return nil, err
	}

	return result, nil
}

// 获取同步数据通用方法
func SyncDataFromMasterReq(url string, token string) proto.UserSync {
	//从接口获取数据
	req, err := http.NewRequest("POST", url, nil)
	if err != nil {
		return proto.UserSync{}
	}
	req.Header.Set("token", token)
	//json负载
	req.Header.Set("Content-Type", "application/json")
	//传输数据
	m := make(map[string]interface{})
	m["token"] = token
	m["device"] = ""

	if client == nil {
		client = &http.Client{}
	}
	client = &http.Client{}
	//获取数据
	resp, err := client.Do(req)
	if err != nil {
		return proto.UserSync{}
	}
	defer resp.Body.Close()
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return proto.UserSync{}
	}
	var result map[string]interface{}
	err = json.Unmarshal(body, &result)
	if err != nil {
		return proto.UserSync{}
	}
	fmt.Println("SyncDataFromMasterReq result:", result)
	if result["code"].(float64) != 0 {
		return proto.UserSync{}
	}
	var userSync proto.UserSync
	err = json.Unmarshal([]byte(result["data"].(string)), &userSync)
	if err != nil {
		return proto.UserSync{}
	}
	return userSync
}

type Response struct {
	Code    int            `json:"code"`
	Message string         `json:"message"`
	Data    proto.UserSync `json:"data"`
}

type ShellResponse struct {
	Code    int         `json:"code"`
	Message string      `json:"message"`
	Data    []dao.Shell `json:"data"`
}

type ShellResponseV2 struct {
	Code    int                       `json:"code"`
	Message string                    `json:"message"`
	Data    []proto.UpdateShellRespV2 `json:"data"`
}

// 获取数据,全量及增量
func SyncDataFromMasterReq2(url string, data proto.SyncUserReq) (proto.UserSync, error) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("SyncDataFromMasterReq2 error:", r)
		}
	}()

	var res proto.UserSync
	//从接口获取数据
	json_data, err := json.Marshal(data)
	if err != nil {
		return res, err
	}
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(json_data))
	if err != nil {
		return res, err
	}
	req.Header.Set("Content-Type", "application/json")
	//传输数据
	if client == nil {
		client = &http.Client{}
	}
	//获取数据
	resp, err := client.Do(req)
	if err != nil {
		return res, err
	}
	defer resp.Body.Close()
	//解析数据
	responseBod, err := io.ReadAll(resp.Body)
	if err != nil {
		return res, err
	}
	var response Response
	err = json.Unmarshal(responseBod, &response)
	if err != nil {
		return res, err
	}
	res = response.Data
	fmt.Println("SyncDataFromMasterReq2 result add data:", len(res.Add), "update data:", len(res.Update), "delete data:", len(res.Delete))
	return res, nil
}

// 获取待执行的shell
func SyncDataFromMasterShellReq2(url string, data proto.SyncUserShellReq) ([]dao.Shell, error) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("SyncDataFromMasterReq2 error:", r)
		}
	}()

	var res []dao.Shell
	//从接口获取数据
	json_data, err := json.Marshal(data)
	if err != nil {
		return res, err
	}
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(json_data))
	if err != nil {
		return res, err
	}
	req.Header.Set("Content-Type", "application/json")
	//传输数据
	if client == nil {
		client = &http.Client{}
	}
	//获取数据
	resp, err := client.Do(req)
	if err != nil {
		return res, err
	}
	defer resp.Body.Close()
	//解析数据
	responseBod, err := io.ReadAll(resp.Body)
	if err != nil {
		return res, err
	}
	var response ShellResponse
	err = json.Unmarshal(responseBod, &response)
	if err != nil {
		return res, err
	}
	res = response.Data
	return res, nil
}

// 获取待执行的shell
func SyncDataFromMasterShellReq3(url string, data proto.SyncUserShellResp) ([]proto.UpdateShellRespV2, error) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("SyncDataFromMasterReq2 error:", r)
		}
	}()

	var res []proto.UpdateShellRespV2
	//从接口获取数据
	json_data, err := json.Marshal(data)
	if err != nil {
		return res, err
	}
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(json_data))
	if err != nil {
		return res, err
	}
	req.Header.Set("Content-Type", "application/json")
	//传输数据
	if client == nil {
		client = &http.Client{}
	}
	//获取数据
	resp, err := client.Do(req)
	if err != nil {
		return res, err
	}
	defer resp.Body.Close()
	//解析数据
	responseBod, err := io.ReadAll(resp.Body)
	if err != nil {
		return res, err
	}
	var response ShellResponseV2
	err = json.Unmarshal(responseBod, &response)
	if err != nil {
		return res, err
	}
	res = response.Data
	return res, nil
}