package esutil
|
|
import (
|
"bytes"
|
"encoding/json"
|
"fmt"
|
"io"
|
"io/ioutil"
|
"log"
|
"mime/multipart"
|
"net/http"
|
"strings"
|
"time"
|
|
"github.com/pkg/errors"
|
)
|
|
func GetEsDataReq(url string, parama string, isSource bool) map[string]interface{} {
|
//fmt.Println("es 查询请求路径" + url) // 配置信息 获取
|
var dat map[string]interface{}
|
req, err := http.NewRequest("POST", url, strings.NewReader(parama))
|
req.Header.Add("Content-Type", "application/json")
|
timeout := time.Duration(10 * time.Second) //超时时间50ms
|
client := &http.Client{Timeout: timeout}
|
resp, err := client.Do(req)
|
if err != nil {
|
fmt.Println(err)
|
return dat
|
}
|
defer resp.Body.Close()
|
dec := json.NewDecoder(resp.Body)
|
if err := dec.Decode(&dat); err == io.EOF {
|
fmt.Println(err.Error())
|
return dat
|
} else if err != nil {
|
fmt.Println(err.Error())
|
return dat
|
}
|
// 是否需要 解析 es 返回的 source
|
if isSource {
|
dat = dat["hits"].(map[string]interface{})
|
var data = make(map[string]interface{}, 2)
|
data["total"] = dat["total"]
|
sources := []interface{}{}
|
for _, value := range dat["hits"].([]interface{}) {
|
source := value.(map[string]interface{})["_source"].(map[string]interface{})
|
//source["id"] = source["id"]
|
/*sdkType := source["sdkType"]
|
if sdkType != nil {
|
sdk, _ := strconv.Atoi(sdkType.(string))
|
source["sdkType"] = sdkTypeToValue(sdk)
|
}*/
|
sources = append(sources, source)
|
}
|
data["datalist"] = sources
|
return data
|
} else {
|
return dat
|
}
|
|
}
|
|
//sdk类型
|
/*func sdkTypeToValue(i int) string {
|
value := []string{"人脸", "车辆", "人体", "入侵", "拥挤", "靠右行", "人员异常", "个体静止"}
|
return value[i-1]
|
}*/
|
|
func PutEsDataReq(url string, parama string) (map[string]interface{}, error) {
|
//fmt.Println("es 查询请求路径" + url) // 配置信息 获取
|
req, err := http.NewRequest("PUT", url, strings.NewReader(parama))
|
if err != nil {
|
fmt.Println(err)
|
return nil, err
|
}
|
req.Header.Add("Content-Type", "application/json")
|
timeout := time.Duration(5 * time.Second) //超时时间50ms
|
client := &http.Client{Timeout: timeout}
|
resp, err := client.Do(req)
|
if err != nil {
|
fmt.Println(err)
|
return nil, err
|
}
|
defer resp.Body.Close()
|
if err != nil {
|
fmt.Println(err)
|
return nil, err
|
}
|
var dat map[string]interface{}
|
dec := json.NewDecoder(resp.Body)
|
if err := dec.Decode(&dat); err == io.EOF {
|
fmt.Println(err.Error())
|
return nil, err
|
} else if err != nil {
|
fmt.Println(err.Error())
|
return nil, err
|
}
|
return dat, nil
|
}
|
|
func PostFormData(uri string, filename, paramName string, fileBytes []byte) (maps map[string]interface{}, err0 error) {
|
body := &bytes.Buffer{}
|
writer := multipart.NewWriter(body)
|
_, err := writer.CreateFormFile(paramName, filename)
|
if err != nil {
|
return nil, err
|
}
|
boundary := writer.Boundary()
|
close_buf := bytes.NewBufferString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
|
fmt.Println("PostFormData.fileLen:", len(fileBytes))
|
file := bytes.NewBuffer(fileBytes)
|
request_reader := io.MultiReader(body, file, close_buf)
|
|
request, err := http.NewRequest("POST", uri, request_reader)
|
request.Header.Add("Content-Type", writer.FormDataContentType())
|
timeout := time.Duration(5 * time.Second) //超时时间50ms
|
client := &http.Client{Timeout: timeout}
|
resp, err := client.Do(request)
|
if err != nil {
|
log.Fatal(err)
|
return nil, err
|
}
|
defer func() {
|
if r := recover(); r != nil {
|
fmt.Printf("panic的内容%v\n", r)
|
msg := "上传图片服务器异常"
|
if _, ok := r.(error); ok {
|
msg = r.(error).Error()
|
fmt.Println("panic--recover()得到的是error类型")
|
}
|
if _, ok := r.(string); ok {
|
msg = r.(string)
|
fmt.Println("panic--recover()得到的是string类型")
|
}
|
err0 = errors.New(msg)
|
}
|
}()
|
defer resp.Body.Close()
|
body = &bytes.Buffer{}
|
_, err = body.ReadFrom(resp.Body)
|
if err != nil {
|
log.Fatal(err)
|
}
|
fmt.Println(resp.StatusCode)
|
//fmt.Println(body)
|
//decoder := json.NewDecoder(strings.NewReader(body.String()))
|
decoder := make(map[string]interface{})
|
if err := json.Unmarshal([]byte(body.String()), &decoder); err != nil {
|
return nil, err
|
}
|
return decoder, nil
|
}
|
|
func PostFormBufferData(uri string, filename, paramName string, fileData []byte) (maps map[string]interface{}, err0 error) {
|
body := &bytes.Buffer{}
|
writer := multipart.NewWriter(body)
|
_, err := writer.CreateFormFile(paramName, filename)
|
if err != nil {
|
return nil, err
|
}
|
boundary := writer.Boundary()
|
//close_string := fmt.Sprintf("\r\n--%s--\r\n", boundary)
|
close_buf := bytes.NewBufferString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
|
file := bytes.NewBuffer(fileData)
|
request_reader := io.MultiReader(body, file, close_buf)
|
//_, err = io.Copy(part, file)
|
//writer.WriteField(key, val)
|
request, err := http.NewRequest("POST", uri, request_reader)
|
request.Header.Add("Content-Type", writer.FormDataContentType())
|
timeout := time.Duration(5 * time.Second) //超时时间50ms
|
client := &http.Client{Timeout: timeout}
|
resp, err := client.Do(request)
|
if err != nil {
|
log.Fatal(err)
|
return nil, err
|
}
|
defer func() {
|
if r := recover(); r != nil {
|
fmt.Printf("panic的内容%v\n", r)
|
msg := "上传图片服务器异常"
|
if _, ok := r.(error); ok {
|
msg = r.(error).Error()
|
fmt.Println("panic--recover()得到的是error类型")
|
}
|
if _, ok := r.(string); ok {
|
msg = r.(string)
|
fmt.Println("panic--recover()得到的是string类型")
|
}
|
err0 = errors.New(msg)
|
}
|
}()
|
defer resp.Body.Close()
|
{
|
body := &bytes.Buffer{}
|
_, err := body.ReadFrom(resp.Body)
|
if err != nil {
|
log.Fatal(err)
|
}
|
fmt.Println(resp.StatusCode)
|
//fmt.Println(resp.Header)
|
fmt.Println(body)
|
//decoder := json.NewDecoder(strings.NewReader(body.String()))
|
decoder := make(map[string]interface{})
|
if err := json.Unmarshal([]byte(body.String()), &decoder); err != nil {
|
return nil, err
|
}
|
return decoder, nil
|
}
|
}
|
|
func GetEsDataInfo(url string, isSource bool) map[string]interface{} {
|
|
fmt.Println("es GET 查询请求路径" + url) // 配置信息 获取
|
req, err := http.NewRequest("GET", url, strings.NewReader(""))
|
req.Header.Add("Content-Type", "application/json")
|
timeout := time.Duration(5 * time.Second) //超时时间50ms
|
client := &http.Client{Timeout: timeout}
|
resp, err := client.Do(req)
|
defer resp.Body.Close()
|
if err != nil {
|
fmt.Println(err)
|
}
|
defer resp.Body.Close()
|
body, err := ioutil.ReadAll(resp.Body)
|
if err != nil {
|
fmt.Println(err)
|
}
|
//jsonStr := string(body)
|
//fmt.Println("jsonStr", jsonStr)
|
var dat map[string]interface{}
|
if err := json.Unmarshal(body, &dat); err == nil {
|
fmt.Println("token", dat["token"])
|
} else {
|
fmt.Println("json str to struct error")
|
}
|
// 是否需要 解析 es 返回的 source
|
if isSource {
|
source := make(map[string]interface{})
|
if dat["_source"] != nil {
|
source = dat["_source"].(map[string]interface{})
|
}
|
source["id"] = dat["_id"]
|
return source
|
} else {
|
return dat
|
}
|
}
|
|
//解析http
|
func EsReq(method string, url string, parama []byte) (buf []byte, err error) {
|
timeout := time.Duration(10 * time.Second)
|
client := http.Client{
|
Timeout: timeout,
|
}
|
request, err := http.NewRequest(method, url, bytes.NewBuffer(parama))
|
request.Header.Set("Content-type", "application/json")
|
|
if err != nil {
|
fmt.Println("build request fail !")
|
return nil, err
|
}
|
|
resp, err := client.Do(request)
|
if err != nil {
|
fmt.Println("request error: ", err)
|
return nil, err
|
}
|
|
defer resp.Body.Close()
|
body, err := ioutil.ReadAll(resp.Body)
|
if err != nil {
|
fmt.Println(err)
|
return nil, err
|
}
|
return body, nil
|
}
|
|
//解析json
|
func Sourcelist(buf []byte) (sources []map[string]interface{}, err error) {
|
var info interface{}
|
json.Unmarshal(buf, &info)
|
out, ok := info.(map[string]interface{})
|
if !ok {
|
return nil, errors.New("http response interface can not change map[string]interface{}")
|
}
|
|
middle, ok := out["hits"].(map[string]interface{})
|
if !ok {
|
return nil, errors.New("first hits change error!")
|
}
|
for _, in := range middle["hits"].([]interface{}) {
|
tmpbuf, ok := in.(map[string]interface{})
|
if !ok {
|
fmt.Println("change to source error!")
|
continue
|
}
|
source, ok := tmpbuf["_source"].(map[string]interface{})
|
if !ok {
|
fmt.Println("change _source error!")
|
continue
|
}
|
sources = append(sources, source)
|
}
|
return sources, nil
|
}
|
|
|
func HttpGet(str string) ([]byte){
|
resp, err := http.Get(str)
|
if err != nil {
|
// handle error
|
}
|
|
defer resp.Body.Close()
|
body, err := ioutil.ReadAll(resp.Body)
|
if err != nil {
|
// handle error
|
}
|
return body
|
}
|
