itao

upstream/itao/itao.go

@@ -6,24 +6,28 @@ import (
 	"crypto/sha1"
 	"encoding/hex"
 	"github.com/gogf/gf/encoding/gjson"
+	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/util/gconv"
+	"github.com/gogf/gf/util/gutil"
+	"net/url"
 	"sort"
 	"strings"
 	"time"
 )
 
 type Config struct {
-	ApiUrl      string
-	AppKey      string
-	AppSecret   string
-	AccessToken string
+	ApiUrl    string
+	AppKey    string
+	AppSecret string
 }
 
 var server *Config
 
 const PkgName = "itao"
+const CacheKey = "itao:token"
+const Host = "https://open.huoju6.com/openapi/param2/1/com.huoju6.open/"
 
 func New(req *Config) {
 	server = req
@@ -36,22 +40,20 @@ type CommonRes struct {
 	ErrorMessage string `json:"errorMessage"`
 }
 
-func (s *Config) CreateSign(signStr string) (sign string) {
+func generate(req string) (res string) {
 	//拼接参数
-	appSecret := []byte(s.AppSecret)
-	mac := hmac.New(sha1.New, appSecret)
-	mac.Write([]byte(signStr))
+	mac := hmac.New(sha1.New, []byte(server.AppSecret))
+	mac.Write([]byte(req))
 	mdStr := hex.EncodeToString(mac.Sum(nil))
-	sign = strings.ToUpper(mdStr)
+	res = strings.ToUpper(mdStr)
 	return
 }
 
-func (s *Config) sign(method string, param g.Map) g.Map {
+func sign(method string, req g.Map) (err error) {
 	var keys []string
-	param["_aop_timestamp"] = gtime.Now().TimestampMilliStr()
+	req["_aop_timestamp"] = gtime.Now().TimestampMilliStr()
 
-	mewparam := param
-	for k := range mewparam {
+	for k := range req {
 		keys = append(keys, k)
 	}
 
@@ -61,28 +63,82 @@ func (s *Config) sign(method string, param g.Map) g.Map {
 	for _, v := range keys {
 		if v != "_aop_signature" {
 			signStr += v
-			signStr += gconv.String(mewparam[v])
+			signStr += gconv.String(req[v])
 		}
 	}
 	//拼接参数
-	signStr = "param2/1/" + method + "/" + s.AppKey + signStr
-	param["_aop_signature"] = s.CreateSign(signStr)
-
-	return param
+	signStr = "param2/1/com.huoju6.open/" + method + "/" + server.AppKey + signStr
+	req["_aop_signature"] = generate(signStr)
+	return
 }
 
 func (s *Config) Post(ctx context.Context, method string, params g.Map) (str string, err error) {
+	params["access_token"], err = s.AccessToken(ctx)
+	if err != nil {
+		return
+	}
+	str, err = Post(ctx, method, params)
+	return
+
+}
+
+func Post(ctx context.Context, method string, params g.Map) (str string, err error) {
+	Start := gtime.TimestampMilli()
+	err = sign(method, params)
+	if err != nil {
+		return
+	}
+	Url := Host + method + "/" + server.AppKey
+	Request := g.Client()
+	Request.SetHeader("Content-Type", "application/x-www-form-urlencoded")
+	resp, err := Request.Timeout(time.Second*5).Get(Url, params)
+
+	defer func() {
+		_ = resp.Close()
+		paramStr := gjson.New(params).MustToJsonString()
+		ctx = context.WithValue(ctx, "Method", "GET")
+		ctx = context.WithValue(ctx, "URI", Url)
+		if err != nil {
+			g.Log().Cat(PkgName).Ctx(ctx).Infof("参数【%v】错误【%v】响应时间【%vms】", paramStr, err.Error(), gtime.TimestampMilli()-Start)
+		} else {
+			g.Log().Cat(PkgName).Ctx(ctx).Infof("参数【%v】响应【%v】响应时间【%vms】", paramStr, str, gtime.TimestampMilli()-Start)
+		}
+
+	}()
+	str = resp.ReadAllString()
+	return
+
+}
+
+func (s *Config) Get(ctx context.Context, method string, params g.Map) (str string, err error) {
+	params["access_token"], err = s.AccessToken(ctx)
+	if err != nil {
+		return
+	}
+	str, err = Get(ctx, method, params)
+	return
+
+}
+
+func Get(ctx context.Context, method string, params g.Map) (str string, err error) {
 	Start := gtime.TimestampMilli()
-	allparams := s.sign(method, params)
-	Url := s.ApiUrl + method + "/" + s.AppKey
+	err = sign(method, params)
+	if err != nil {
+		return
+	}
+	Url := Host + method + "/" + server.AppKey
 	Request := g.Client()
+	Values := url.Values{}
+	for k, v := range params {
+		Values.Add(k, gconv.String(v))
+	}
 	Request.SetHeader("Content-Type", "application/x-www-form-urlencoded")
-	resp, err := Request.Timeout(time.Second*5).Post(Url, allparams)
+	resp, err := Request.Timeout(time.Second * 5).Get(Url + "?" + Values.Encode())
 
 	defer func() {
 		_ = resp.Close()
 		paramStr := gjson.New(params).MustToJsonString()
-		ctx = context.WithValue(ctx, "Method", "POST")
+		ctx = context.WithValue(ctx, "Method", "GET")
 		ctx = context.WithValue(ctx, "URI", Url)
 		if err != nil {
 			g.Log().Cat(PkgName).Ctx(ctx).Infof("参数【%v】错误【%v】响应时间【%vms】", paramStr, err.Error(), gtime.TimestampMilli()-Start)
@@ -95,3 +151,40 @@ func (s *Config) Post(ctx context.Context, method string, params g.Map) (str str
 	return
 
 }
+
+func (s *Config) AccessToken(ctx context.Context) (res string, err error) {
+	var conn = g.Redis().Conn()
+	defer func() {
+		_ = conn.Close()
+	}()
+	_, _ = conn.DoVar("SELECT", 10)
+	cache, _ := conn.DoVar("HGETALL", CacheKey)
+	if cache.IsEmpty() {
+		err = gerror.New("获取token 失败")
+		return
+	}
+	var token *AuthTokenRes
+	_ = gjson.New(cache).Scan(&token)
+	if token == nil {
+		err = gerror.New("获取token 失败")
+		return
+	}
+	if token.AccessTokenExpireTime < gtime.Now().TimestampMilli() {
+		if token.RefreshTokenExpireTime < gtime.Now().TimestampMilli() {
+			err = gerror.New("获取token 失败")
+			return
+		}
+		token, err = Auth.Token(ctx, token.RefreshToken, 2)
+		if err != nil {
+			return
+		}
+		if token.Code != "success" {
+			err = gerror.New("获取token 失败")
+			return
+		}
+		_, _ = conn.Do("HMSET", append(g.Slice{CacheKey}, gutil.StructToSlice(token)...)...)
+
+	}
+	res = token.AccessToken
+	return
+}

upstream/itao/itao_address.go

@@ -47,7 +47,7 @@ type AddressDivisionRes struct {
 
 //Division 行政区划
 func (s addressItao) Division(ctx context.Context, req AddressDivisionReq) (res *AddressDivisionRes, err error) {
-	method := "com.alibaba.c2m/ltao.delivery.queryDivision"
+	method := "tt.order.queryDivision"
 
 	result, err := server.Post(ctx, method, g.Map{
 		"param": req,
@@ -81,7 +81,7 @@ type AddressParseRes struct {
 //Parse 地址解析
 // 省、市必传
 func (s addressItao) Parse(ctx context.Context, req AddressParseReq) (res *AddressParseRes, err error) {
-	method := "com.alibaba.c2m/ltao.delivery.validate"
+	method := "tt.address.validate"
 
 	result, err := server.Post(ctx, method, g.Map{
 		"param": req,

upstream/itao/itao_auth.go

+package itao
+
+import (
+	"context"
+	"github.com/gogf/gf/encoding/gjson"
+	"github.com/gogf/gf/frame/g"
+)
+
+type auth struct {
+}
+
+var Auth = auth{}
+
+type AuthStatusRes struct {
+	Code    string `json:"code"`
+	Message string `json:"message"`
+}
+
+//Status 授权状态
+func (s auth) Status(ctx context.Context) (res *AuthStatusRes, err error) {
+	method := "tt.authority.checkAuthStatus"
+
+	result, err := server.Get(ctx, method, g.Map{
+		"bId": server.AppKey,
+	})
+	_ = gjson.New(result).Scan(&res)
+	return
+
+}
+
+type AuthQrCodeRes struct {
+	Code               string `json:"code"`
+	Message            string `json:"message"`
+	TempCode           string `json:"tempCode"`
+	TempCodeExpireTime string `json:"tempCodeExpireTime"`
+	QrCodeUrl          string `json:"qrCodeUrl"`
+}
+
+//QrCode 二维码
+func (s auth) QrCode(ctx context.Context) (res *AuthQrCodeRes, err error) {
+	method := "tt.authority.generateQrCode"
+
+	result, err := server.Get(ctx, method, g.Map{
+		"bId": server.AppKey,
+	})
+	_ = gjson.New(result).Scan(&res)
+	return
+
+}
+
+type AuthTokenRes struct {
+	Code                   string `json:"code"`
+	Message                string `json:"message"`
+	RefreshToken           string `json:"refreshToken"`
+	AccessToken            string `json:"accessToken"`
+	AccessTokenExpireTime  int64  `json:"accessTokenExpireTime"`
+	RefreshTokenExpireTime int64  `json:"refreshTokenExpireTime"`
+	TaoteId                string `json:"taoteId"`
+	TaoteNickName          string `json:"taoteNickName"`
+	Feature                string `json:"feature"`
+	GwTraceId              string `json:"gw_trace_id"`
+}
+
+//Token 授权
+func (s auth) Token(ctx context.Context, code string, Type int) (res *AuthTokenRes, err error) {
+	method := "tt.auth.getAccessToken"
+	var request = g.Map{
+		"bId": server.AppKey,
+	}
+	if Type == 1 {
+		request["code"] = code //临时令牌
+		request["grantType"] = "code"
+	} else {
+		request["refreshToken"] = code //刷新令牌
+		request["grantType"] = "refreshToken"
+	}
+
+	result, err := server.Get(ctx, method, request)
+	_ = gjson.New(result).Scan(&res)
+	return
+}
+
+//Unbind 注销授权
+func (s auth) Unbind(ctx context.Context) (res *AuthTokenRes, err error) {
+	method := "tt.authority.unbind"
+
+	result, err := server.Get(ctx, method, g.Map{
+		"bId": server.AppKey,
+	})
+	_ = gjson.New(result).Scan(&res)
+	return
+}

upstream/itao/itao_logistics.go

@@ -46,7 +46,7 @@ type LogisticsTraceRes struct {
 
 //Trace 物流轨迹
 func (logisticsItao) Trace(ctx context.Context, req string) (res *LogisticsTraceRes, err error) {
-	method := "com.alibaba.c2m/ltao.logistics.queryDetail"
+	method := "tt.logistics.detail"
 
 	result, err := server.Post(ctx, method, g.Map{
 		"request": g.Map{