github.com/gorocks/apikit@v0.0.0-20170808011444-396ab031afbd/push/xg/xg.go (about)

     1  package xg
     2  
     3  import (
     4  	"bytes"
     5  	"crypto/md5"
     6  	"encoding/hex"
     7  	"encoding/json"
     8  	"io"
     9  	"net/http"
    10  	"net/url"
    11  	"path"
    12  	"sort"
    13  
    14  	"github.com/douglarek/apikit"
    15  	"github.com/fatih/structs"
    16  )
    17  
    18  const xgPushURL = "http://openapi.xg.qq.com/v2/push"
    19  
    20  // Req ...
    21  type Req struct {
    22  	AccessID  string `structs:"access_id"`
    23  	TimeStamp string `structs:"timestamp"`
    24  	ValidTime string `structs:"valid_time"`
    25  	Sign      string `structs:"sign"`
    26  }
    27  
    28  // SingleDeviceReq ...
    29  type SingleDeviceReq struct {
    30  	Req
    31  	DeviceToken string `structs:"device_token"`
    32  	MessageType string `structs:"message_type"`
    33  	Message     string `structs:"message"`
    34  	ExpireTime  string `structs:"expire_time"`
    35  	SendTime    string `structs:"send_time"`
    36  	MultiPkg    string `structs:"multi_pkg"`
    37  	Environment string `structs:"environment"`
    38  }
    39  
    40  func params(prefix, secret string, m map[string]string) []byte {
    41  	var keys []string
    42  	for k := range m {
    43  		if k == "sign" {
    44  			continue
    45  		}
    46  		keys = append(keys, k)
    47  	}
    48  	sort.Strings(keys)
    49  	var buf bytes.Buffer
    50  	buf.WriteString(prefix)
    51  	for _, k := range keys {
    52  		buf.WriteString(k + "=" + m[k])
    53  	}
    54  	buf.WriteString(secret)
    55  	return buf.Bytes()
    56  }
    57  
    58  func sign(s interface{}, prefix, secret string) string {
    59  	m := apikit.Params(structs.Map(s))
    60  	b := params(prefix, secret, m)
    61  	sum := md5.Sum(b)
    62  	return hex.EncodeToString(sum[:])
    63  }
    64  
    65  // Resp ...
    66  type Resp struct {
    67  	RetCode int    `json:"ret_code"`
    68  	ErrMsg  string `json:"err_msg"`
    69  	Result  struct {
    70  		Status string `json:"status"`
    71  		PushID string `json:"push_id"`
    72  	} `json:"result"`
    73  }
    74  
    75  // Success ...
    76  func (resp *Resp) Success() bool {
    77  	return resp.RetCode == 0
    78  }
    79  
    80  func newURL(oldURL, suffix string) *url.URL {
    81  	u, _ := url.Parse(oldURL)
    82  	u.Path = path.Join(u.Path, suffix)
    83  	return u
    84  }
    85  
    86  func values(s interface{}) url.Values {
    87  	v := url.Values{}
    88  	for k, val := range apikit.Params(structs.Map(s)) {
    89  		v.Set(k, val)
    90  	}
    91  	return v
    92  }
    93  
    94  // SinglePush ...
    95  func SinglePush(r *SingleDeviceReq, secret string) (*Resp, error) {
    96  	u := newURL(xgPushURL, "single_device")
    97  	prefix := "POST" + u.String()[len(u.Scheme)+3:]
    98  	r.Sign = sign(r, prefix, secret)
    99  	resp, err := http.PostForm(u.String(), values(r))
   100  	defer resp.Body.Close()
   101  	if err != nil {
   102  		return nil, err
   103  	}
   104  	var resp0 Resp
   105  	if err := json.NewDecoder(resp.Body).Decode(&resp0); err != nil && err != io.EOF {
   106  		return nil, err
   107  	}
   108  	return &resp0, nil
   109  }
   110  
   111  // MultipleDeviceReq ...
   112  type MultipleDeviceReq struct {
   113  	SingleDeviceReq
   114  	DeviceList []string `structs:"device_list"`
   115  	PushID     string   `structs:"push_id"`
   116  }
   117  
   118  func unmarshalBody(body io.ReadCloser) (r *Resp, err error) {
   119  	defer body.Close()
   120  	if err != nil {
   121  		return
   122  	}
   123  	err = json.NewDecoder(body).Decode(&r)
   124  	if err != nil && err != io.EOF {
   125  		return
   126  	}
   127  	return r, nil
   128  }
   129  
   130  func createMultiPush(r *MultipleDeviceReq, secret string) (s string, err error) {
   131  	u := newURL(xgPushURL, "create_multipush")
   132  	prefix := "POST" + u.String()[len(u.Scheme)+3:]
   133  	r.Sign = sign(r, prefix, secret)
   134  	resp, err := http.PostForm(u.String(), values(r))
   135  	if err != nil {
   136  		return
   137  	}
   138  	resp0, err := unmarshalBody(resp.Body)
   139  	if err != nil {
   140  		return
   141  	}
   142  	return resp0.Result.PushID, nil
   143  }
   144  
   145  func listMultiple(r *MultipleDeviceReq, secret string) (*Resp, error) {
   146  	u := newURL(xgPushURL, "device_list_multiple")
   147  	prefix := "POST" + u.String()[len(u.Scheme)+3:]
   148  	r.Sign = sign(r, prefix, secret)
   149  	resp, err := http.PostForm(u.String(), values(r))
   150  	if err != nil {
   151  		return nil, err
   152  	}
   153  	return unmarshalBody(resp.Body)
   154  }
   155  
   156  // MultiPush ...
   157  func MultiPush(r *MultipleDeviceReq, secret string) (*Resp, error) {
   158  	s, _ := createMultiPush(r, secret)
   159  	r.PushID = s
   160  	return listMultiple(r, secret)
   161  }