Create & Init Project...

app/interface/main/account/dao/vip/BUILD

@@ -0,0 +1,66 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "api_test.go",
+        "dao_test.go",
+        "oauth2_api_test.go",
+        "oauth2_client_test.go",
+        "vip_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/account/conf:go_default_library",
+        "//app/interface/main/account/model:go_default_library",
+        "//app/service/main/vip/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "dao.go",
+        "oauth2_api.go",
+        "oauth2_client.go",
+    ],
+    importpath = "go-common/app/interface/main/account/dao/vip",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/account/conf:go_default_library",
+        "//app/interface/main/account/model:go_default_library",
+        "//app/service/main/vip/model:go_default_library",
+        "//library/conf/env:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)

app/interface/main/account/dao/vip/api.go

@@ -0,0 +1,150 @@
+package vip
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"go-common/app/interface/main/account/model"
+	vipmol "go-common/app/service/main/vip/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	_vipCodeVerify = "/x/internal/vip/code/verify"
+	_vipCodeOpen   = "/x/internal/vip/code/open"
+	_viptips       = "/x/internal/vip/tips"
+	_couponCancel  = "/x/internal/vip/coupon/cancel"
+	_vipCodeOpened = "/x/internal/vip/code/opened"
+
+	// vip with java
+	_vipInfo = "/internal/v1/user/"
+)
+
+//CodeVerify code verify
+func (d *Dao) CodeVerify(c context.Context) (token *model.Token, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	var tokenResq *model.TokenResq
+	val := url.Values{}
+	if err = d.client.Get(c, d.codeVerifyURL, ip, val, &tokenResq); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if tokenResq.Code == int64(ecode.OK.Code()) {
+		token = tokenResq.Data
+	}
+	return
+}
+
+//CodeOpen http code open
+func (d *Dao) CodeOpen(c context.Context, mid int64, code, token, verify string) (data *model.ResourceCodeResq, err error) {
+	ip := metadata.String(c, metadata.RemoteIP)
+	val := url.Values{}
+	val.Add("mid", fmt.Sprintf("%v", mid))
+	val.Add("token", token)
+	val.Add("verify", verify)
+	val.Add("code", code)
+	defer func() {
+		log.Info("qingqiu url(%+v) params(%+v) return(%+v)", d.codeOpenURL, val, data)
+	}()
+	if err = d.client.Post(c, d.codeOpenURL, ip, val, &data); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+
+	if data.Code > int64(ecode.OK.Code()) {
+		err = ecode.Int(int(data.Code))
+		return
+	}
+	return
+}
+
+// Info get vip info
+func (d *Dao) Info(c context.Context, mid int64, ip string) (info *model.VIPInfo, err error) {
+	var res struct {
+		Code int            `json:"code"`
+		Data *model.VIPInfo `json:"data"`
+	}
+	if err = d.client.Get(c, d.infoURL+strconv.FormatInt(mid, 10), ip, nil, &res); err != nil {
+		log.Error("d.client.Get(%d) error(%v)", mid, err)
+		return
+	}
+	if res.Code != ecode.OK.Code() {
+		err = ecode.Int(res.Code)
+		log.Error("d.client.Get(%d) error(%v)", mid, err)
+		return
+	}
+	info = res.Data
+	return
+}
+
+// Tips tips info.
+func (d *Dao) Tips(c context.Context, version int64, platform string) (data *vipmol.TipsResp, err error) {
+	params := url.Values{}
+	params.Add("version", fmt.Sprintf("%v", version))
+	params.Add("platform", platform)
+	var resp struct {
+		Code int              `json:"code"`
+		Data *vipmol.TipsResp `json:"data"`
+	}
+	if err = d.client.Get(c, d.tipsURL, "", params, &resp); err != nil {
+		err = errors.Errorf("vip tips d.httpClient.Do(%s) error(%+v)", d.tipsURL+"?"+params.Encode(), err)
+		return
+	}
+	if resp.Code != ecode.OK.Code() {
+		err = errors.Errorf("vip tips url(%s) res(%+v) err(%+v)", d.tipsURL+"?"+params.Encode(), resp, ecode.Int(resp.Code))
+	}
+	data = resp.Data
+	return
+}
+
+// CancelUseCoupon cancel use coupon.
+func (d *Dao) CancelUseCoupon(c context.Context, arg *vipmol.ArgCancelUseCoupon) (err error) {
+	params := url.Values{}
+	params.Add("mid", fmt.Sprintf("%d", arg.Mid))
+	params.Add("coupon_token", arg.CouponToken)
+	var resp struct {
+		Code int `json:"code"`
+	}
+	if err = d.clientSlow.Post(c, d.cancelCouponURL, "", params, &resp); err != nil {
+		err = errors.Errorf("vip cancel coupon d.httpClient.Do(%s) error(%+v)", d.cancelCouponURL+"?"+params.Encode(), err)
+		return
+	}
+	if resp.Code != ecode.OK.Code() {
+		err = ecode.Int(resp.Code)
+	}
+	return
+}
+
+//CodeOpeneds sel code opened data
+func (d *Dao) CodeOpeneds(c context.Context, arg *model.CodeInfoReq, ip string) (resp []*vipmol.CodeInfoResp, err error) {
+	val := url.Values{}
+	val.Add("bis_appkey", arg.Appkey)
+	val.Add("bis_sign", arg.Sign)
+	val.Add("bis_ts", strconv.FormatInt(arg.Ts.Time().Unix(), 10))
+	val.Add("start_time", strconv.FormatInt(arg.StartTime.Time().Unix(), 10))
+	val.Add("end_time", strconv.FormatInt(arg.EndTime.Time().Unix(), 10))
+	val.Add("cursor", strconv.FormatInt(arg.Cursor, 10))
+	rep := new(struct {
+		Code int                    `json:"code"`
+		Data []*vipmol.CodeInfoResp `json:"data"`
+	})
+	defer func() {
+		log.Info("vip code opened url:%+v params:%+v return:%+v", d.codeOpenedURL, val, rep)
+	}()
+	if err = d.client.Get(c, d.codeOpenedURL, ip, val, rep); err != nil {
+		err = errors.Errorf("vip code opened url:%+v params:%+v return:%+v,err:%+v", d.codeOpenedURL, val, rep, err)
+		return
+	}
+	if rep.Code != ecode.OK.Code() {
+		err = ecode.Int(rep.Code)
+		return
+	}
+	resp = rep.Data
+	return
+}

