gjson解析和http的发送

package main

import (
	"encoding/json"
	"fmt"
	"github.com/tidwall/gjson"
	"io/ioutil"
	"log"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
)

type body struct {
	Method                  string   `json:"method"`
	Title                   string   `json:"title"`
	Desc                    string   `json:"desc"`
	Catname                 string   `json:"catname"`
	Tag                     []string `json:"tag"`
	Path                    string   `json:"path"`
	Req_params              []string `json:"req_params""`
	Req_body_form           []string `json:"req_body_form"`
	Req_headers             []string `json:"req_headers"`
	Req_query               []string `json:"req_query"`
	Req_body_type           string   `json:"req_body_type"`
	Res_body_type           string   `json:"res_body_type"`
	Res_body_is_json_schema bool     `json:"res_body_is_json_schema"`
	Res_body                string   `json:"res_body"`
	Req_body_other          string   `json:"req_body_other"`
	Req_body_is_json_schema bool     `json:"req_body_is_json_schema"`
	Project_id              float64  `json:"project_id"`
	Catid                   float64  `json:"catid"`
	DataSync                string   `json:"dataSync"`
}

type Req_body struct {
	Type       string      `json:"type"`
	Properties interface{} `json:"properties"`
	Ref        string      `json:"$ref"`
}

type Resp_body struct {
	Type       string     `json:"type"`
	Properties Properties `json:"properties"`
	Ref        string     `json:"$ref"`
}
type Properties struct {
	Err_Msg Type    `json:"err_msg"`
	Err_No  Type    `json:"err_no"`
	Results Results `json:"results"`
}
type Type struct {
	Type string `json:"type"`
}
type Results struct {
	Type       string      `json:"type"`
	Properties interface{} `json:"properties"`
}

func getMenu(token string, client *http.Client) (map[string]interface{}, error) {

	URL := ""
	request, _ := http.NewRequest("GET", URL, nil)
	params := make(url.Values)
	params.Add("token", token)
	request.URL.RawQuery = params.Encode()
	response, err := client.Do(request)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	returnMap, _ := ParseResponse(response)
	return returnMap, nil
}

