Skip to content

add token #1

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
pengan1990 wants to merge 1 commit into
base: master
Choose a base branch
from
Open

add token #1

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
191 changes: 62 additions & 129 deletions http/http.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,13 +2,15 @@ package http

import (
"bytes"
"crypto/tls"
"encoding/json"
"io"
"io/ioutil"
"net"
"net/http"
"time"
"fmt"
"strings"
"github.com/zssky/log"
)

var (
Expand All @@ -23,88 +25,36 @@ var (
)

// PostJSON - send an http post json Request.
func PostJSON(url string, data interface{}, deadline, dialTimeout time.Duration) ([]byte, int, error) {
func PostJSON(url, token string, data interface{}, deadline, dialTimeout time.Duration) ([]byte, int, error) {
buf, err := json.Marshal(data)
fmt.Println(string(buf))
fmt.Println("---------------------------------------")
if err != nil {
return nil, 0, err
}

return Request(http.MethodPost, url, bytes.NewBuffer(buf), deadline, dialTimeout, map[string]string{"Content-Type": ContentTypeJson})
return Request(http.MethodPost, url, bytes.NewBuffer(buf), deadline, dialTimeout,
map[string]string{"Content-Type": ContentTypeJson, "token": token})
}

// PostForm - sen an http post form Request
func PostForm(url string, data []byte, deadline, dialTimeout time.Duration) ([]byte, int, error) {
return Request(http.MethodPost, url, bytes.NewBuffer(data), deadline, dialTimeout, map[string]string{"Content-Type": ContentTypeForm})
}

// SimpleGet - send an http get Request
func SimpleGet(url string, deadline, dialTimeout time.Duration) ([]byte, int, error) {
return Request(http.MethodGet, url, bytes.NewBuffer(nil), deadline, dialTimeout, nil)
}

// SimpleDelete - send an simple http delete Request
func SimpleDelete(url string, deadline, dialTimeout time.Duration) ([]byte, int, error) {
return Request(http.MethodDelete, url, bytes.NewBuffer(nil), deadline, dialTimeout, nil)
}

// SimplePut - send an simple http put Request
func SimplePut(url string, deadline, dialTimeout time.Duration) ([]byte, int, error) {
return Request(http.MethodPut, url, bytes.NewBuffer(nil), deadline, dialTimeout, nil)
}

// CookiesGet - send an http get Request, response cookies
func CookiesGet(url string, deadline, dialTimeout time.Duration, header map[string]string) ([]byte, []*http.Cookie, error) {
return RequestCookies(http.MethodGet, url, bytes.NewBuffer(nil), deadline, dialTimeout, header, nil)
}

// GetRequestWithBasicAuth - get request with Basic Auth
func GetRequestWithBasicAuth(url string, deadline, dialTimeout time.Duration, username, password string) ([]byte, int, error) {
return BasicAuthRequest(http.MethodGet, url, bytes.NewBuffer(nil), deadline, dialTimeout, nil, username, password)
}

// BasicAuthRequest - send an http Request
func BasicAuthRequest(method, url string, body io.Reader, deadline, dialTimeout time.Duration, header map[string]string, username, password string) ([]byte, int, error) {
client := http.Client{
Transport: &http.Transport{
Dial: func(netw, addr string) (net.Conn, error) {
deadline := time.Now().Add(deadline)
c, err := net.DialTimeout(netw, addr, dialTimeout)
if err != nil {
return nil, err
}
c.SetDeadline(deadline)
return c, nil
},
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}

req, err := http.NewRequest(method, url, body)
// PostJSONWithHeader - send an http post json Request with header.
func PostJSONWithHeader(url string, header map[string]string, data interface{}, deadline, dialTimeout time.Duration) ([]byte, int, error) {
buf, err := json.Marshal(data)
fmt.Println(string(buf))
fmt.Println("---------------------------------------")
if err != nil {
return nil, 0, err
}

if header != nil {
for key, value := range header {
req.Header.Set(key, value)
}
}

req.SetBasicAuth(username, password)
resp, err := client.Do(req)
if err != nil {
return nil, 0, err
}
header["Content-Type"] = ContentTypeJson

defer resp.Body.Close()
return Request(http.MethodPost, url, bytes.NewBuffer(buf), deadline, dialTimeout, header)
}

data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, 0, err
}
return data, resp.StatusCode, nil
// PostHex - send an http post json Request.
func PostHex(url, token string, data string, deadline, dialTimeout time.Duration) ([]byte, int, error) {
return Request(http.MethodPost, url, bytes.NewBuffer([]byte(data)), deadline, dialTimeout,
map[string]string{"Content-Type": ContentTypeJson, "token": token})
}

// Request - send an http Request
Expand All @@ -120,9 +70,6 @@ func Request(method, url string, body io.Reader, deadline, dialTimeout time.Dura
c.SetDeadline(deadline)
return c, nil
},
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}

Expand Down Expand Up @@ -151,67 +98,19 @@ func Request(method, url string, body io.Reader, deadline, dialTimeout time.Dura
return data, resp.StatusCode, nil
}

// RequestCookies - send an http Request with cookies
func RequestCookies(method, url string, body io.Reader, deadline, dialTimeout time.Duration, header map[string]string, cookies []*http.Cookie) ([]byte, []*http.Cookie, error) {
client := http.Client{
Transport: &http.Transport{
Dial: func(netw, addr string) (net.Conn, error) {
deadline := time.Now().Add(deadline)
c, err := net.DialTimeout(netw, addr, dialTimeout)
if err != nil {
return nil, err
}
c.SetDeadline(deadline)
return c, nil
},
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}

req, err := http.NewRequest(method, url, body)
if err != nil {
return nil, nil, err
}

if header != nil {
for key, value := range header {
req.Header.Set(key, value)
}
}

for _, c := range cookies {
req.AddCookie(c)
}

resp, err := client.Do(req)
if err != nil {
return nil, nil, err
}

defer resp.Body.Close()

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

return data, resp.Cookies(), nil
}

// HttpResponse - htt Response
type HttpResponse struct {
Code int `json:"Code"`
Message string `json:"Message"`
Data interface{} `json:"Data,omitempty"`
Code int `json:"Code"`
Message string `json:"Message"`
Data map[string]interface{} `json:"Data,omitempty"`
}

// NewHttpResponse -
func NewHttpResponse() *HttpResponse {
return &HttpResponse{
Code: 0,
Message: "success",
Data: make(map[string]interface{}),
}
}

Expand Down Expand Up @@ -239,8 +138,42 @@ func (h *HttpResponse) Error(err error) {
h.Message = err.Error()
}

// RespData user for bootstrap
type RespData struct {
Total int64 `json:"total"`
Rows interface{} `json:"rows"`
// PostForm post form data
func PostForm(url string, header, para map[string]string) ([]byte, int, error) {
// write string buffer
var r http.Request
r.ParseForm()

// add form key value
for key, value := range para {
r.Form.Add(key, value)
}

body := strings.TrimSpace(r.Form.Encode())
req, err := http.NewRequest("POST", url, strings.NewReader(body))
if err != nil {
return nil, 0, err
}

// add header
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
for key, value := range header {
req.Header.Add(key, value)
}

log.Debugf("header %v", req.Header)

// request client
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, 0, err
}

defer resp.Body.Close()

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