Create & Init Project...

app/service/main/passport-game/dao/BUILD

@@ -0,0 +1,62 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "cache.go",
+        "dao.go",
+        "mc.go",
+        "mysql.go",
+    ],
+    importpath = "go-common/app/service/main/passport-game/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/main/passport-game/conf:go_default_library",
+        "//app/service/main/passport-game/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql: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",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "api_test.go",
+        "cache_test.go",
+        "dao_test.go",
+        "mc_test.go",
+        "mysql_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/passport-game/conf:go_default_library",
+        "//app/service/main/passport-game/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/passport-game/dao/api.go

@@ -0,0 +1,396 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"go-common/app/service/main/passport-game/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+)
+
+// MyInfo get info from api.
+func (d *Dao) MyInfo(c context.Context, accessKey string) (accountInfo *model.Info, err error) {
+	params := url.Values{}
+	params.Set("access_key", accessKey)
+	params.Set("type", "json")
+	var res struct {
+		Code int `json:"code"`
+		model.Info
+	}
+	if err = d.client.Get(c, d.myInfoURI, metadata.String(c, metadata.RemoteIP), params, &res); err != nil {
+		log.Error("myInfo url(%s) error(%v)", d.myInfoURI+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("myInfo url(%s) error(%v)", d.myInfoURI+"?"+params.Encode(), err)
+		return
+	}
+	accountInfo = &res.Info
+	return
+}
+
+// Oauth oauth via passport api.
+func (d *Dao) Oauth(c context.Context, uri, accessKey, from string) (token *model.Token, err error) {
+	params := url.Values{}
+	params.Set("access_key", accessKey)
+	params.Set("from", from)
+	var res struct {
+		Code  int `json:"code"`
+		Token *struct {
+			Mid         string `json:"mid"`
+			AppID       int32  `json:"appid"`
+			AccessToken string `json:"access_key"`
+			CreateAt    int64  `json:"create_at"`
+			UserID      string `json:"userid"`
+			Uname       string `json:"uname"`
+			Expires     string `json:"expires"`
+			Permission  string `json:"permission"`
+		} `json:"access_info,omitempty"`
+		Data *model.Token `json:"data,omitempty"`
+	}
+	if err = d.client.Get(c, uri, metadata.String(c, metadata.RemoteIP), params, &res); err != nil {
+		log.Error("model oauth url(%s) error(%v)", uri+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("model oauth url(%s) error(%v)", uri+"?"+params.Encode(), err)
+		return
+	}
+	if res.Token != nil {
+		t := res.Token
+		var mid int64
+		if mid, err = strconv.ParseInt(t.Mid, 10, 64); err != nil {
+			log.Error("strconv.ParseInt(%s, 10, 64) error(%v)", t.Mid, err)
+			return
+		}
+		var expires int64
+		if expires, err = strconv.ParseInt(t.Expires, 10, 64); err != nil {
+			log.Error("strconv.ParseInt(%s, 10, 64) error(%v)", t.Expires, err)
+			return
+		}
+		token = &model.Token{
+			Mid:         mid,
+			AppID:       t.AppID,
+			AccessToken: t.AccessToken,
+			CreateAt:    t.CreateAt,
+			UserID:      t.UserID,
+			Uname:       t.Uname,
+			Expires:     expires,
+			Permission:  t.Permission,
+		}
+	} else {
+		token = res.Data
+	}
+	return
+}
+
+// Login login via model api.
+func (d *Dao) Login(c context.Context, query, cookie string) (loginToken *model.LoginToken, err error) {
+	req, err := http.NewRequest("GET", d.loginURI+"?"+query, nil)
+	if err != nil {
+		log.Error("http.NewRequest(GET, %s) error(%v)", d.loginURI+"?"+query, err)
+		return
+	}
+	req.Header.Set("Cookie", cookie)
+	req.Header.Set("X-BACKEND-BILI-REAL-IP", metadata.String(c, metadata.RemoteIP))
+	var res struct {
+		Code      int    `json:"code"`
+		Mid       int64  `json:"mid"`
+		AccessKey string `json:"access_key"`
+		Expires   int64  `json:"expires"`
+	}
+	if err = d.client.Do(c, req, &res); err != nil {
+		log.Error("model login url(%s) error(%v)", d.loginURI+"?"+query, err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("model login url(%s) error(%v)", d.loginURI+"?"+query, err)
+		return
+	}
+	loginToken = &model.LoginToken{
+		Mid:       res.Mid,
+		AccessKey: res.AccessKey,
+		Expires:   res.Expires,
+	}
+	return
+}
+
+// LoginOrigin login via passport api.
+func (d *Dao) LoginOrigin(c context.Context, userid, rsaPwd string) (loginToken *model.LoginToken, err error) {
+	params := url.Values{}
+	params.Set("userid", userid)
+	params.Set("pwd", rsaPwd)
+	var res struct {
+		Code      int    `json:"code"`
+		Mid       int64  `json:"mid"`
+		AccessKey string `json:"access_key"`
+		Expires   int64  `json:"expires"`
+	}
+	if err = d.client.Get(c, d.loginURI, metadata.String(c, metadata.RemoteIP), params, &res); err != nil {
+		log.Error("login url(%s) error(%v)", d.loginURI+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("login url(%s) error(%v)", d.loginURI+"?"+params.Encode(), err)
+		return
+	}
+
+	str, _ := json.Marshal(res)
+	log.Info("login url(%s) res(%s)", d.loginURI+"?"+params.Encode(), str)
+
+	loginToken = &model.LoginToken{
+		Mid:       res.Mid,
+		AccessKey: res.AccessKey,
+		Expires:   res.Expires,
+	}
+	return
+}
+
+// RSAKeyOrigin get rsa pub key and ts hash via passport api.
+func (d *Dao) RSAKeyOrigin(c context.Context) (key *model.RSAKey, err error) {
+	var res struct {
+		*model.RSAKey
+		Code int `json:"code"`
+	}
+	params := url.Values{}
+	if err = d.client.Get(c, d.getKeyURI, metadata.String(c, metadata.RemoteIP), params, &res); err != nil {
+		log.Error("key url(%s) error(%v)", d.getKeyURI+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("key url(%s) error(%v)", d.getKeyURI+"?"+params.Encode(), err)
+		return
+	}
+	key = res.RSAKey
+	return
+}
+
+// RenewToken renew token via passport api.
+func (d *Dao) RenewToken(c context.Context, uri, ak, from string) (renewToken *model.RenewToken, err error) {
+	params := url.Values{}
+	params.Set("access_key", ak)
+	params.Set("from", from)
+	var res struct {
+		Code    int   `json:"code"`
+		Expires int64 `json:"expires"`
+		Data    struct {
+			Expires int64 `json:"expires"`
+		}
+	}
+	if err = d.client.Get(c, uri, metadata.String(c, metadata.RemoteIP), params, &res); err != nil {
+		log.Error("renewtoken url(%s) error(%v)", uri+"?"+params.Encode(), err)
+		return
+	}
+	if res.Code != 0 {
+		err = ecode.Int(res.Code)
+		log.Error("renewtoken url(%s) error(%v)", uri+"?"+params.Encode(), err)
+		return
+	}
+	expires := res.Expires
+	if expires == 0 {
+		expires = res.Data.Expires
+	}
+	renewToken = &model.RenewToken{
+		Expires: expires,
+	}
+	return
+}
+
+// RegV3 RegV3
+func (d *Dao) RegV3(c context.Context, tdoRegV3 model.TdoRegV3) (regV3 *model.ResRegV3, err error) {
+	p := url.Values{}
+	p.Add("userpwd", tdoRegV3.Arg.Pwd)
+	p.Add("userid", tdoRegV3.Arg.User)
+	p.Add("captcha", tdoRegV3.Arg.Captcha)
+	p.Add("ctoken", tdoRegV3.Arg.Ctoken)
+	req, err := d.client.NewRequest(http.MethodPost, d.regV3URI, tdoRegV3.IP, p)
+	if err != nil {
+		log.Error("client.NewRequest(GET, %s) error(%v)", req.URL.String(), err)
+		return
+	}
+
+	req.Header.Set("X-Forwarded-For", tdoRegV3.IP)
+	req.Header.Set("Cookie", tdoRegV3.Cookie)
+	var response struct {
+		Code int `json:"code"`
+		Mid  int `json:"mid"`
+	}
+	if err = d.client.Do(c, req, &response); err != nil {
+		log.Error("client.Do(%s) error(%v)", req.URL.String(), err)
+		return
+	}
+	if response.Code != ecode.OK.Code() {
+		log.Warn("regv3 url(%s) code(%d)", req.URL.String(), response.Code)
+		err = ecode.Int(response.Code)
+		return
+	}
+	regV3 = new(model.ResRegV3)
+	regV3.Mid = response.Mid
+	return
+}
+
+// RegV2 RegV2
+func (d *Dao) RegV2(c context.Context, tdoRegV2 model.TdoRegV2) (regV2 *model.ResRegV2, err error) {
+	p := url.Values{}
+	p.Add("captcha", tdoRegV2.Arg.Captcha)
+	p.Add("ctoken", tdoRegV2.Arg.Ctoken)
+	req, err := d.client.NewRequest(http.MethodPost, d.regV2URI, tdoRegV2.IP, p)
+	if err != nil {
+		log.Error("client.NewRequest(GET, %s) error(%v)", req.URL.String(), err)
+		return
+	}
+
+	req.Header.Set("X-Forwarded-For", tdoRegV2.IP)
+	req.Header.Set("Cookie", tdoRegV2.Cookie)
+	var response struct {
+		Code      int    `json:"code"`
+		Mid       int    `json:"mid"`
+		AccessKey string `json:"access_key"`
+	}
+	if err = d.client.Do(c, req, &response); err != nil {
+		log.Error("client.Do(%s) error(%v)", req.URL.String(), err)
+		return
+	}
+	if response.Code != ecode.OK.Code() {
+		log.Warn("reg v2 url(%s) code(%d)", req.URL.String(), response.Code)
+		err = ecode.Int(response.Code)
+		return
+	}
+	regV2 = new(model.ResRegV2)
+	regV2.Mid = response.Mid
+	regV2.AccessKey = response.AccessKey
+	return
+}
+
+// Reg Reg
+func (d *Dao) Reg(c context.Context, tdoReg model.TdoReg) (reg *model.ResReg, err error) {
+	p := url.Values{}
+	p.Add("userpwd", tdoReg.Arg.Userpwd)
+	p.Add("user", tdoReg.Arg.User)
+	p.Add("email", tdoReg.Arg.Email)
+
+	// new request
+	req, err := d.client.NewRequest(http.MethodPost, d.regURI, tdoReg.IP, p)
+	if err != nil {
+		log.Error("client.NewRequest(GET, %s) error(%v)", req.URL.String(), err)
+		return
+	}
+
+	req.Header.Set("X-Forwarded-For", tdoReg.IP)
+	req.Header.Set("Cookie", tdoReg.Cookie)
+	var response struct {
+		Code int `json:"code"`
+		Mid  int `json:"mid"`
+	}
+	if err = d.client.Do(c, req, &response); err != nil {
+		log.Error("client.Do(%s) error(%v)", req.URL.String(), err)
+		return
+	}
+	if response.Code != ecode.OK.Code() {
+		log.Warn("reg url(%s) code(%d)", req.URL.String(), response.Code)
+		err = ecode.Int(response.Code)
+		return
+	}
+	reg = new(model.ResReg)
+	reg.Mid = response.Mid
+	return
+}
+
+// ByTel ByTel
+func (d *Dao) ByTel(c context.Context, tdoByTel model.TdoByTel) (byTel *model.ResByTel, err error) {
+
+	p := url.Values{}
+	p.Add("userpwd", tdoByTel.Arg.Userpwd)
+	p.Add("tel", tdoByTel.Arg.Tel)
+	p.Add("captcha", tdoByTel.Arg.Captcha)
+	p.Add("country_id", tdoByTel.Arg.CountryID)
+	p.Add("uname", tdoByTel.Arg.Uname)
+
+	// new request
+	req, err := d.client.NewRequest(http.MethodPost, d.byTelURI, tdoByTel.IP, p)
+	if err != nil {
+		log.Error("client.NewRequest(GET, %s) error(%v)", req.URL.String(), err)
+		return
+	}
+
+	req.Header.Set("X-Forwarded-For", tdoByTel.IP)
+	req.Header.Set("Cookie", tdoByTel.Cookie)
+	var response struct {
+		Code int `json:"code"`
+		Data struct {
+			Mid       int    `json:"mid"`
+			AccessKey string `json:"access_key"`
+		}
+	}
+
+	if err = d.client.Do(c, req, &response); err != nil {
+		log.Error("client.Do(%s) error(%v)", req.URL.String(), err)
+		return
+	}
+	if response.Code != ecode.OK.Code() {
+		log.Warn("byTel url(%s) code(%d)", req.URL.String(), response.Code)
+		err = ecode.Int(response.Code)
+		return
+	}
+	byTel = new(model.ResByTel)
+	byTel.Mid = response.Data.Mid
+	byTel.AccessKey = response.Data.AccessKey
+	return
+}
+
+// Captcha Captcha
+func (d *Dao) Captcha(c context.Context, ip string) (captchaData *model.CaptchaData, err error) {
+	p := url.Values{}
+	req, err := d.client.NewRequest(http.MethodGet, d.captchaURI, ip, p)
+	if err != nil {
+		log.Error("client.NewRequest(GET, %s) error(%v)", req.URL.String(), err)
+		return
+	}
+	resCaptcha := new(model.ResCaptcha)
+
+	req.Header.Set("X-Forwarded-For", ip)
+	if err = d.client.Do(c, req, &resCaptcha); err != nil {
+		log.Error("client.Do(%s) error(%v)", req.URL.String(), err)
+		return
+	}
+
+	err = ecode.Int(resCaptcha.Code)
+	captchaData = &resCaptcha.Data
+	return
+}
+
+// SendSms SendSms
+func (d *Dao) SendSms(c context.Context, tdoSendSms model.TdoSendSms) (err error) {
+	p := url.Values{}
+	p.Add("captcha", tdoSendSms.Arg.Captcha)
+	p.Add("tel", tdoSendSms.Arg.Tel)
+	p.Add("country_id", tdoSendSms.Arg.CountryID)
+	p.Add("ctoken", tdoSendSms.Arg.Ctoken)
+	p.Add("reset_pwd", strconv.FormatBool(tdoSendSms.Arg.ResetPwd))
+	req, err := d.client.NewRequest(http.MethodGet, d.sendSmsURI, tdoSendSms.IP, p)
+	if err != nil {
+		log.Error("client.NewRequest(GET, %s) error(%v)", req.URL.String(), err)
+		return
+	}
+
+	req.Header.Set("X-Forwarded-For", tdoSendSms.IP)
+	req.Header.Set("Cookie", tdoSendSms.Cookie)
+	resCaptcha := new(model.ResCaptcha)
+	if err = d.client.Do(c, req, &resCaptcha); err != nil {
+		log.Error("client.Do(%s) error(%v)", req.URL.String(), err)
+		return
+	}
+
+	err = ecode.Int(resCaptcha.Code)
+	return
+}

app/service/main/passport-game/dao/api_test.go

@@ -0,0 +1,97 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoMyInfo(t *testing.T) {
+	var (
+		c         = context.TODO()
+		accessKey = "123456"
+	)
+	convey.Convey("MyInfo", t, func(ctx convey.C) {
+		accountInfo, err := d.MyInfo(c, accessKey)
+		ctx.Convey("Then err should be nil.accountInfo should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(accountInfo, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoOauth(t *testing.T) {
+	var (
+		c         = context.TODO()
+		uri       = "https://wwww.baidu.com"
+		accessKey = "123456"
+		from      = "baidu"
+	)
+	convey.Convey("Oauth", t, func(ctx convey.C) {
+		token, err := d.Oauth(c, uri, accessKey, from)
+		ctx.Convey("Then err should be nil.token should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(token, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoLogin(t *testing.T) {
+	var (
+		c      = context.TODO()
+		query  = "123"
+		cookie = "123"
+	)
+	convey.Convey("Login", t, func(ctx convey.C) {
+		loginToken, err := d.Login(c, query, cookie)
+		ctx.Convey("Then err should be nil.loginToken should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(loginToken, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoLoginOrigin(t *testing.T) {
+	var (
+		c      = context.TODO()
+		userid = "1"
+		rsaPwd = "123456"
+	)
+	convey.Convey("LoginOrigin", t, func(ctx convey.C) {
+		loginToken, err := d.LoginOrigin(c, userid, rsaPwd)
+		ctx.Convey("Then err should be nil.loginToken should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(loginToken, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoRSAKeyOrigin(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("RSAKeyOrigin", t, func(ctx convey.C) {
+		key, err := d.RSAKeyOrigin(c)
+		ctx.Convey("Then err should be nil.key should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(key, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoRenewToken(t *testing.T) {
+	var (
+		c    = context.TODO()
+		uri  = "https://wwww.baidu.com"
+		ak   = "234"
+		from = "234"
+	)
+	convey.Convey("RenewToken", t, func(ctx convey.C) {
+		renewToken, err := d.RenewToken(c, uri, ak, from)
+		ctx.Convey("Then err should be nil.renewToken should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(renewToken, convey.ShouldBeNil)
+		})
+	})
+}

app/service/main/passport-game/dao/cache.go

@@ -0,0 +1,36 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"go-common/app/service/main/passport-game/model"
+	"go-common/library/log"
+)
+
+// TokenPBCache get token pb cache.
+func (d *Dao) TokenPBCache(c context.Context, key string) (res *model.Perm, err error) {
+	if !strings.HasPrefix(key, _keyPrefixTokenPB) {
+		err = fmt.Errorf("invalid cache key %s, key pattern is %s{token}", key, _keyPrefixInfoPB)
+		return
+	}
+	token := key[len(_keyPrefixTokenPB):]
+	return d.TokenCache(c, token)
+}
+
+// InfoPBCache get info pb cache.
+func (d *Dao) InfoPBCache(c context.Context, key string) (res *model.Info, err error) {
+	if !strings.HasPrefix(key, _keyPrefixInfoPB) {
+		err = fmt.Errorf("invalid cache key %s, key pattern is %s{mid}", key, _keyPrefixInfoPB)
+		return
+	}
+	midStr := key[len(_keyPrefixInfoPB):]
+	mid, err := strconv.ParseInt(midStr, 10, 64)
+	if err != nil {
+		log.Error("strconv.ParseInt(%s, 10, 64) error(%v)", midStr, err)
+		return
+	}
+	return d.InfoCache(c, mid)
+}

app/service/main/passport-game/dao/cache_test.go

@@ -0,0 +1,36 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaoTokenPBCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		key = "123456"
+	)
+	convey.Convey("TokenPBCache", t, func(ctx convey.C) {
+		res, err := d.TokenPBCache(c, key)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoInfoPBCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		key = "123456"
+	)
+	convey.Convey("InfoPBCache", t, func(ctx convey.C) {
+		res, err := d.InfoPBCache(c, key)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}

app/service/main/passport-game/dao/dao.go

@@ -0,0 +1,96 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"go-common/app/service/main/passport-game/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+)
+
+// Dao dao
+type Dao struct {
+	c             *conf.Config
+	getMemberStmt []*sql.Stmt
+	cloudDB       *sql.DB
+	otherRegion   *sql.DB
+	mc            *memcache.Pool
+	mcExpire      int32
+	client        *bm.Client
+	myInfoURI     string
+	loginURI      string
+	getKeyURI     string
+	regV3URI      string
+	regV2URI      string
+	regURI        string
+	byTelURI      string
+	captchaURI    string
+	sendSmsURI    string
+}
+
+const (
+	_myInfoURI  = "/api/myinfo"
+	_loginURI   = "/api/login"
+	_getKeyURI  = "/api/login/get_key"
+	_regV3URI   = "/api/reg/regV3"
+	_regV2URI   = "/api/reg/regV2"
+	_regURI     = "/api/reg/reg"
+	_byTelURI   = "/api/reg/byTelGame"
+	_captchaURI = "/bilicaptcha/token"
+	_sendSmsURI = "/api/sms/sendCaptcha"
+)
+
+// New dao
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		c:           c,
+		cloudDB:     sql.NewMySQL(c.DB.Cloud),
+		otherRegion: sql.NewMySQL(c.DB.OtherRegion),
+		mc:          memcache.NewPool(c.Memcache.Config),
+		mcExpire:    int32(time.Duration(c.Memcache.Expire) / time.Second),
+		client:      bm.NewClient(c.HTTPClient),
+		myInfoURI:   c.AccountURI + _myInfoURI,
+		loginURI:    c.PassportURI + _loginURI,
+		getKeyURI:   c.PassportURI + _getKeyURI,
+		regV3URI:    c.PassportURI + _regV3URI,
+		regV2URI:    c.PassportURI + _regV2URI,
+		regURI:      c.PassportURI + _regURI,
+		byTelURI:    c.PassportURI + _byTelURI,
+		captchaURI:  c.PassportURI + _captchaURI,
+		sendSmsURI:  c.PassportURI + _sendSmsURI,
+	}
+	d.getMemberStmt = make([]*sql.Stmt, _memberShard)
+	for i := 0; i < _memberShard; i++ {
+		d.getMemberStmt[i] = d.cloudDB.Prepared(fmt.Sprintf(_getMemberInfoSQL, i))
+	}
+	return
+}
+
+// Ping verify server is ok.
+func (d *Dao) Ping(c context.Context) (err error) {
+	if err = d.cloudDB.Ping(c); err != nil {
+		log.Info("dao.cloudDB.Ping() error(%v)", err)
+	}
+	if err = d.otherRegion.Ping(c); err != nil {
+		log.Info("dao.otherRegion.Ping() error(%v)", err)
+	}
+	return d.pingMC(c)
+}
+
+// Close close connections of mc, cloudDB.
+func (d *Dao) Close() (err error) {
+	if d.cloudDB != nil {
+		d.cloudDB.Close()
+	}
+	if d.otherRegion != nil {
+		d.otherRegion.Close()
+	}
+	if d.mc != nil {
+		d.mc.Close()
+	}
+	return
+}

app/service/main/passport-game/dao/dao_test.go

@@ -0,0 +1,34 @@
+package dao
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	"go-common/app/service/main/passport-game/conf"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "dev" {
+		flag.Set("app_id", "main.account.passport-game-service")
+		flag.Set("conf_token", "6461f64e47f084a2c9bbd505182dbe39")
+		flag.Set("tree_id", "3791")
+		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")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	m.Run()
+	os.Exit(0)
+}

app/service/main/passport-game/dao/mc.go

@@ -0,0 +1,243 @@
+package dao
+
+import (
+	"context"
+	"math/rand"
+	"strconv"
+
+	"go-common/app/service/main/passport-game/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+const (
+	_keyPrefixInfoPB              = "pa2_"
+	_keyPrefixTokenPB             = "pt_"
+	_keyPrefixOriginMissMatchFlag = "m_"
+	_keyPrefixOriginToken         = "pot_"
+
+	_missMatchFlagExpireSeconds = 30 // 30 seconds
+)
+
+func keyInfoPB(mid int64) string {
+	return _keyPrefixInfoPB + strconv.FormatInt(mid, 10)
+}
+
+func keyTokenPB(accessToken string) string {
+	return _keyPrefixTokenPB + accessToken
+}
+
+func keyOriginToken(accessToken string) string {
+	return _keyPrefixOriginToken + accessToken
+}
+
+func keyOriginMissMatchFlag(identify string) string {
+	return _keyPrefixOriginMissMatchFlag + identify
+}
+
+// pingMC check connection success.
+func (d *Dao) pingMC(c context.Context) (err error) {
+	item := &memcache.Item{
+		Key:        "ping",
+		Value:      []byte{1},
+		Expiration: d.mcExpire,
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%v) error(%v)", item, err)
+	}
+	return
+}
+
+// SetInfoCache set info into cache.
+func (d *Dao) SetInfoCache(c context.Context, info *model.Info) (err error) {
+	item := &memcache.Item{
+		Key:        keyInfoPB(info.Mid),
+		Object:     info,
+		Flags:      memcache.FlagProtobuf,
+		Expiration: d.mcExpire,
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%s) error(%v)", item.Key, err)
+	}
+	return
+}
+
+// InfoCache get info cache from cache.
+func (d *Dao) InfoCache(c context.Context, mid int64) (info *model.Info, err error) {
+	key := keyInfoPB(mid)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	var item *memcache.Item
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("conn.Get(%s) error(%v)", key, err)
+		return
+	}
+	info = new(model.Info)
+	if err = conn.Scan(item, info); err != nil {
+		log.Error("conn.Scan(%s, %s) error(%v)", key, item.Value, err)
+	}
+	return
+}
+
+// SetTokenCache set token into cache.
+func (d *Dao) SetTokenCache(c context.Context, token *model.Perm) (err error) {
+	item := &memcache.Item{
+		Key:        keyTokenPB(token.AccessToken),
+		Object:     token,
+		Flags:      memcache.FlagProtobuf,
+		Expiration: d.mcExpire,
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%s) error(%v)", item.Key, err)
+	}
+	return
+}
+
+// TokenCache get token from cache.
+func (d *Dao) TokenCache(c context.Context, accessToken string) (token *model.Perm, err error) {
+	key := keyTokenPB(accessToken)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("conn.Get(%s) error(%v)", key, err)
+		return
+	}
+	token = new(model.Perm)
+	if err = conn.Scan(item, token); err != nil {
+		log.Error("conn.Scan(%s, %s) error(%v)", item.Key, item.Value, err)
+	}
+	return
+}
+
+// DelTokenCache delete token from cache.
+func (d *Dao) DelTokenCache(c context.Context, accessToken string) (err error) {
+	key := keyTokenPB(accessToken)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("conn.Delete(%s) error(%v)", key, err)
+	}
+	return
+}
+
+// SetOriginMissMatchFlagCache set origin miss match flag cache.
+func (d *Dao) SetOriginMissMatchFlagCache(c context.Context, identify string, flag []byte) (err error) {
+	item := &memcache.Item{
+		Key:        keyOriginMissMatchFlag(identify),
+		Value:      flag,
+		Expiration: _missMatchFlagExpireSeconds,
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%s) error(%v)", item.Key, err)
+	}
+	return
+}
+
+// OriginMissMatchFlagCache get origin miss match flag.
+func (d *Dao) OriginMissMatchFlagCache(c context.Context, identify string) (res []byte, err error) {
+	key := keyOriginMissMatchFlag(identify)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	var item *memcache.Item
+	if item, err = conn.Get(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("conn.Get(%s) error(%v)", key, err)
+		return
+	}
+	res = item.Value
+	return
+}
+
+// DelOriginMissMatchFlagCache delete origin miss match flag.
+func (d *Dao) DelOriginMissMatchFlagCache(c context.Context, identify string) (err error) {
+	key := keyOriginMissMatchFlag(identify)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("conn.Delete(%s) error(%v)", key, err)
+	}
+	return
+}
+
+// SetOriginTokenCache set passport token into cache.
+func (d *Dao) SetOriginTokenCache(c context.Context, token *model.Token) (err error) {
+	item := &memcache.Item{
+		Key:        keyOriginToken(token.AccessToken),
+		Object:     token,
+		Flags:      memcache.FlagJSON,
+		Expiration: 60 + rand.Int31n(600),
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(item); err != nil {
+		log.Error("conn.Set(%s) error(%v)", item.Key, err)
+		return
+	}
+	return
+}
+
+// OriginTokenCache set passport token into cache.
+func (d *Dao) OriginTokenCache(c context.Context, accessToken string) (token *model.Token, err error) {
+	key := keyOriginToken(accessToken)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("conn.Get(%s) error(%v)", key, err)
+		return
+	}
+	token = new(model.Token)
+	if err = conn.Scan(item, token); err != nil {
+		log.Error("conn.Scan(%s, %s) error(%v)", item.Key, item.Value, err)
+		return
+	}
+	return
+}
+
+// DelOriginTokenCache delete passport token from cache.
+func (d *Dao) DelOriginTokenCache(c context.Context, accessToken string) (err error) {
+	key := keyOriginToken(accessToken)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("conn.Delete(%s) error(%v)", key, err)
+		return
+	}
+	return
+}

app/service/main/passport-game/dao/mc_test.go

@@ -0,0 +1,193 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/service/main/passport-game/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaokeyInfoPB(t *testing.T) {
+	var (
+		mid = int64(12)
+	)
+	convey.Convey("keyInfoPB", t, func(ctx convey.C) {
+		p1 := keyInfoPB(mid)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaokeyTokenPB(t *testing.T) {
+	var (
+		accessToken = "123"
+	)
+	convey.Convey("keyTokenPB", t, func(ctx convey.C) {
+		p1 := keyTokenPB(accessToken)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaokeyOriginMissMatchFlag(t *testing.T) {
+	var (
+		identify = "123"
+	)
+	convey.Convey("keyOriginMissMatchFlag", t, func(ctx convey.C) {
+		p1 := keyOriginMissMatchFlag(identify)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaopingMC(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("pingMC", t, func(ctx convey.C) {
+		err := d.pingMC(c)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoSetInfoCache(t *testing.T) {
+	var (
+		c    = context.TODO()
+		info = &model.Info{}
+	)
+	convey.Convey("SetInfoCache", t, func(ctx convey.C) {
+		err := d.SetInfoCache(c, info)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoInfoCache(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(0)
+	)
+	convey.Convey("InfoCache", t, func(ctx convey.C) {
+		info, err := d.InfoCache(c, mid)
+		ctx.Convey("Then err should be nil.info should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(info, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoTokenCache(t *testing.T) {
+	var (
+		c           = context.TODO()
+		accessToken = "123456"
+		token       = &model.Perm{
+			Mid:         -1,
+			AccessToken: accessToken,
+		}
+	)
+	convey.Convey("TestDaoTokenCache", t, func(ctx convey.C) {
+		err := d.SetTokenCache(c, token)
+		ctx.Convey("SetTokenCache", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+
+		token, err := d.TokenCache(c, accessToken)
+		ctx.Convey("TokenCache", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(token, convey.ShouldNotBeNil)
+		})
+
+		err = d.DelTokenCache(c, accessToken)
+		ctx.Convey("DelTokenCache", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+
+		token, err = d.TokenCache(c, accessToken)
+		ctx.Convey("DeletedTokenCache", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(token, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoSetOriginMissMatchFlagCache(t *testing.T) {
+	var (
+		c        = context.TODO()
+		identify = "123456"
+		flag     = []byte("")
+	)
+	convey.Convey("SetOriginMissMatchFlagCache", t, func(ctx convey.C) {
+		err := d.SetOriginMissMatchFlagCache(c, identify, flag)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoOriginMissMatchFlagCache(t *testing.T) {
+	var (
+		c        = context.TODO()
+		identify = "123456"
+	)
+	convey.Convey("OriginMissMatchFlagCache", t, func(ctx convey.C) {
+		res, err := d.OriginMissMatchFlagCache(c, identify)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoDelOriginMissMatchFlagCache(t *testing.T) {
+	var (
+		c        = context.TODO()
+		identify = "123456"
+	)
+	convey.Convey("DelOriginMissMatchFlagCache", t, func(ctx convey.C) {
+		err := d.DelOriginMissMatchFlagCache(c, identify)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoOriginTokenCache(t *testing.T) {
+	var (
+		c           = context.TODO()
+		accessToken = "123456"
+		token       = &model.Token{
+			Mid:         -1,
+			AccessToken: accessToken,
+		}
+	)
+	convey.Convey("TestDaoOriginTokenCache", t, func(ctx convey.C) {
+		err := d.SetOriginTokenCache(c, token)
+		ctx.Convey("SetOriginTokenCache", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+
+		token, err := d.OriginTokenCache(c, accessToken)
+		ctx.Convey("OriginTokenCache", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(token, convey.ShouldNotBeNil)
+		})
+
+		err = d.DelOriginTokenCache(c, accessToken)
+		ctx.Convey("DelOriginTokenCache", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+
+		token, err = d.OriginTokenCache(c, accessToken)
+		ctx.Convey("DeletedOriginTokenCache", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(token, convey.ShouldBeNil)
+		})
+	})
+}

app/service/main/passport-game/dao/mysql.go

@@ -0,0 +1,147 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+
+	"go-common/app/service/main/passport-game/model"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_memberShard       = 30
+	_getMemberInfoSQL  = "SELECT mid,face FROM member_%02d WHERE mid=?"
+	_getAppsSQL        = "SELECT appid,appkey,app_secret FROM app"
+	_addTokenSQL       = "INSERT INTO app_perm (mid,appid,app_subid,access_token,create_at,expires) VALUES (?,?,?,?,?,?)"
+	_updateTokenSQL    = "UPDATE app_perm SET expires=? WHERE access_token=? AND expires<?"
+	_getTokenSQL       = "SELECT mid,appid,app_subid,access_token,create_at,expires FROM app_perm WHERE access_token=?"
+	_getAsoAccountSQL  = "SELECT mid,userid,uname,pwd,salt,isleak FROM aso_account WHERE userid=? OR email=? OR tel=?"
+	_getAccountInfoSQL = "SELECT mid,userid,uname,email,tel FROM aso_account WHERE mid=?"
+)
+
+func hit(mid int64) int64 {
+	return mid % _memberShard
+}
+
+// MemberInfo get member info.
+func (d *Dao) MemberInfo(c context.Context, mid int64) (res *model.Info, err error) {
+	var row = d.getMemberStmt[hit(mid)].QueryRow(c, mid)
+	res = new(model.Info)
+	if err = row.Scan(&res.Mid, &res.Face); err != nil {
+		if err == xsql.ErrNoRows {
+			res = nil
+			err = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}
+
+// Apps get all apps.
+func (d *Dao) Apps(c context.Context) (res []*model.App, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.cloudDB.Query(c, _getAppsSQL); err != nil {
+		log.Error("get apps, dao.cloudDB.Query(%s) error(%v)", _getAppsSQL, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		app := new(model.App)
+		if err = rows.Scan(&app.AppID, &app.AppKey, &app.AppSecret); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			res = nil
+			return
+		}
+		res = append(res, app)
+	}
+	err = rows.Err()
+	return
+}
+
+// AddToken add token.
+func (d *Dao) AddToken(c context.Context, t *model.Perm) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.cloudDB.Exec(c, _addTokenSQL, t.Mid, t.AppID, t.AppSubID, t.AccessToken, t.CreateAt, t.Expires); err != nil {
+		log.Error("add token, dao.cloudDB.Exec(%d, %d, %d, %s, %d, %d) error(%v)", t.Mid, t.AppID, t.AppSubID, t.AccessToken, t.CreateAt, t.Expires, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpdateToken update token.
+func (d *Dao) UpdateToken(c context.Context, t *model.Perm) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.cloudDB.Exec(c, _updateTokenSQL, t.Expires, t.AccessToken, t.Expires); err != nil {
+		log.Error("update token, dao.cloudDB.Exec(%d, %s, %d) error(%v)", t.Expires, t.AccessToken, t.Expires, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// Token get token.
+func (d *Dao) Token(c context.Context, accessToken string) (res *model.Perm, err error) {
+	row := d.cloudDB.QueryRow(c, _getTokenSQL, accessToken)
+	res = new(model.Perm)
+	if err = row.Scan(&res.Mid, &res.AppID, &res.AppSubID, &res.AccessToken, &res.CreateAt, &res.Expires); err != nil {
+		if err == xsql.ErrNoRows {
+			res = nil
+			err = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}
+
+// AsoAccount get aso account.
+func (d *Dao) AsoAccount(c context.Context, identify, identifyHash string) (res []*model.AsoAccount, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.cloudDB.Query(c, _getAsoAccountSQL, identify, identifyHash, identifyHash); err != nil {
+		log.Error("get apps, dao.cloudDB.Query(%s) error(%v)", _getAsoAccountSQL, err)
+		return
+	}
+	for rows.Next() {
+		aso := new(model.AsoAccount)
+		if err = rows.Scan(&aso.Mid, &aso.UserID, &aso.Uname, &aso.Pwd, &aso.Salt, &aso.Isleak); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			res = nil
+			return
+		}
+		res = append(res, aso)
+	}
+	err = rows.Err()
+	return
+}
+
+// AccountInfo get account info.
+func (d *Dao) AccountInfo(c context.Context, mid int64) (res *model.AsoAccount, err error) {
+	row := d.cloudDB.QueryRow(c, _getAccountInfoSQL, mid)
+	res = new(model.AsoAccount)
+	if err = row.Scan(&res.Mid, &res.UserID, &res.Uname, &res.Email, &res.Tel); err != nil {
+		if err == xsql.ErrNoRows {
+			res = nil
+			err = nil
+		} else {
+			log.Error("row.Scan() error(%v)", err)
+		}
+	}
+	return
+}
+
+// TokenFromOtherRegion get token from otherRegion.
+func (d *Dao) TokenFromOtherRegion(c context.Context, accessToken string) (res *model.Perm, err error) {
+	row := d.otherRegion.QueryRow(c, _getTokenSQL, accessToken)
+	res = new(model.Perm)
+	if err = row.Scan(&res.Mid, &res.AppID, &res.AppSubID, &res.AccessToken, &res.CreateAt, &res.Expires); err != nil {
+		if err == xsql.ErrNoRows {
+			res = nil
+			err = nil
+			return
+		}
+		log.Error("row.Scan() error(%v)", err)
+		return
+	}
+	return
+}

app/service/main/passport-game/dao/mysql_test.go

@@ -0,0 +1,133 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/service/main/passport-game/model"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDaohit(t *testing.T) {
+	var (
+		mid = int64(1)
+	)
+	convey.Convey("hit", t, func(ctx convey.C) {
+		p1 := hit(mid)
+		ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+			ctx.So(p1, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoMemberInfo(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("MemberInfo", t, func(ctx convey.C) {
+		res, err := d.MemberInfo(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoApps(t *testing.T) {
+	var (
+		c = context.TODO()
+	)
+	convey.Convey("Apps", t, func(ctx convey.C) {
+		res, err := d.Apps(c)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoAddToken(t *testing.T) {
+	var (
+		c  = context.TODO()
+		no = &model.Perm{}
+	)
+	convey.Convey("AddToken", t, func(ctx convey.C) {
+		affected, err := d.AddToken(c, no)
+		ctx.Convey("Then err should be nil.affected should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldNotBeNil)
+			ctx.So(affected, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoUpdateToken(t *testing.T) {
+	var (
+		c  = context.TODO()
+		no = &model.Perm{}
+	)
+	convey.Convey("UpdateToken", t, func(ctx convey.C) {
+		affected, err := d.UpdateToken(c, no)
+		ctx.Convey("Then err should be nil.affected should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(affected, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoToken(t *testing.T) {
+	var (
+		c           = context.TODO()
+		accessToken = "123456"
+	)
+	convey.Convey("Token", t, func(ctx convey.C) {
+		res, err := d.Token(c, accessToken)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoAsoAccount(t *testing.T) {
+	var (
+		c            = context.TODO()
+		identify     = "123456"
+		identifyHash = "654321"
+	)
+	convey.Convey("AsoAccount", t, func(ctx convey.C) {
+		res, err := d.AsoAccount(c, identify, identifyHash)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoAccountInfo(t *testing.T) {
+	var (
+		c   = context.TODO()
+		mid = int64(1)
+	)
+	convey.Convey("AccountInfo", t, func(ctx convey.C) {
+		res, err := d.AccountInfo(c, mid)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}
+
+func TestDaoTokenFromOtherRegion(t *testing.T) {
+	var (
+		c           = context.TODO()
+		accessToken = "123456"
+	)
+	convey.Convey("TokenFromOtherRegion", t, func(ctx convey.C) {
+		res, err := d.TokenFromOtherRegion(c, accessToken)
+		ctx.Convey("Then err should be nil.res should not be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+			ctx.So(res, convey.ShouldBeNil)
+		})
+	})
+}