func getlist(token string, projectId float64, client *http.Client) (map[string]interface{}, error) {
	URL := ""
	request, _ := http.NewRequest("GET", URL, nil)
	params := make(url.Values)
	params.Add("token", token)
	params.Add("project_id", strconv.FormatFloat(projectId, 'f', 0, 64))
	params.Add("page", "1")
	params.Add("limit", "1000")
	request.URL.RawQuery = params.Encode()
	response, err := client.Do(request)
	if err != nil {
		log.Println(err)
		return nil, err
	}
	returnMap, _ := ParseResponse(response)
	return returnMap, nil
}
func post(title_catid map[string]float64, projectId float64, jsonContext, url string, client *http.Client) {
	paths := gjson.Get(jsonContext, "paths")
	paths.ForEach(func(key, value gjson.Result) bool {
		if key.Str != url {
			return true
		}
		//fmt.Println(value)

		body := &body{}
		body.Res_body_type = "json"
		body.Req_body_type = "json"
		body.DataSync = "good"
		body.Res_body_is_json_schema = true
		body.Req_body_is_json_schema = true
		body.Path = key.Str

		way := "post"
		method := value.Get(way)
		if method.String() == "" {
			way = "get"
		}
		//添加method
		body.Method = strings.ToUpper(way)
		//post
		body.Desc = method.Get("description").Str
		body.Title = method.Get("summary").Str
		body.Catname = method.Get("summary").Str
		//resp部分
		resp_json := method.Get("responses").Get("200").Get("schema").Get("allOf").Array()[1].Array()[0].Get("properties").Get("results").Get("$ref")
		resp_strs := strings.Split(resp_json.String(), "/")
		resp_name := resp_strs[len(resp_strs)-1]
		req_json := method.Get("parameters").Array()[0].Get("schema").Get("$ref")
		req_strs := strings.Split(req_json.String(), "/")
		req_name := req_strs[len(req_strs)-1]
		con := gjson.Get(jsonContext, "definitions")
		var resp interface{}
		var req interface{}
		con.ForEach(func(key, value gjson.Result) bool {
			if key.Str == resp_name {
				resp = value.Get("properties").Value()
				fmt.Println(resp)
			}
			if key.Str == req_name {
				req = value.Get("properties").Value()
				fmt.Println(req)
			}
			return true
		})
		resbody := Resp_body{
			Type: "object",
			Properties: Properties{
				Err_Msg: Type{"string"},
				Err_No:  Type{"integer"},
				Results: Results{
					Type:       "object",
					Properties: resp,
				},
			},
			Ref: resp_json.String(),
		}
		//req部分
		reqbody := Req_body{
			Type:       "object",
			Properties: req,
			Ref:        req_json.String(),
		}
		data_resbody, _ := json.Marshal(resbody)
		data_reqbody, _ := json.Marshal(reqbody)
		body.Res_body = string(data_resbody)
		body.Req_headers = []string{}
		body.Req_body_form = []string{}
		body.Req_query = []string{}
		body.Req_params = []string{}
		body.Req_body_other = string(data_reqbody)
		//fmt.Println(body.Req_body_other)
		body.Project_id = projectId
		body.Catid = title_catid[body.Title]
		tags := method.Get("tags")
		tags.ForEach(func(key, value gjson.Result) bool {
			body.Tag = append(body.Tag, value.Str)
			return true
		})
		context, _ := json.Marshal(body)
		fmt.Println(string(context))
		URL := "http://yapi.phigent.io/api/interface/save"
		request, _ := http.NewRequest("POST", URL, strings.NewReader(string(context)))
		request.Header.Add("Accept", "application/json, text/plain, */*")
		request.Header.Add("Accept-Language", "zh-CN,zh;q=0.9")
		request.Header.Add("Connection", "keep-alive")
		request.Header.Add("Content-Type", "application/json;charset=UTF-8")
		request.Header.Add("Origin", "http://yapi.phigent.io")
		request.Header.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36")
		request.Header.Add("Cookie", "_yapi_token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1aWQiOjEwMiwiaWF0IjoxNjg0MjMzMTI4LCJleHAiOjE2ODQ4Mzc5Mjh9.tt5GzKJBFvrjT7EtLNX9Ha50_qDcpr-a864oDrU5xpA; _yapi_uid=102")
		//处理返回结果
		//log.Println(request.Body)
		response, err := client.Do(request)
		if err != nil {
			log.Println(err)
		}
		resp, err = ParseResponse(response)
		//log.Println(resp)
		defer response.Body.Close()
		return true
	})

}
func main() {
	filePath := os.Args[1]
	file, err := ioutil.ReadFile(filePath)
	if err != nil {
		log.Println(err)
		return
	}
	json1 := string(file)
	client := &http.Client{}
	token := os.Args[2]
	url := os.Args[3]
	returnMap, err := getMenu(token, client)
	if err != nil {
		return
	}
	data := returnMap["data"].([]interface{})
	//id和name的映射以及name和id的映射
	var projectId float64
	for _, v := range data {
		tmpmap := v.(map[string]interface{})
		projectId = tmpmap["project_id"].(float64)
	}
	returnMap, err = getlist(token, projectId, client)
	if err != nil {
		log.Println(err)
		return
	}
	list := returnMap["data"].(map[string]interface{})["list"].([]interface{})
	title_catid := make(map[string]float64)
	for _, v := range list {
		item := v.(map[string]interface{})
		title_catid[item["title"].(string)] = item["catid"].(float64)
	}
	post(title_catid, projectId, json1, url, client)
}

func ParseResponse(response *http.Response) (map[string]interface{}, error) {
	var result map[string]interface{}
	body, err := ioutil.ReadAll(response.Body)
	if err == nil {
		err = json.Unmarshal(body, &result)
	}

	return result, err
}

Http发送

HTTP发送一共有三个部分要写，parm,header和body，其中如果发送内容有表单，则用form-data进行发送；如果发送内容是普通的文本，那么用json格式发送

