github.com/pr2apisdk/testgo/sdk@v0.0.0-20240626131719-36a9d76518b2/sdk.go (about)

     1  package sdk
     2  
     3  import (
     4  	"sort"
     5  	"bytes"
     6  	"crypto/hmac"
     7  	"crypto/sha256"
     8  	"encoding/base64"
     9  	"encoding/json"
    10  	"fmt"
    11  	"io/ioutil"
    12  	"net/url"
    13  	"net/http"
    14  	"reflect"
    15  	"runtime"
    16  	"strings"
    17  	"time"
    18  	"strconv"
    19  )
    20  
    21  var SDK_VERSION = "1.0.3"
    22  
    23  // Sdk 是请求的结构
    24  type Sdk struct {
    25  	AppId string
    26  	AppSecret string
    27  	ApiPre string
    28  	UserId int
    29  	clientIp string
    30  	userAgent string
    31  	Timeout int
    32  	Debug bool
    33  	isSetDefault bool
    34  }
    35  
    36  type Response struct {
    37  	Url string
    38  	Api string
    39  	Method string
    40  	Query string
    41  	Data string
    42  	ReqHeaders map[string]string
    43  	Response *http.Response
    44  	RespBody string
    45  	HttpCode  int
    46  	RespData map[string]interface{}
    47  	BizCode int
    48  	BizMsg string
    49  	BizData interface{}
    50  }
    51  
    52  type ReqParams struct {
    53  	Query map[string]interface{}
    54  	Data map[string]interface{}
    55  	Headers map[string]string
    56  }
    57  
    58  // 将深度字典全部字符串化
    59  func MapStrval(data map[string]interface{}) (map[string]interface{}, error) {
    60  	query := map[string]interface{}{}
    61  
    62  	for key, row := range data {
    63  		dtype := reflect.TypeOf(row).String()
    64  		switch dtype {
    65  		case "map[string]interface {}":
    66  			subQuery, err := MapStrval(row.(map[string]interface{}))
    67  			if err != nil {
    68  				return query, err
    69  			}
    70  			query[key] = subQuery
    71  		case "[]interface {}":
    72  			subQuery := map[string]interface{}{}
    73  			for subKey, subRow := range row.([]interface{}) {
    74  				subDtype := reflect.TypeOf(subRow).String()
    75  				switch subDtype {
    76  				case "map[string]interface {}":
    77  					subQuery1, err := MapStrval(subRow.(map[string]interface{}))
    78  					if err != nil {
    79  						return query, err
    80  					}
    81  					subQuery[strconv.Itoa(subKey)] = subQuery1
    82  				case "int":
    83  					subQuery[strconv.Itoa(subKey)] = strconv.Itoa(row.(int))
    84  				case "string":
    85  					subQuery[strconv.Itoa(subKey)] = row.(string)
    86  				default:
    87  				}
    88  				
    89  			}
    90  			query[key] = subQuery
    91  		case "[]float32":
    92  			subQuery := map[string]interface{}{}
    93  			for subKey, subRow := range row.([]float32) {
    94  				subQuery[strconv.Itoa(subKey)] = strconv.FormatFloat(float64(subRow), 'f', 2, 64)
    95  			}
    96  			query[key] = subQuery
    97  		case "[]float64":
    98  			subQuery := map[string]interface{}{}
    99  			for subKey, subRow := range row.([]float64) {
   100  				subQuery[strconv.Itoa(subKey)] = strconv.FormatFloat(subRow, 'f', 2, 64)
   101  			}
   102  			query[key] = subQuery
   103  		case "[]bool":
   104  			subQuery := map[string]interface{}{}
   105  			for subKey, subRow := range row.([]bool) {
   106  				if subRow {
   107  					subQuery[strconv.Itoa(subKey)] = "1"
   108  				} else {
   109  					subQuery[strconv.Itoa(subKey)] = "0"
   110  				}
   111  			}
   112  			query[key] = subQuery
   113  		case "int":
   114  			query[key] = strconv.Itoa(row.(int))
   115  		case "[]int":
   116  			subQuery := map[string]interface{}{}
   117  			for subKey, subRow := range row.([]int) {
   118  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(subRow)
   119  			}
   120  			query[key] = subQuery
   121  		case "uint":
   122  			query[key] = strconv.Itoa(int(row.(uint)))
   123  		case "[]uint":
   124  			subQuery := map[string]interface{}{}
   125  			for subKey, subRow := range row.([]uint) {
   126  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(int(subRow))
   127  			}
   128  			query[key] = subQuery
   129  		case "int8":
   130  			query[key] = strconv.Itoa(int(row.(int8)))
   131  		case "[]int8":
   132  			subQuery := map[string]interface{}{}
   133  			for subKey, subRow := range row.([]int8) {
   134  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(int(subRow))
   135  			}
   136  			query[key] = subQuery
   137  		case "uint8":
   138  			query[key] = strconv.Itoa(int(row.(uint8)))
   139  		case "[]uint8": 	// []byte
   140  			query[key] = string(row.([]byte))
   141  		case "int16":
   142  			query[key] = strconv.Itoa(int(row.(int16)))
   143  		case "[]int16":
   144  			subQuery := map[string]interface{}{}
   145  			for subKey, subRow := range row.([]int16) {
   146  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(int(subRow))
   147  			}
   148  			query[key] = subQuery
   149  		case "uint16":
   150  			query[key] = strconv.Itoa(int(row.(uint16)))
   151  		case "[]uint16":
   152  			subQuery := map[string]interface{}{}
   153  			for subKey, subRow := range row.([]uint16) {
   154  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(int(subRow))
   155  			}
   156  			query[key] = subQuery
   157  		case "int32":
   158  			query[key] = strconv.Itoa(int(row.(int32)))
   159  		case "[]int32":
   160  			subQuery := map[string]interface{}{}
   161  			for subKey, subRow := range row.([]int32) {
   162  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(int(subRow))
   163  			}
   164  			query[key] = subQuery
   165  		case "uint32":
   166  			query[key] = strconv.Itoa(int(row.(uint32)))
   167  		case "[]uint32":
   168  			subQuery := map[string]interface{}{}
   169  			for subKey, subRow := range row.([]uint32) {
   170  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(int(subRow))
   171  			}
   172  			query[key] = subQuery
   173  		case "int64":
   174  			query[key] = strconv.Itoa(int(row.(int64)))
   175  		case "[]int64":
   176  			subQuery := map[string]interface{}{}
   177  			for subKey, subRow := range row.([]int64) {
   178  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(int(subRow))
   179  			}
   180  			query[key] = subQuery
   181  		case "uint64":
   182  			query[key] = strconv.Itoa(int(row.(uint64)))
   183  		case "[]uint64":
   184  			subQuery := map[string]interface{}{}
   185  			for subKey, subRow := range row.([]int64) {
   186  				subQuery[strconv.Itoa(subKey)] = strconv.Itoa(int(subRow))
   187  			}
   188  			query[key] = subQuery
   189  		case "string":
   190  			query[key] = row.(string)
   191  		default:
   192  			return query, fmt.Errorf("不支持的数据类型:%s, %s", dtype, key)
   193  		}
   194  	}
   195  
   196  	return query, nil
   197  }
   198  
   199  // 将深度字典转换为字符串一维键值结构,用于转换为URL      MapStrval已经做了字符串化,这里不需要处理太多类型
   200  func Map2StrKV(data map[string]interface{}) (map[string]string, error) {
   201  	query := map[string]string{}
   202  
   203  	for key, row := range data {
   204  		dtype := reflect.TypeOf(row).String()
   205  		switch dtype {
   206  		case "map[string]interface {}":
   207  			subQuery, err := Map2StrKV(row.(map[string]interface{}))
   208  			if err != nil {
   209  				return query, err
   210  			}
   211  			for subKey, subRow := range subQuery {
   212  				query[key + "[" + subKey + "]"] = subRow
   213  			}
   214  		case "[]interface {}":
   215  			for subKey, subRow := range row.([]interface{}) {
   216  				subDtype := reflect.TypeOf(subRow).String()
   217  				switch subDtype {
   218  				case "map[string]interface {}":
   219  					subQuery, err := Map2StrKV(subRow.(map[string]interface{}))
   220  					if err != nil {
   221  						return query, err
   222  					}
   223  					for subKey1, subRow1 := range subQuery {
   224  						query[key + "[" + strconv.Itoa(subKey) + "]["+subKey1+"]"] = subRow1
   225  					}
   226  				case "int":
   227  					query[key + "[" + strconv.Itoa(subKey) + "]"] = strconv.Itoa(row.(int))
   228  				case "string":
   229  					query[key + "[" + strconv.Itoa(subKey) + "]"] = row.(string)
   230  				default:
   231  				}
   232  				
   233  			}
   234  		case "int":
   235  			query[key] = strconv.Itoa(row.(int))
   236  		case "string":
   237  			query[key] = row.(string)
   238  		default:
   239  			return query, fmt.Errorf("不支持的数据类型:%s, %s", dtype, key)
   240  		}
   241  	}
   242  
   243  	return query, nil
   244  }
   245  
   246  func UrlEncode(data map[string]interface{}) (string, error) {
   247  	params, err := Map2StrKV(data)
   248  	if err != nil {
   249  		return "", err
   250  	}
   251  
   252  	//对key排序
   253  	keys := make([]string, 0, len(params));
   254  	for k := range params {
   255  		keys = append(keys, k)
   256  	}
   257  	sort.Strings(keys)
   258  
   259  	querys := []string{}
   260  	for _, k := range keys {
   261  		querys = append(querys, fmt.Sprintf("%s=%s", k, url.QueryEscape(params[k])))
   262  	}
   263  
   264  	return strings.Join(querys, "&"), nil
   265  }
   266  
   267  //hmac 加密
   268  func hmacSha256(encodedData string, appSecret string) (hashedSig string) {
   269  	key:=[]byte(appSecret)
   270  	h := hmac.New(sha256.New, key)
   271  	h.Write([]byte(encodedData))
   272  	hashedSig = base64.StdEncoding.EncodeToString(h.Sum(nil))
   273  	return  hashedSig
   274  }
   275  
   276  //生成body 里的sign
   277  func (sdk *Sdk) Sign(method string, signData map[string]interface{}) (sign string) {
   278  	bf := &bytes.Buffer{}
   279  	jsonEncoder := json.NewEncoder(bf)
   280  	//不转义html
   281  	jsonEncoder.SetEscapeHTML(false)
   282  	jsonEncoder.Encode(signData)
   283  	b := bf.Bytes()
   284  	// json编码后,go会自动追加\n,去掉 https://github.com/golang/go/issues/7767
   285  	b = bytes.TrimSpace(b)
   286  	//fmt.Println("raw json: ", string(b))
   287  	encodeString := base64.StdEncoding.EncodeToString(b)
   288  	tmpencodeString := strings.ReplaceAll(encodeString, "+", "-")
   289  	encodedPayload := strings.ReplaceAll(tmpencodeString, "/", "_")
   290  	//fmt.Println("encodedPayload: ", encodedPayload)
   291  	hashedSig  := hmacSha256(encodedPayload, sdk.AppSecret)
   292  	tmphashedSig := strings.ReplaceAll(hashedSig, "+", "-")
   293  	encodedSig := strings.ReplaceAll(tmphashedSig, "/", "_")
   294  	sign = encodedSig
   295  	return  sign
   296  }
   297  
   298  func (sdk *Sdk) payload(method string, reqParams *ReqParams) {
   299  	issuedAt := int(time.Now().Unix())
   300  	if method == "GET" {
   301  		reqParams.Query["user_id"] = strconv.Itoa(sdk.UserId)
   302  		reqParams.Query["client_ip"] = ""    //当项目内代理转发调用时,此参数用作将外部的IP传递给内部的系统,这里默认空
   303  		reqParams.Query["client_userAgent"] = sdk.userAgent
   304  		reqParams.Query["algorithm"] = "HMAC-SHA256"
   305  		reqParams.Query["issued_at"] = issuedAt
   306  		reqParams.Query, _ = MapStrval(reqParams.Query)
   307  	} else {
   308  		reqParams.Data["user_id"]          = strconv.Itoa(sdk.UserId)
   309  		reqParams.Data["client_ip"]        = ""    //当项目内代理转发调用时,此参数用作将外部的IP传递给内部的系统,这里默认空
   310  		reqParams.Data["client_userAgent"] = sdk.userAgent
   311  		reqParams.Data["algorithm"]        = "HMAC-SHA256"
   312  		reqParams.Data["issued_at"]        = issuedAt
   313  	}
   314  
   315  	signData := map[string]interface{}{}
   316  	if method == "GET" {
   317  		signData = reqParams.Query
   318  	} else {
   319  		signData = reqParams.Data
   320  	}
   321  	signStr := sdk.Sign(method, signData)
   322  
   323          reqParams.Headers["X-Auth-Sign"]        = signStr
   324          reqParams.Headers["X-Auth-App-Id"]      = sdk.AppId
   325          reqParams.Headers["X-Auth-Sdk-Version"] = SDK_VERSION
   326          reqParams.Headers["Content-Type"]       = "application/json; charset=utf-8"
   327          reqParams.Headers["User-Agent"]         = sdk.userAgent
   328  	return
   329  }
   330  
   331  func (sdk *Sdk) initDefault() bool {
   332  	sdk.clientIp = ""
   333  	sdk.userAgent = "Sdk " + SDK_VERSION + "; " + runtime.Version() + "; arch/" + runtime.GOARCH + "; os/" + runtime.GOOS
   334  	return true
   335  }
   336  
   337  // Request 执行实例发送请求
   338  func (sdk *Sdk) Request(uri, method string, reqParams ReqParams) (*Response, error) {
   339  	//初始化数据默认值
   340  	sdk.initDefault()
   341  	response := Response{
   342  		Api: uri,
   343  	}
   344  	if reqParams.Query == nil {
   345  		reqParams.Query = map[string]interface{}{}
   346  	}
   347  	if reqParams.Data == nil {
   348  		reqParams.Data = map[string]interface{}{}
   349  	}
   350  	if reqParams.Headers == nil {
   351  		reqParams.Headers = map[string]string{}
   352  	}
   353  
   354  	method = strings.ToUpper(method)
   355  	response.Method = method
   356  	url := strings.TrimRight(sdk.ApiPre, "/") + "/" + strings.TrimLeft(uri, "/")
   357  	response.Url = url
   358  
   359  	var err  error
   360  	sdk.payload(method, &reqParams)
   361  
   362  	query, err := UrlEncode(reqParams.Query)
   363  	if err != nil {
   364  		return &response, err
   365  	}
   366  	response.Query = query
   367  	if query != "" {
   368  		url = url + "?" + query
   369  	}
   370  
   371  	jsonByte, err := json.Marshal(reqParams.Data)
   372  	if err != nil {
   373  		return &response, err
   374  	}
   375  	response.Data = string(jsonByte)
   376  	body := strings.NewReader(string(jsonByte))
   377  	req, err := http.NewRequest(method, url, body)
   378  	if err != nil {
   379  		return &response, err
   380  	}
   381  	response.ReqHeaders = reqParams.Headers
   382  	for k, v := range reqParams.Headers {
   383  		req.Header.Set(k, v)
   384  	}
   385  
   386  	//客户端,被Get,Head以及Post使用
   387  	client := &http.Client{
   388  		Timeout: time.Duration(sdk.Timeout) * time.Second,
   389  	}
   390  	resp, err := client.Do(req)//发送请求
   391  	if err != nil {
   392  		return &response, err
   393  	}
   394  	response.Response = resp
   395  	response.HttpCode = resp.StatusCode
   396  
   397  	if resp.StatusCode == 200 {
   398          	rawByte, err := ioutil.ReadAll(resp.Body)
   399          	if err == nil {
   400  			response.RespBody = string(rawByte)
   401  			respData := map[string]interface{}{}
   402  			err = json.Unmarshal(rawByte, &respData)
   403  			if err == nil {
   404  				if bizStatus, ok := respData["status"].(map[string]interface{}); ok {
   405  					response.BizCode = int(bizStatus["code"].(float64))
   406  					response.BizMsg = bizStatus["message"].(string)
   407  					response.BizData = respData["data"]
   408  				} else {
   409  					response.BizCode = 0
   410  					response.BizMsg = "the json format of response body has not status"
   411  					response.BizData = map[string]interface{}{}
   412  					err = fmt.Errorf("the json format of response body has not status")
   413  				}
   414  			} else {
   415  				response.BizCode = 0
   416  				response.BizMsg = "json parse response body error: " + err.Error()
   417  				response.BizData = map[string]interface{}{}
   418  				err = fmt.Errorf("json parse response body error: %s", err.Error())
   419  			}
   420          	} else {
   421  			response.BizCode = 0
   422  			response.BizMsg = "response body read error: " + err.Error()
   423  			response.BizData = map[string]interface{}{}
   424  			err = fmt.Errorf("response body read error: %s", err.Error())
   425  		}
   426  	} else {
   427  		response.BizCode = 0
   428  		response.BizMsg = "response code is " + strconv.Itoa(resp.StatusCode)
   429  		response.BizData = map[string]interface{}{}
   430  		err = fmt.Errorf("response code is %s", strconv.Itoa(resp.StatusCode))
   431  	}
   432  
   433  	return &response, err
   434  }
   435  
   436  // GET 请求
   437  func (sdk *Sdk) Get(api string, reqParams ReqParams) (*Response, error) {
   438  	return sdk.Request(api, "GET", reqParams)
   439  }
   440  
   441  // POST 请求
   442  func (sdk *Sdk) Post(api string, reqParams ReqParams) (*Response, error) {
   443  	return sdk.Request(api, "POST", reqParams)
   444  }
   445  
   446  //PUT 请求
   447  func (sdk *Sdk) Put(api string, reqParams ReqParams) (*Response, error) {
   448  	return sdk.Request(api, "PUT", reqParams)
   449  }
   450  
   451  //DELETE 请求
   452  func (sdk *Sdk) Delete(api string, reqParams ReqParams) (*Response, error) {
   453  	return sdk.Request(api, "DELETE", reqParams)
   454  }