Create & Init Project...

app/job/main/passport-sns/dao/BUILD

@@ -0,0 +1,62 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "aso_test.go",
+        "dao_test.go",
+        "mc_test.go",
+        "qq_test.go",
+        "sns_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/job/main/passport-sns/conf:go_default_library",
+        "//app/job/main/passport-sns/model:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//vendor/github.com/bouk/monkey:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "aso.go",
+        "dao.go",
+        "mc.go",
+        "qq.go",
+        "sns.go",
+    ],
+    importpath = "go-common/app/job/main/passport-sns/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/passport-sns/conf:go_default_library",
+        "//app/job/main/passport-sns/model:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log: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/job/main/passport-sns/dao/aso.go

@@ -0,0 +1,67 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+
+	"go-common/app/job/main/passport-sns/model"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_addSnsLogSQL = "INSERT INTO sns_log (mid,openid,unionid,appid,platform,operator,operate,description) VALUES(?,?,?,?,?,?,?,?)"
+
+	_getAsoAccountSnsAllSQL = "SELECT mid,sina_uid,sina_access_token,sina_access_expires,qq_openid,qq_access_token,qq_access_expires FROM aso_account_sns WHERE mid > ? order by mid limit 20000"
+	_getAsoAccountSnsSQL    = "SELECT mid,sina_uid,sina_access_token,sina_access_expires,qq_openid,qq_access_token,qq_access_expires FROM aso_account_sns WHERE (qq_openid != '' or sina_uid != 0) and mid > ? order by mid limit 20000"
+)
+
+// AddSnsLog add sns log.
+func (d *Dao) AddSnsLog(c context.Context, a *model.SnsLog) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.snsDB.Exec(c, _addSnsLogSQL, a.Mid, a.OpenID, a.UnionID, a.AppID, a.Platform, a.Operator, a.Operate, a.Description); err != nil {
+		log.Error("AddSnsLog(%+v) tx.Exec() error(%+v)", a, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// AsoAccountSnsAll get account sns
+func (d *Dao) AsoAccountSnsAll(c context.Context, start int64) (res []*model.AsoAccountSns, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.asoDB.Query(c, _getAsoAccountSnsAllSQL, start); err != nil {
+		log.Error("fail to get AsoAccountSns, dao.asoDB.Query() error(%+v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.AsoAccountSns)
+		if err = rows.Scan(&r.Mid, &r.SinaUID, &r.SinaAccessToken, &r.SinaAccessExpires, &r.QQOpenid, &r.QQAccessToken, &r.QQAccessExpires); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// AsoAccountSns get account sns by id.
+func (d *Dao) AsoAccountSns(c context.Context, start int64) (res []*model.AsoAccountSns, err error) {
+	var rows *xsql.Rows
+	if rows, err = d.asoDB.Query(c, _getAsoAccountSnsSQL, start); err != nil {
+		log.Error("fail to get AsoAccountSns, dao.asoDB.Query() error(%+v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(model.AsoAccountSns)
+		if err = rows.Scan(&r.Mid, &r.SinaUID, &r.SinaAccessToken, &r.SinaAccessExpires, &r.QQOpenid, &r.QQAccessToken, &r.QQAccessExpires); err != nil {
+			log.Error("row.Scan() error(%v)", err)
+			res = nil
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}

app/job/main/passport-sns/dao/aso_test.go

@@ -0,0 +1,70 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+	"database/sql/driver"
+	"reflect"
+	"testing"
+
+	"go-common/app/job/main/passport-sns/model"
+	xsql "go-common/library/database/sql"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_AddSnsLog(t *testing.T) {
+	convey.Convey("AddSnsLog", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			a = &model.SnsLog{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(d.asoDB), "Exec", func(_ *xsql.DB, _ context.Context, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.AddSnsLog(c, a)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+			ctx.Convey("Then affected should not be nil.", func(ctx convey.C) {
+				ctx.So(affected, convey.ShouldNotBeNil)
+			})
+		})
+
+	})
+}
+
+func TestDao_AsoAccountSns(t *testing.T) {
+	convey.Convey("AsoAccountSns", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			start = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.AsoAccountSns(c, start)
+			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 TestDao_AsoAccountSnsAll(t *testing.T) {
+	convey.Convey("AsoAccountSnsAll", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			start = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.AsoAccountSnsAll(c, start)
+			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)
+			})
+		})
+	})
+}

app/job/main/passport-sns/dao/dao.go

@@ -0,0 +1,54 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/job/main/passport-sns/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/database/sql"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+// Dao dao
+type Dao struct {
+	c        *conf.Config
+	asoDB    *xsql.DB
+	snsDB    *xsql.DB
+	mc       *memcache.Pool
+	mcExpire int32
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:        c,
+		asoDB:    xsql.NewMySQL(c.DB.Aso),
+		snsDB:    xsql.NewMySQL(c.DB.Sns),
+		mc:       memcache.NewPool(c.Memcache.Config),
+		mcExpire: int32(time.Duration(c.Memcache.Expire) / time.Second),
+	}
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() (err error) {
+	if err = d.asoDB.Close(); err != nil {
+		log.Error("srv.asoDB.Close() error(%v)", err)
+	}
+	if err = d.snsDB.Close(); err != nil {
+		log.Error("srv.snsDB.Close() error(%v)", err)
+	}
+	return
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	return nil
+}
+
+// BeginSnsTran begin sns transcation.
+func (d *Dao) BeginSnsTran(c context.Context) (tx *sql.Tx, err error) {
+	return d.snsDB.Begin(c)
+}

app/job/main/passport-sns/dao/dao_test.go

@@ -0,0 +1,68 @@
+package dao
+
+import (
+	"context"
+	"flag"
+	"os"
+	"reflect"
+	"testing"
+
+	"go-common/app/job/main/passport-sns/conf"
+	"go-common/library/database/sql"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	d *Dao
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("DEPLOY_ENV") != "" {
+		flag.Set("app_id", "main.passport.passport-sns-job")
+		flag.Set("conf_token", "5aa702b77df8a25d5af539aea08b2d03")
+		flag.Set("tree_id", "80868")
+		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/passport-sns-job.toml")
+	}
+	flag.Parse()
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	d = New(conf.Conf)
+	os.Exit(m.Run())
+}
+
+func TestDaoPing(t *testing.T) {
+	var c = context.Background()
+	convey.Convey("Ping", t, func(ctx convey.C) {
+		err := d.Ping(c)
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}
+
+func TestDaoClose(t *testing.T) {
+	convey.Convey("Close", t, func(ctx convey.C) {
+		monkey.PatchInstanceMethod(reflect.TypeOf(d.asoDB), "Close", func(_ *sql.DB) error {
+			return nil
+		})
+		monkey.PatchInstanceMethod(reflect.TypeOf(d.snsDB), "Close", func(_ *sql.DB) error {
+			return nil
+		})
+		defer monkey.UnpatchAll()
+		var err error
+		d.Close()
+		ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+			ctx.So(err, convey.ShouldBeNil)
+		})
+	})
+}

app/job/main/passport-sns/dao/mc.go

@@ -0,0 +1,58 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/app/job/main/passport-sns/model"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+)
+
+func snsKey(platform string, mid int64) string {
+	return fmt.Sprintf("sns_%s_%d", platform, mid)
+}
+
+// SetSnsCache set sns to cache
+func (d *Dao) SetSnsCache(c context.Context, mid int64, platform string, sns *model.SnsProto) (err error) {
+	key := snsKey(platform, mid)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	item := &memcache.Item{Key: key, Object: sns, Flags: memcache.FlagProtobuf, Expiration: d.mcExpire}
+	if err = conn.Set(item); err != nil {
+		log.Error("fail to set sns to mc, key(%s) expire(%d) error(%+v)", key, d.mcExpire, err)
+	}
+	return
+}
+
+// DelSnsCache del sns cache
+func (d *Dao) DelSnsCache(c context.Context, mid int64, platform string) (err error) {
+	key := snsKey(platform, mid)
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("fail to del sns cache, key(%s) error(%+v)", key, err)
+	}
+	return
+}
+
+// GetUnionIDCache .
+func (d *Dao) GetUnionIDCache(c context.Context, key string) (v string, err error) {
+	conn := d.mc.Get(c)
+	r, err := conn.Get(key)
+	conn.Close()
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		log.Error("GetUnionIDCache, key(%s) error(%+v)", key, err)
+		return
+	}
+	v = string(r.Value)
+	return
+}

app/job/main/passport-sns/dao/mc_test.go

@@ -0,0 +1,74 @@
+package dao
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/job/main/passport-sns/model"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_snsKey(t *testing.T) {
+	convey.Convey("snsKey", t, func(ctx convey.C) {
+		var (
+			platform = model.PlatformQQStr
+			mid      = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res := snsKey(platform, mid)
+			ctx.Convey("Then res should not be nil.", func(ctx convey.C) {
+				ctx.So(res, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestDao_SetSnsCache(t *testing.T) {
+	convey.Convey("SetSnsCache", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			platform = model.PlatformQQStr
+			qq       = &model.SnsProto{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetSnsCache(c, mid, platform, qq)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDao_DelSnsCache(t *testing.T) {
+	convey.Convey("DelSnsCache", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			platform = model.PlatformQQStr
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelSnsCache(c, mid, platform)
+			ctx.Convey("Then err should be nil.info should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDao_GetUnionIDCache(t *testing.T) {
+	convey.Convey("GetUnionIDCache", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			key = "test"
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.GetUnionIDCache(c, key)
+			ctx.Convey("Then err should be nil.res should be nil.", func(ctx convey.C) {
+				ctx.So(res, convey.ShouldBeEmpty)
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/job/main/passport-sns/dao/qq.go

@@ -0,0 +1,63 @@
+package dao
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"go-common/app/job/main/passport-sns/model"
+	"go-common/library/log"
+)
+
+const (
+	_qqGetUnionidUrl = "https://graph.qq.com/oauth2.0/get_unionid"
+
+	_respCodeSuccess             = 0
+	_respCodeInvalidOpenid       = 100050
+	_respCodeInvalidOpenidLength = 100058
+)
+
+// QQUnionID .
+func (d *Dao) QQUnionID(c context.Context, openID string) (unionID string, err error) {
+	var (
+		res    *http.Response
+		bs     []byte
+		params = url.Values{}
+	)
+	params.Set("client_id", model.OldAppID)
+	params.Set("openid", openID)
+
+	if res, err = http.Get(_qqGetUnionidUrl + "?" + params.Encode()); err != nil {
+		log.Error("d.QQUnionID error(%+v) openID(%s)", err, openID)
+		return "", err
+	}
+	defer res.Body.Close()
+
+	if bs, err = ioutil.ReadAll(res.Body); err != nil {
+		log.Error("ioutil.ReadAll() error(%+v) openID(%s)", err, openID)
+		return "", err
+	}
+	respStr := string(bs)
+	if strings.HasPrefix(respStr, "callback") {
+		start := strings.Index(respStr, "{")
+		end := strings.Index(respStr, "}")
+		respStr = respStr[start : end+1]
+	}
+	unionRes := new(model.QQUnionIDResp)
+	if err = json.Unmarshal([]byte(respStr), unionRes); err != nil {
+		log.Error("json.Unmarshal() error(%+v) respStr(%s) openID(%s)", err, respStr, openID)
+		return "", err
+	}
+	if unionRes.Code == _respCodeSuccess && unionRes.UnionID != "" {
+		return unionRes.UnionID, nil
+	}
+	log.Error("request qq get_unionid failed with code(%d) desc(%s) openID(%s)", unionRes.Code, unionRes.Description, openID)
+	if unionRes.Code == _respCodeInvalidOpenidLength || unionRes.Code == _respCodeInvalidOpenid {
+		return "", nil
+	}
+	return "", fmt.Errorf("request qq get_unionid failed with code(%d) desc(%s) openID(%s)", unionRes.Code, unionRes.Description, openID)
+}

app/job/main/passport-sns/dao/qq_test.go

@@ -0,0 +1,24 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_QQUnionID(t *testing.T) {
+	var (
+		c      = context.Background()
+		openID = "2A9FE674CE0810761DC3F420239A8CD7"
+	)
+	convey.Convey("QQUnionID", t, func(ctx convey.C) {
+		res, err := d.QQUnionID(c, openID)
+		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)
+		})
+		fmt.Printf("(%+v) error(%+v)", res, err)
+	})
+}

app/job/main/passport-sns/dao/sns.go

@@ -0,0 +1,164 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"hash/crc32"
+
+	"go-common/app/job/main/passport-sns/model"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getSnsUserByMidSQL      = "SELECT mid,unionid,platform,expires FROM sns_user WHERE mid = ? and platform = ?"
+	_getSnsUserByUnionIDSQL  = "SELECT mid,unionid,platform FROM sns_user WHERE unionid = ? and platform = ?"
+	_addSnsUserSQL           = "INSERT INTO sns_user (mid,unionid,platform,expires) VALUES(?,?,?,?)"
+	_addSnsOpenIDSQL         = "INSERT IGNORE INTO sns_openid_%02d (openid,unionid,appid,platform) VALUES(?,?,?,?)"
+	_addSnsTokenSQL          = "INSERT INTO sns_token (mid,openid,unionid,platform,token,expires,appid) VALUES(?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE mid=?, openid =?, token =?, expires =?, appid =?"
+	_delSnsUserSQL           = "DELETE FROM sns_user WHERE mid = ? and platform = ?"
+	_updateSnsUserExpiresSQL = "UPDATE sns_user SET expires = ? where mid = ? and platform = ?"
+	_updateSnsUserSQL        = "UPDATE sns_user SET unionid = ?, expires = ? where mid = ? and platform = ?"
+	_updateSnsTokenSQL       = "UPDATE sns_token SET token =?, expires =? WHERE mid =? and platform = ?"
+)
+
+// SnsUserByMid get sns user by mid and platform
+func (d *Dao) SnsUserByMid(c context.Context, mid int64, platform int) (res *model.SnsUser, err error) {
+	res = new(model.SnsUser)
+	row := d.snsDB.QueryRow(c, _getSnsUserByMidSQL, mid, platform)
+	if err = row.Scan(&res.Mid, &res.UnionID, &res.Platform, &res.Expires); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			res = nil
+			return
+		}
+		log.Error("SnsUserByMid mid(%d) platform(%d) row.Scan() error(%+v)", mid, platform, err)
+		return
+	}
+	return
+}
+
+// SnsUserByUnionID get sns user by unionID and platform
+func (d *Dao) SnsUserByUnionID(c context.Context, unionID string, platform int) (res *model.SnsUser, err error) {
+	res = new(model.SnsUser)
+	row := d.snsDB.QueryRow(c, _getSnsUserByUnionIDSQL, unionID, platform)
+	if err = row.Scan(&res.Mid, &res.UnionID, &res.Platform); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+			res = nil
+			return
+		}
+		log.Error("SnsUserByUnionID unionID(%d) platform(%d) row.Scan() error(%+v)", unionID, platform, err)
+		return
+	}
+	return
+}
+
+// AddSnsUser add sns user.
+func (d *Dao) AddSnsUser(c context.Context, mid, expires int64, unionID string, platform int) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.snsDB.Exec(c, _addSnsUserSQL, mid, unionID, platform, expires); err != nil {
+		log.Error("AddSnsUser mid(%d) platform(%d) unionID(%s) expires(%d) d.snsDB.Exec() error(%+v)", mid, platform, unionID, platform, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// TxAddSnsUser add sns user.
+func (d *Dao) TxAddSnsUser(tx *xsql.Tx, a *model.SnsUser) (affected int64, err error) {
+	var res sql.Result
+	if res, err = tx.Exec(_addSnsUserSQL, a.Mid, a.UnionID, a.Platform, a.Expires); err != nil {
+		log.Error("TxAddSnsUser(%+v) tx.Exec() error(%+v)", a, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// TxAddSnsOpenID add sns openid.
+func (d *Dao) TxAddSnsOpenID(tx *xsql.Tx, a *model.SnsOpenID) (affected int64, err error) {
+	var res sql.Result
+	if res, err = tx.Exec(fmt.Sprintf(_addSnsOpenIDSQL, openIDSuffix(a.OpenID)), a.OpenID, a.UnionID, a.AppID, a.Platform); err != nil {
+		log.Error("TxAddSnsOpenID(%+v) tx.Exec() error(%+v)", a, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// TxAddSnsToken add sns token.
+func (d *Dao) TxAddSnsToken(tx *xsql.Tx, a *model.SnsToken) (affected int64, err error) {
+	var res sql.Result
+	if res, err = tx.Exec(_addSnsTokenSQL, a.Mid, a.OpenID, a.UnionID, a.Platform, a.Token, a.Expires, a.AppID, a.Mid, a.OpenID, a.Token, a.Expires, a.AppID); err != nil {
+		log.Error("TxAddSnsToken(%+v) tx.Exec() error(%+v)", a, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// DelSnsUser del sns user.
+func (d *Dao) DelSnsUser(c context.Context, mid int64, platform int) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.snsDB.Exec(c, _delSnsUserSQL, mid, platform); err != nil {
+		log.Error("DelSnsUser mid(%d) platform(%d) d.snsDB.Exec() error(%+v)", mid, platform, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// TxUpdateSnsUserExpires update sns user expires.
+func (d *Dao) TxUpdateSnsUserExpires(tx *xsql.Tx, a *model.SnsUser) (affected int64, err error) {
+	var res sql.Result
+	if res, err = tx.Exec(_updateSnsUserExpiresSQL, a.Expires, a.Mid, a.Platform); err != nil {
+		log.Error("TxUpdateSnsUser(%+v) tx.Exec() error(%+v)", a, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// TxUpdateSnsUser update sns user.
+func (d *Dao) TxUpdateSnsUser(tx *xsql.Tx, mid, expires int64, unionID string, platform int) (affected int64, err error) {
+	var res sql.Result
+	if res, err = tx.Exec(_updateSnsUserSQL, unionID, expires, mid, platform); err != nil {
+		log.Error("TxUpdateSnsUser mid(%d) platform(%d) unionID(%s) expires(%d) d.snsDB.Exec() error(%+v)", mid, platform, unionID, platform, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpdateSnsUser update sns user.
+func (d *Dao) UpdateSnsUser(c context.Context, mid, expires int64, unionID string, platform int) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.snsDB.Exec(c, _updateSnsUserSQL, unionID, expires, mid, platform); err != nil {
+		log.Error("UpdateSnsUser mid(%d) platform(%d) unionID(%s) expires(%d) d.snsDB.Exec() error(%+v)", mid, platform, unionID, platform, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// TxUpdateSnsToken update sns token.
+func (d *Dao) TxUpdateSnsToken(tx *xsql.Tx, a *model.SnsToken) (affected int64, err error) {
+	var res sql.Result
+	if res, err = tx.Exec(_updateSnsTokenSQL, a.Token, a.Expires, a.Mid, a.Platform); err != nil {
+		log.Error("TxUpdateSnsToken(%+v) tx.Exec() error(%+v)", a, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+// UpdateSnsToken update sns token.
+func (d *Dao) UpdateSnsToken(c context.Context, a *model.SnsToken) (affected int64, err error) {
+	var res sql.Result
+	if res, err = d.snsDB.Exec(c, _updateSnsTokenSQL, a.Token, a.Expires, a.Mid, a.Platform); err != nil {
+		log.Error("UpdateSnsToken(%+v) tx.Exec() error(%+v)", a, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+func openIDSuffix(openID string) int {
+	v := int(crc32.ChecksumIEEE([]byte(openID)))
+	if v < 0 {
+		v = -v
+	}
+	return v % 100
+}

app/job/main/passport-sns/dao/sns_test.go

@@ -0,0 +1,268 @@
+package dao
+
+import (
+	"context"
+	"database/sql"
+	"database/sql/driver"
+	"reflect"
+	"testing"
+
+	"go-common/app/job/main/passport-sns/model"
+	xsql "go-common/library/database/sql"
+
+	"github.com/bouk/monkey"
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_SnsUserByMid(t *testing.T) {
+	convey.Convey("SnsUserByMid", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			platform = model.PlatformQQ
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.SnsUserByMid(c, mid, platform)
+			ctx.Convey("Then err should be nil.res should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDao_SnsUserByUnionID(t *testing.T) {
+	convey.Convey("SnsUserByUnionID", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			unionID  = ""
+			platform = model.PlatformQQ
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.SnsUserByUnionID(c, unionID, platform)
+			ctx.Convey("Then err should be nil.res should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(res, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestDao_AddSnsUser(t *testing.T) {
+	convey.Convey("AddSnsUser", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			platform = model.PlatformQQ
+			expires  = int64(0)
+			unionID  = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(d.snsDB), "Exec", func(_ *xsql.DB, _ context.Context, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.AddSnsUser(c, mid, expires, unionID, platform)
+			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 TestDao_UpdateSnsUser(t *testing.T) {
+	convey.Convey("UpdateSnsUser", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			platform = model.PlatformQQ
+			expires  = int64(0)
+			unionID  = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(d.snsDB), "Exec", func(_ *xsql.DB, _ context.Context, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.UpdateSnsUser(c, mid, expires, unionID, platform)
+			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 TestDao_UpdateSnsToken(t *testing.T) {
+	convey.Convey("UpdateSnsToken", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			a = &model.SnsToken{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(d.snsDB), "Exec", func(_ *xsql.DB, _ context.Context, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.UpdateSnsToken(c, a)
+			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 TestDao_TxAddSnsUser(t *testing.T) {
+	convey.Convey("TxAddSnsUser", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginSnsTran(context.Background())
+			a     = &model.SnsUser{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(tx), "Exec", func(_ *xsql.Tx, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.TxAddSnsUser(tx, a)
+			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 TestDao_TxAddSnsOpenID(t *testing.T) {
+	convey.Convey("TxAddSnsOpenID", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginSnsTran(context.Background())
+			a     = &model.SnsOpenID{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(tx), "Exec", func(_ *xsql.Tx, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.TxAddSnsOpenID(tx, a)
+			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 TestDao_TxAddSnsToken(t *testing.T) {
+	convey.Convey("TxAddSnsToken", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginSnsTran(context.Background())
+			a     = &model.SnsToken{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(tx), "Exec", func(_ *xsql.Tx, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.TxAddSnsToken(tx, a)
+			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 TestDao_DelSnsUser(t *testing.T) {
+	convey.Convey("DelSnsUser", t, func(ctx convey.C) {
+		var (
+			c        = context.Background()
+			mid      = int64(0)
+			platform = model.PlatformQQ
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(d.snsDB), "Exec", func(_ *xsql.DB, _ context.Context, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.DelSnsUser(c, mid, platform)
+			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 TestDao_TxUpdateSnsUserExpires(t *testing.T) {
+	convey.Convey("TxUpdateSnsUserExpires", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginSnsTran(context.Background())
+			a     = &model.SnsUser{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(tx), "Exec", func(_ *xsql.Tx, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.TxUpdateSnsUserExpires(tx, a)
+			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 TestDao_TxUpdateSnsUser(t *testing.T) {
+	convey.Convey("TxUpdateSnsUser", t, func(ctx convey.C) {
+		var (
+			tx, _    = d.BeginSnsTran(context.Background())
+			mid      = int64(0)
+			platform = model.PlatformQQ
+			expires  = int64(0)
+			unionID  = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(tx), "Exec", func(_ *xsql.Tx, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.TxUpdateSnsUser(tx, mid, expires, unionID, platform)
+			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 TestDao_TxUpdateSnsToken(t *testing.T) {
+	convey.Convey("TxUpdateSnsToken", t, func(ctx convey.C) {
+		var (
+			tx, _ = d.BeginSnsTran(context.Background())
+			a     = &model.SnsToken{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			mock := monkey.PatchInstanceMethod(reflect.TypeOf(tx), "Exec", func(_ *xsql.Tx, _ string, _ ...interface{}) (res sql.Result, err error) {
+				return driver.RowsAffected(1), nil
+			})
+			defer mock.Unpatch()
+			affected, err := d.TxUpdateSnsToken(tx, a)
+			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 TestDao_openIDSuffix(t *testing.T) {
+	convey.Convey("openIDSuffix", t, func(ctx convey.C) {
+		res := openIDSuffix("")
+		ctx.Convey("Then res should not be nil.", func(ctx convey.C) {
+			ctx.So(res, convey.ShouldNotBeNil)
+		})
+	})
+}