// 发送飞书文件
func PostXlsFile(token, filePath, uid string) (err error) {
	cli := &http.Client{}
	//得到文件名
	fileName := strings.Split(filePath, "\\")
	name := fileName[len(fileName)-1]
	//先将file上传,获得key
	params := make(map[string]string)
	params["file_type"] = "xls"
	params["file_name"] = name
	header := make(map[string]string)
	header["Authorization"] = fmt.Sprintf("Bearer %s", token)
	resp, err := GetPostFormResp(Configs().FeiShu.PostFileUrl, params, header, "file", filePath)
	if err != nil {
		Logger().Errorln("upload file failed, err:", err)
		return
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		Logger().Errorln("read body failed, err: ", err)
		return
	}
	postFileResp := &PostFileResponse{}
	err = json.Unmarshal(body, postFileResp)
	if err != nil {
		Logger().Errorln("Unmarshal postFileResp failed, err:", err)
		return
	}
	if postFileResp.Code != 0 {
		Logger().Errorln("error: ", postFileResp.Msg)
		return
	}
	fileKey := postFileResp.Data.FileKey
	//通过fileKey进行发送文件
	PostMessageRequest := PostMessageRequest{}
	content := make(map[string]string)
	content["file_key"] = fileKey
	contentJson, err := json.Marshal(content)
	if err != nil {
		Logger().Errorln("Marshal postFileResp failed, err:", err)
		return err
	}
	PostMessageRequest.Content = string(contentJson)
	PostMessageRequest.MsgType = "file"
	PostMessageRequest.ReceiveId = uid
	context, err := json.Marshal(PostMessageRequest)
	req, err := http.NewRequest("POST", Configs().FeiShu.PostMessageUrl, strings.NewReader(string(context)))
	//设置查询参数
	param := make(url.Values)
	param.Add("receive_id_type", "user_id")
	req.URL.RawQuery = param.Encode()
	req.Header.Set("Authorization", header["Authorization"])
	req.Header.Set("Content-Type", "application/json; charset=utf-8")
	resp, err = cli.Do(req)
	if err != nil {
		Logger().Errorln("upload file failed, err:", err)
		return err
	}
	defer resp.Body.Close()
	body, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		Logger().Errorln("read body failed, err:", err)
		return err
	}
	postMessageResp := &PostMessageResponse{}
	err = json.Unmarshal(body, postMessageResp)
	if err != nil {
		Logger().Errorln("Unmarshal SendMessResp failed, err: ", err)
		return err
	}
	if postMessageResp.Code != 0 {
		return errors.New(postMessageResp.Msg)
	}
	return nil
}
func GetPostFormResp(urlPath string, params map[string]string, header map[string]string, paramName, path string) (*http.Response, error) {
	cli := &http.Client{}
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	file, err := os.Open(path)
	if err != nil {
		Logger().Errorln("open file err: ", err)
		return nil, err
	}
	defer file.Close()
	part, err := writer.CreateFormFile(paramName, filepath.Base(path))
	if err != nil {
		Logger().Errorln("CreateFormFile err:", err)
		return nil, err
	}
	_, err = io.Copy(part, file)

	if err != nil {
		Logger().Errorln("io.Copy err :", err)
		return nil, err
	}
	for key, val := range params {
		err = writer.WriteField(key, val)
		if err != nil {
			Logger().Errorln("WriteField err:", err)
			return nil, err
		}
	}
	err = writer.Close()
	if err != nil {
		Logger().Errorln("writer.Close() err :", err)
		return nil, err
	}
	req, err := http.NewRequest("POST", urlPath, body)
	for key, val := range header {
		req.Header.Set(key, val)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	resp, err := cli.Do(req)
	if err != nil {
		Logger().Errorln("upload file failed, err: ", err)
		return nil, err
	}
	return resp, nil
}

小文件下载

在请求头里写入即可

func AnnoProjectFile(c *gin.Context) (err error) {
	db := libraries.DB()
	id, err := strconv.Atoi(c.Query("id"))
	if err != nil || id <= 0 {
		return libraries.NewCError(libraries.ErrRequestParams, libraries.ErrRequestParams)
	}
	annoProject, err := dao.GetAnnoProjectById(db, id)
	if err != nil {
		libraries.Logger().Errorln("GetAnnoProjectById_err:", err)
		return libraries.NewCError(libraries.ErrGetAnnoProject, libraries.ErrGetAnnoProject)
	}
	if annoProject.ConfFile == "" {
		return libraries.NewCError(libraries.ErrGetAnnoProjectFile, libraries.ErrGetAnnoProjectFile)
	}
	c.Header("Content-Type", "application/octet-stream")
	c.Header("Content-Transfer-Encoding", "binary")
	c.Header("Content-Disposition", "attachment;filename=conf.txt")
	info, err := json.Marshal(annoProject.ConfFile)
	if err != nil {
		return err
	}
	//对resp.body直接解析
	/**reader := bufio.NewReaderSize(file, 32*1024)
	if _, err = reader.WriteTo(c.Writer); err != nil {
		return err
	}
	**/
	info = []byte(string(info) + "\r\n")
	buf := bytes.NewBuffer(info)
	if _, err = buf.WriteTo(c.Writer); err != nil {
		return err
	}
	return nil
}