app/interface/main/account/dao/vip/api_test.go

@@ -0,0 +1,42 @@
+package vip
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestVipCodeVerify(t *testing.T) {
+	convey.Convey("CodeVerify", t, func(convCtx convey.C) {
+		var (
+			c = context.Background()
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			token, err := d.CodeVerify(c)
+			convCtx.Convey("Then err should be nil.token should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(token, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestVipCodeOpen(t *testing.T) {
+	convey.Convey("CodeOpen", t, func(convCtx convey.C) {
+		var (
+			c      = context.Background()
+			mid    = int64(0)
+			code   = ""
+			token  = ""
+			verify = ""
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			data, err := d.CodeOpen(c, mid, code, token, verify)
+			convCtx.Convey("Then err should be nil.data should not be nil.", func(convCtx convey.C) {
+				convCtx.So(err, convey.ShouldBeNil)
+				convCtx.So(data, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/account/dao/vip/dao.go

@@ -0,0 +1,38 @@
+package vip
+
+import (
+	"go-common/app/interface/main/account/conf"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Dao dao
+type Dao struct {
+	c               *conf.Config
+	client          *bm.Client
+	clientSlow      *bm.Client
+	infoURL         string
+	codeOpenURL     string
+	codeVerifyURL   string
+	tipsURL         string
+	cancelCouponURL string
+	codeOpenedURL   string
+	cl              *Clientl
+}
+
+// New new
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:               c,
+		client:          bm.NewClient(c.HTTPClient.Normal),
+		clientSlow:      bm.NewClient(c.HTTPClient.Slow),
+		infoURL:         c.Host.Vip + _vipInfo,
+		codeOpenURL:     c.Host.API + _vipCodeOpen,
+		codeVerifyURL:   c.Host.API + _vipCodeVerify,
+		tipsURL:         c.Host.API + _viptips,
+		cancelCouponURL: c.Host.API + _couponCancel,
+		codeOpenedURL:   c.Host.API + _vipCodeOpened,
+	}
+	// http client for had url md5 sign.
+	d.cl = NewClientl(c.Vipproperty.OAuthClient, d.client)
+	return
+}

app/interface/main/account/dao/vip/dao_test.go

@@ -0,0 +1,35 @@
+package vip
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/interface/main/account/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.account.account-interface")
+		flag.Set("conf_token", "967eef77ad40b478234f11b0d489d6d6")
+		flag.Set("tree_id", "3815")
+		flag.Set("conf_version", "docker-1")
+		flag.Set("deploy_env", "uat")
+		flag.Set("conf_host", "config.bilibili.co")
+		flag.Set("conf_path", "/tmp")
+		flag.Set("region", "sh")
+		flag.Set("zone", "sh001")
+	} else {
+		flag.Set("conf", "../../cmd/account-interface-example.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}

app/interface/main/account/dao/vip/oauth2_api.go

@@ -0,0 +1,36 @@
+package vip
+
+import (
+	"context"
+	"net/url"
+
+	"go-common/app/interface/main/account/model"
+	"go-common/library/ecode"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+const (
+	_oauth2UserInfoPath = "/oauth2/user_info"
+)
+
+//OAuth2ByCode get user info by oauth2 code.
+func (d *Dao) OAuth2ByCode(c context.Context, a *model.ArgAuthCode) (data *model.OAuth2InfoResp, err error) {
+	params := url.Values{}
+	params.Add("code", a.Code)
+	params.Add("grant_type", "authorization_code")
+	var res struct {
+		Code int                   `json:"code"`
+		Data *model.OAuth2InfoResp `json:"data"`
+	}
+	if err = d.cl.get(c, d.c.Host.PassportCom, _oauth2UserInfoPath, a.IP, params, &res); err != nil {
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		err = pkgerr.Wrap(err, "dao oauth2 userinfo")
+		return
+	}
+	data = res.Data
+	return
+}

app/interface/main/account/dao/vip/oauth2_api_test.go

@@ -0,0 +1,25 @@
+package vip
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"go-common/app/interface/main/account/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+//  go test  -test.v -test.run TestDaoOAuth2
+func TestDaoOAuth2(t *testing.T) {
+	Convey("TestDaoOAuth2", t, func() {
+		data, err := d.OAuth2ByCode(context.Background(), &model.ArgAuthCode{
+			Code: "778b91c87a43e4fdab6c647010b77566",
+		})
+		if fmt.Sprintf("%v", err) != "dao oauth2 userinfo: -907" {
+			So(err, ShouldBeNil)
+			So(data, ShouldNotBeNil)
+		}
+		So(fmt.Sprintf("%v", err) == "dao oauth2 userinfo: -907", ShouldBeTrue)
+	})
+}

app/interface/main/account/dao/vip/oauth2_client.go

@@ -0,0 +1,95 @@
+package vip
+
+import (
+	"bytes"
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	xhttp "net/http"
+	"net/url"
+	"strings"
+
+	"go-common/library/conf/env"
+	bm "go-common/library/net/http/blademaster"
+
+	pkgerr "github.com/pkg/errors"
+)
+
+//Clientl Client is http client, for url sign.
+type Clientl struct {
+	client *bm.Client
+	conf   *bm.ClientConfig
+}
+
+// NewClientl new a http client.
+func NewClientl(c *bm.ClientConfig, client *bm.Client) *Clientl {
+	// check appkey
+	if c.Key == "" || c.Secret == "" {
+		panic("http client must config appkey and appsecret")
+	}
+	cl := new(Clientl)
+	cl.client = client
+	cl.conf = c
+	return cl
+}
+
+const (
+	_httpHeaderRemoteIP = "x-backend-bili-real-ip"
+	_noKickUserAgent    = "haoguanwei@bilibili.com "
+)
+
+func (cl *Clientl) get(c context.Context, host, path, realIP string, params url.Values, res interface{}) (err error) {
+	req, err := cl.newGetRequest(host, path, realIP, params)
+	if err != nil {
+		return
+	}
+	return cl.client.Do(c, req, res)
+}
+
+// newGetRequest new get http request with  host, path, ip, values and headers, without sign.
+func (cl *Clientl) newGetRequest(host, path, realIP string, params url.Values) (req *xhttp.Request, err error) {
+	if params == nil {
+		params = url.Values{}
+	}
+	params.Add("client_id", cl.conf.App.Key)
+	enc := sign(params, path, cl.conf.App.Secret)
+	ru := host + path
+	if enc != "" {
+		ru = ru + "?" + enc
+	}
+	req, err = xhttp.NewRequest(xhttp.MethodGet, ru, nil)
+	if err != nil {
+		err = pkgerr.Wrapf(err, "uri:%s", ru)
+		return
+	}
+	const (
+		_userAgent = "User-Agent"
+	)
+	if realIP != "" {
+		req.Header.Set(_httpHeaderRemoteIP, realIP)
+	}
+	req.Header.Set(_userAgent, _noKickUserAgent+" "+env.AppID)
+	return
+}
+
+func sign(params url.Values, path, secret string) string {
+	if params == nil {
+		params = url.Values{}
+	}
+	tmp := params.Encode()
+	if strings.IndexByte(tmp, '+') > -1 {
+		tmp = strings.Replace(tmp, "+", "%20", -1)
+	}
+	var b bytes.Buffer
+	b.WriteString(path)
+	b.WriteString("?")
+	b.WriteString(tmp)
+	b.WriteString(secret)
+	mh := md5.Sum(b.Bytes())
+	// query
+	var qb bytes.Buffer
+	qb.WriteString(tmp)
+	qb.WriteString("&sign=")
+	qb.WriteString(hex.EncodeToString(mh[:]))
+	return qb.String()
+}

app/interface/main/account/dao/vip/oauth2_client_test.go

@@ -0,0 +1,24 @@
+package vip
+
+import (
+	"net/url"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestVipsign(t *testing.T) {
+	convey.Convey("sign", t, func(convCtx convey.C) {
+		var (
+			params url.Values
+			path   = ""
+			secret = ""
+		)
+		convCtx.Convey("When everything goes positive", func(convCtx convey.C) {
+			p1 := sign(params, path, secret)
+			convCtx.Convey("Then p1 should not be nil.", func(convCtx convey.C) {
+				convCtx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}

app/interface/main/account/dao/vip/vip_test.go

@@ -0,0 +1,29 @@
+package vip
+
+import (
+	"context"
+	"testing"
+
+	vipmol "go-common/app/service/main/vip/model"
+	"go-common/library/ecode"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_CodeVerify(t *testing.T) {
+	Convey("code verify", t, func() {
+		_, err := d.CodeVerify(context.TODO())
+		So(err, ShouldBeNil)
+	})
+}
+
+//  go test  -test.v -test.run TestDaoCancelUseCoupon
+func TestDaoCancelUseCoupon(t *testing.T) {
+	Convey("TestDaoCancelUseCoupon", t, func() {
+		err := d.CancelUseCoupon(context.TODO(), &vipmol.ArgCancelUseCoupon{
+			CouponToken: "672889783020180721180426",
+			Mid:         1,
+		})
+		So(err == ecode.CouPonTokenNotFoundErr, ShouldBeTrue)
+	})
+}