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 }