Create & Init Project...

app/interface/main/activity/dao/bws/BUILD

@@ -0,0 +1,63 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "achievement.go",
+        "bws.go",
+        "cache.go",
+        "dao.cache.go",
+        "mc.cache.go",
+        "point.go",
+    ],
+    importpath = "go-common/app/interface/main/activity/dao/bws",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/activity/conf:go_default_library",
+        "//app/interface/main/activity/model/bws:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/stat/prom: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "achievement_test.go",
+        "bws_test.go",
+        "point_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/activity/conf:go_default_library",
+        "//app/interface/main/activity/model/bws:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/interface/main/activity/dao/bws/achievement.go

@@ -0,0 +1,390 @@
+package bws
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+
+	bwsmdl "go-common/app/interface/main/activity/model/bws"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_userAchieveKeyFmt = "bws_u_a_%d_%s"
+	_userAchieveCntFmt = "bws_a_c_%d_%s"
+	_bwsLotteryKeyFmt  = "bws_l_%s_%d"
+	_awardSQL          = "UPDATE act_bws_user_achievements SET award = 2 where `key`= ? AND aid = ?"
+	_achievementsSQL   = "SELECT id,`name`,icon,dic,link_type,`unlock`,bid,icon_big,icon_active,icon_active_big,award,ctime,mtime,image,suit_id FROM act_bws_achievements WHERE del = 0  AND bid = ? ORDER BY ID"
+	_userAchieveSQL    = "SELECT id,aid,award FROM act_bws_user_achievements WHERE bid = ? AND `key` = ? AND del = 0"
+	_userAchieveAddSQL = "INSERT INTO act_bws_user_achievements(bid,aid,award,`key`) VALUES(?,?,?,?)"
+	_countAchievesSQL  = "SELECT aid,COUNT(1) AS c FROM act_bws_user_achievements WHERE del = 0 AND bid = ? AND ctime BETWEEN ? AND ? GROUP BY aid HAVING c > 0"
+	_nextDayHour       = 16
+)
+
+func keyUserAchieve(bid int64, key string) string {
+	return fmt.Sprintf(_userAchieveKeyFmt, bid, key)
+}
+
+func keyAchieveCnt(bid int64, day string) string {
+	return fmt.Sprintf(_userAchieveCntFmt, bid, day)
+}
+
+func keyLottery(aid int64, day string) string {
+	if day == "" {
+		day = time.Now().Format("20060102")
+	}
+	return fmt.Sprintf(_bwsLotteryKeyFmt, day, aid)
+}
+
+// Award  achievement award
+func (d *Dao) Award(c context.Context, key string, aid int64) (err error) {
+	if _, err = d.db.Exec(c, _awardSQL, key, aid); err != nil {
+		log.Error("Award: db.Exec(%d,%s) error(%v)", aid, key, err)
+	}
+	return
+}
+
+// RawAchievements  achievements list
+func (d *Dao) RawAchievements(c context.Context, bid int64) (res *bwsmdl.Achievements, err error) {
+	var (
+		rows *xsql.Rows
+		rs   []*bwsmdl.Achievement
+	)
+	if rows, err = d.db.Query(c, _achievementsSQL, bid); err != nil {
+		log.Error("RawAchievements: db.Exec(%d) error(%v)", bid, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(bwsmdl.Achievement)
+		if err = rows.Scan(&r.ID, &r.Name, &r.Icon, &r.Dic, &r.LockType, &r.Unlock, &r.Bid, &r.IconBig, &r.IconActive, &r.IconActiveBig, &r.Award, &r.Ctime, &r.Mtime, &r.Image, &r.SuitID); err != nil {
+			log.Error("RawAchievements:row.Scan() error(%v)", err)
+			return
+		}
+		rs = append(rs, r)
+	}
+	if len(rs) > 0 {
+		res = new(bwsmdl.Achievements)
+		res.Achievements = rs
+	}
+	return
+}
+
+// RawUserAchieves get user achievements from db.
+func (d *Dao) RawUserAchieves(c context.Context, bid int64, key string) (rs []*bwsmdl.UserAchieve, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	if rows, err = d.db.Query(c, _userAchieveSQL, bid, key); err != nil {
+		log.Error("RawUserAchieves: db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(bwsmdl.UserAchieve)
+		if err = rows.Scan(&r.ID, &r.Aid, &r.Award); err != nil {
+			log.Error("RawUserAchieves:row.Scan() error(%v)", err)
+			return
+		}
+		rs = append(rs, r)
+	}
+	return
+}
+
+// RawAchieveCounts  achievements user count
+func (d *Dao) RawAchieveCounts(c context.Context, bid int64, day string) (res []*bwsmdl.CountAchieves, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	start, _ := time.Parse("20060102-15:04:05", day+"-00:00:00")
+	end, _ := time.Parse("20060102-15:04:05", day+"-23:59:59")
+	if rows, err = d.db.Query(c, _countAchievesSQL, bid, start, end); err != nil {
+		log.Error("RawCountAchieves: db.Exec(%d) error(%v)", bid, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(bwsmdl.CountAchieves)
+		if err = rows.Scan(&r.Aid, &r.Count); err != nil {
+			log.Error("RawCountAchieves:row.Scan() error(%v)", err)
+			return
+		}
+		res = append(res, r)
+	}
+	return
+}
+
+// AddUserAchieve .
+func (d *Dao) AddUserAchieve(c context.Context, bid, aid, award int64, key string) (lastID int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _userAchieveAddSQL, bid, aid, award, key); err != nil {
+		log.Error("AddUserAchieve error d.db.Exec(%d,%d,%s) error(%v)", bid, aid, key, err)
+		return
+	}
+	return res.LastInsertId()
+}
+
+// CacheUserAchieves .
+func (d *Dao) CacheUserAchieves(c context.Context, bid int64, key string) (res []*bwsmdl.UserAchieve, err error) {
+	var (
+		values   []interface{}
+		cacheKey = keyUserAchieve(bid, key)
+		conn     = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if values, err = redis.Values(conn.Do("ZRANGE", cacheKey, 0, -1)); err != nil {
+		log.Error("CacheUserAchieves conn.Do(ZRANGE, %s) error(%v)", cacheKey, err)
+		return
+	} else if len(values) == 0 {
+		return
+	}
+	for len(values) > 0 {
+		var bs []byte
+		if values, err = redis.Scan(values, &bs); err != nil {
+			log.Error("CacheUserAchieves redis.Scan(%v) error(%v)", values, err)
+			return
+		}
+		item := new(bwsmdl.UserAchieve)
+		if err = json.Unmarshal(bs, &item); err != nil {
+			log.Error("CacheUserAchieves conn.Do(ZRANGE, %s) error(%v)", cacheKey, err)
+			continue
+		}
+		res = append(res, item)
+	}
+	return
+}
+
+// AddCacheUserAchieves .
+func (d *Dao) AddCacheUserAchieves(c context.Context, bid int64, data []*bwsmdl.UserAchieve, key string) (err error) {
+	var bs []byte
+	if len(data) == 0 {
+		return
+	}
+	cacheKey := keyUserAchieve(bid, key)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	args := redis.Args{}.Add(cacheKey)
+	for _, v := range data {
+		if bs, err = json.Marshal(v); err != nil {
+			log.Error("AddCacheUserAchieves json.Marshal() error(%v)", err)
+			return
+		}
+		args = args.Add(v.ID).Add(bs)
+	}
+	if err = conn.Send("ZADD", args...); err != nil {
+		log.Error("AddCacheUserAchieves conn.Send(ZADD, %s, %v) error(%v)", cacheKey, args, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", cacheKey, d.userAchExpire); err != nil {
+		log.Error("AddCacheUserAchieves conn.Send(Expire, %s) error(%v)", cacheKey, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("AddCacheUserAchieves conn.Flush error(%v)", err)
+		return
+	}
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("AddCacheUserAchieves conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// DelCacheUserAchieves .
+func (d *Dao) DelCacheUserAchieves(c context.Context, bid int64, key string) (err error) {
+	cacheKey := keyUserAchieve(bid, key)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if _, err = conn.Do("DEL", cacheKey); err != nil {
+		log.Error("DelCacheUserAchieves conn.Do(DEL) key(%s) error(%v)", cacheKey, err)
+	}
+	return
+}
+
+// AppendUserAchievesCache .
+func (d *Dao) AppendUserAchievesCache(c context.Context, bid int64, key string, achieve *bwsmdl.UserAchieve) (err error) {
+	var (
+		bs       []byte
+		ok       bool
+		cacheKey = keyUserAchieve(bid, key)
+		conn     = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if ok, err = redis.Bool(conn.Do("EXPIRE", cacheKey, d.userAchExpire)); err != nil || !ok {
+		log.Error("AppendUserAchievesCache conn.Do(EXPIRE %s) error(%v)", key, err)
+		return
+	}
+	args := redis.Args{}.Add(cacheKey)
+	if bs, err = json.Marshal(achieve); err != nil {
+		log.Error("AppendUserAchievesCache json.Marshal() error(%v)", err)
+		return
+	}
+	args = args.Add(achieve.ID).Add(bs)
+	if err = conn.Send("ZADD", args...); err != nil {
+		log.Error("AddCacheUserAchieves conn.Send(ZADD, %s, %v) error(%v)", cacheKey, args, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", cacheKey, d.userAchExpire); err != nil {
+		log.Error("AddCacheUserAchieves conn.Send(Expire, %s) error(%v)", cacheKey, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("AddCacheUserAchieves conn.Flush error(%v)", err)
+		return
+	}
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("AddCacheUserAchieves conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// CacheAchieveCounts  get achieve counts from cache
+func (d *Dao) CacheAchieveCounts(c context.Context, bid int64, day string) (res []*bwsmdl.CountAchieves, err error) {
+	var (
+		bss  []int64
+		key  = keyAchieveCnt(bid, day)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if bss, err = redis.Int64s(conn.Do("HGETALL", key)); err != nil {
+		log.Error("CacheAchieveCounts conn.Do(HGETALL,%s) error(%v)", key, err)
+		return
+	}
+	for i := 1; i < len(bss); i += 2 {
+		item := &bwsmdl.CountAchieves{Aid: bss[i-1], Count: bss[i]}
+		res = append(res, item)
+	}
+	return
+}
+
+// AddCacheAchieveCounts set achieve counts  to cache
+func (d *Dao) AddCacheAchieveCounts(c context.Context, bid int64, res []*bwsmdl.CountAchieves, day string) (err error) {
+	if len(res) == 0 {
+		return
+	}
+	key := keyAchieveCnt(bid, day)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if err = conn.Send("DEL", key); err != nil {
+		log.Error("AddCacheAchieveCounts conn.Send(DEL, %s) error(%v)", key, err)
+		return
+	}
+	args := redis.Args{}.Add(key)
+	for _, v := range res {
+		args = args.Add(v.Aid).Add(v.Count)
+	}
+	if err = conn.Send("HMSET", args...); err != nil {
+		log.Error("AddCacheAchieveCounts conn.Send(HMSET, %s) error(%v)", key, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", key, d.achCntExpire); err != nil {
+		log.Error("AddCacheAchieveCounts conn.Send(Expire, %s, %d) error(%v)", key, d.achCntExpire, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("AddCacheAchieveCounts conn.Flush error(%v)", err)
+		return
+	}
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// IncrCacheAchieveCounts incr achieve counts  to cache
+func (d *Dao) IncrCacheAchieveCounts(c context.Context, bid, aid int64, day string) (err error) {
+	var (
+		key  = keyAchieveCnt(bid, day)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if err = conn.Send("EXPIRE", key, d.achCntExpire); err != nil {
+		log.Error("IncrCacheAchieveCounts conn.Send(Expire, %s, %d) error(%v)", key, d.achCntExpire, err)
+		return
+	}
+	if err = conn.Send("HINCRBY", key, aid, 1); err != nil {
+		log.Error("IncrCacheAchieveCounts conn.Send(HMSET, %s, %d) error(%v)", key, aid, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("IncrCacheAchieveCounts conn.Flush error(%v)", err)
+		return
+	}
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// DelCacheAchieveCounts delete achieve cnt cache.
+func (d *Dao) DelCacheAchieveCounts(c context.Context, bid int64, day string) (err error) {
+	cacheKey := keyAchieveCnt(bid, day)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if _, err = conn.Do("DEL", cacheKey); err != nil {
+		log.Error("DelCacheAchieveCounts conn.Do(DEL) key(%s) error(%v)", cacheKey, err)
+	}
+	return
+}
+
+// AddLotteryMidCache add lottery mid cache.
+func (d *Dao) AddLotteryMidCache(c context.Context, aid, mid int64) (err error) {
+	now := time.Now()
+	hour := now.Hour()
+	dayInt, _ := strconv.ParseInt(now.Format("20060102"), 10, 64)
+	if hour >= _nextDayHour {
+		dayInt = dayInt + 1
+	}
+	cacheKey := keyLottery(aid, strconv.FormatInt(dayInt, 10))
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if _, err = conn.Do("SADD", cacheKey, mid); err != nil {
+		log.Error("AddLotteryCache conn.Do(LPUSH, %s, %d) error(%v)", cacheKey, mid, err)
+	}
+	return
+}
+
+// CacheLotteryMid .
+func (d *Dao) CacheLotteryMid(c context.Context, aid int64, day string) (mid int64, err error) {
+	var (
+		cacheKey = keyLottery(aid, day)
+		conn     = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if mid, err = redis.Int64(conn.Do("SPOP", cacheKey)); err != nil && err != redis.ErrNil {
+		log.Error("LotteryMidCache SPOP key(%s) error(%v)", cacheKey, err)
+	}
+	return
+}
+
+// CacheLotteryMids .
+func (d *Dao) CacheLotteryMids(c context.Context, aid int64, day string) (mids []int64, err error) {
+	var cacheKey string
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	cacheKey = keyLottery(aid, day)
+	if mids, err = redis.Int64s(conn.Do("SMEMBERS", cacheKey)); err != nil {
+		if err == redis.ErrNil {
+			err = nil
+			return
+		}
+		log.Error("redis.Int64s(conn.Do(SMEMEBERS,%s)) error(%v)", cacheKey, err)
+	}
+	return
+}

app/interface/main/activity/dao/bws/achievement_test.go

@@ -0,0 +1,100 @@
+package bws
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/activity/model/bws"
+	xtime "go-common/library/time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_CacheAchieveCounts(t *testing.T) {
+	Convey("test cache achieve count", t, WithDao(func(d *Dao) {
+		bid := int64(3)
+		day := "20180712"
+		data, err := d.CacheAchieveCounts(context.Background(), bid, day)
+		So(err, ShouldBeNil)
+		bs, _ := json.Marshal(data)
+		Printf("%v", string(bs))
+	}))
+}
+
+func TestDao_AddCacheAchieveCounts(t *testing.T) {
+	Convey("test add cache achieve count", t, WithDao(func(d *Dao) {
+		bid := int64(3)
+		day := "20180712"
+		list := []*bws.CountAchieves{
+			{Aid: 111, Count: 222},
+			{Aid: 222, Count: 333},
+		}
+		err := d.AddCacheAchieveCounts(context.Background(), bid, list, day)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestDao_AddCacheUserAchieves(t *testing.T) {
+	Convey("test add cache", t, WithDao(func(d *Dao) {
+		bid := int64(3)
+		list := []*bws.UserAchieve{
+			{ID: 2, Aid: 3, Award: 0, Ctime: xtime.Time(time.Now().Unix())},
+			{ID: 3, Aid: 4, Award: 0, Ctime: xtime.Time(time.Now().Unix())},
+		}
+		key := "9abf1997abe851e6"
+		err := d.AddCacheUserAchieves(context.Background(), bid, list, key)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestDao_CacheUserAchieves(t *testing.T) {
+	Convey("test cache user achieves", t, WithDao(func(d *Dao) {
+		bid := int64(3)
+		key := "9abf1997abe851e6"
+		data, err := d.CacheUserAchieves(context.Background(), bid, key)
+		So(err, ShouldBeNil)
+		bs, _ := json.Marshal(data)
+		Printf("%v", string(bs))
+	}))
+}
+
+func TestDao_AddLotteryMidCache(t *testing.T) {
+	Convey("test add lottery mid cache", t, WithDao(func(d *Dao) {
+		aid := int64(3)
+		mid := int64(908085)
+		for i := 0; i < 10; i++ {
+			err := d.AddLotteryMidCache(context.Background(), aid, mid+int64(i))
+			So(err, ShouldBeNil)
+		}
+	}))
+}
+
+func TestDao_LotteryMidCache(t *testing.T) {
+	Convey("test get lottery mid cache", t, WithDao(func(d *Dao) {
+		aid := int64(3)
+		mid, err := d.CacheLotteryMid(context.Background(), aid, "")
+		So(err, ShouldBeNil)
+		Println(mid)
+	}))
+}
+
+func TestDao_RawAchieveCounts(t *testing.T) {
+	Convey("test achieve count", t, WithDao(func(d *Dao) {
+		bid := int64(1)
+		day := "20180712"
+		data, err := d.RawAchieveCounts(context.Background(), bid, day)
+		So(err, ShouldBeNil)
+		Printf("%+v", data)
+	}))
+}
+
+func TestDao_RawAchievements(t *testing.T) {
+	Convey("test raw achievements", t, WithDao(func(d *Dao) {
+		bid := int64(1)
+		data, err := d.RawAchievements(context.Background(), bid)
+		So(err, ShouldBeNil)
+		Printf("%+v", data)
+	}))
+}

app/interface/main/activity/dao/bws/bws.go

@@ -0,0 +1,111 @@
+package bws
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/activity/conf"
+	bwsmdl "go-common/app/interface/main/activity/model/bws"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+const (
+	_bindingSQL  = "UPDATE act_bws_users SET mid = ? WHERE `key`= ?"
+	_usersMidSQL = "SELECT id,mid,`key`,ctime,mtime,bid FROM act_bws_users WHERE mid = ?"
+	_usersKeySQL = "SELECT id,mid,`key`,ctime,mtime,bid FROM act_bws_users WHERE `key` = ?"
+	_usersIDSQL  = "SELECT id,mid,`key`,ctime,mtime,bid FROM act_bws_users WHERE id = ?"
+)
+
+// PromError stat and log.
+func PromError(name string, format string, args ...interface{}) {
+	prom.BusinessErrCount.Incr(name)
+	log.Error(format, args...)
+}
+
+// Dao dao.
+type Dao struct {
+	// config
+	c *conf.Config
+	// db
+	db              *xsql.DB
+	mc              *memcache.Pool
+	mcExpire        int32
+	redis           *redis.Pool
+	redisExpire     int32
+	userAchExpire   int32
+	userPointExpire int32
+	achCntExpire    int32
+	cacheCh         chan func()
+}
+
+// New dao new.
+func New(c *conf.Config) (d *Dao) {
+	d = &Dao{
+		// config
+		c:               c,
+		db:              xsql.NewMySQL(c.MySQL.Like),
+		mc:              memcache.NewPool(c.Memcache.Like),
+		mcExpire:        int32(time.Duration(c.Memcache.BwsExpire) / time.Second),
+		redis:           redis.NewPool(c.Redis.Config),
+		cacheCh:         make(chan func(), 1024),
+		redisExpire:     int32(time.Duration(c.Redis.Expire) / time.Second),
+		userAchExpire:   int32(time.Duration(c.Redis.UserAchExpire) / time.Second),
+		userPointExpire: int32(time.Duration(c.Redis.UserPointExpire) / time.Second),
+		achCntExpire:    int32(time.Duration(c.Redis.AchCntExpire) / time.Second),
+	}
+	return
+}
+
+// RawUsersMid get users by mid
+func (d *Dao) RawUsersMid(c context.Context, mid int64) (res *bwsmdl.Users, err error) {
+	res = &bwsmdl.Users{}
+	row := d.db.QueryRow(c, _usersMidSQL, mid)
+	if err = row.Scan(&res.ID, &res.Mid, &res.Key, &res.Ctime, &res.Mtime, &res.Bid); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("RawUsersMid:row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+// RawUsersKey get users by key
+func (d *Dao) RawUsersKey(c context.Context, key string) (res *bwsmdl.Users, err error) {
+	res = &bwsmdl.Users{}
+	row := d.db.QueryRow(c, _usersKeySQL, key)
+	if err = row.Scan(&res.ID, &res.Mid, &res.Key, &res.Ctime, &res.Mtime, &res.Bid); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("RawUsersKey:row.Scan error(%v)", err)
+		}
+	}
+	return
+}
+
+// Binding binding mid
+func (d *Dao) Binding(c context.Context, loginMid int64, p *bwsmdl.ParamBinding) (err error) {
+	if _, err = d.db.Exec(c, _bindingSQL, loginMid, p.Key); err != nil {
+		log.Error("Binding: db.Exec(%d,%s) error(%v)", loginMid, p.Key, err)
+	}
+	return
+}
+
+// UserByID .
+func (d *Dao) UserByID(c context.Context, keyID int64) (res *bwsmdl.Users, err error) {
+	res = &bwsmdl.Users{}
+	row := d.db.QueryRow(c, _usersIDSQL, keyID)
+	if err = row.Scan(&res.ID, &res.Mid, &res.Key, &res.Ctime, &res.Mtime, &res.Bid); err != nil {
+		if err == xsql.ErrNoRows {
+			err = nil
+		} else {
+			log.Error("UserByID:row.Scan error(%v)", err)
+		}
+	}
+	return
+}

app/interface/main/activity/dao/bws/bws_test.go

@@ -0,0 +1,82 @@
+package bws
+
+import (
+	"context"
+	"flag"
+	"path/filepath"
+	"testing"
+
+	"go-common/app/interface/main/activity/conf"
+
+	"go-common/app/interface/main/activity/model/bws"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var d *Dao
+
+func WithDao(f func(d *Dao)) func() {
+	return func() {
+		dir, _ := filepath.Abs("../../cmd/activity-test.toml")
+		flag.Set("conf", dir)
+		if err := conf.Init(); err != nil {
+			panic(err)
+		}
+		if d == nil {
+			d = New(conf.Conf)
+		}
+		f(d)
+	}
+}
+
+func TestDao_Binding(t *testing.T) {
+	Convey("test binding", t, WithDao(func(d *Dao) {
+		key := "9875fa517967622b"
+		err := d.Binding(context.Background(), 908087, &bws.ParamBinding{Key: key})
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestDao_UsersKey(t *testing.T) {
+	Convey("test users key", t, WithDao(func(d *Dao) {
+		key := "9875fa517967622b"
+		data, err := d.UsersKey(context.Background(), key)
+		So(err, ShouldBeNil)
+		Printf("%+v", data)
+	}))
+}
+
+func TestDao_UsersMid(t *testing.T) {
+	Convey("test users mid", t, WithDao(func(d *Dao) {
+		mid := int64(908087)
+		data, err := d.UsersMid(context.Background(), mid)
+		So(err, ShouldBeNil)
+		Printf("%+v", data)
+	}))
+}
+
+func TestDao_CacheUsersMid(t *testing.T) {
+	Convey("test cache users mid", t, WithDao(func(d *Dao) {
+		mid := int64(908087)
+		data, err := d.CacheUsersMid(context.Background(), mid)
+		So(err, ShouldBeNil)
+		Printf("%+v", data)
+	}))
+}
+
+func TestDao_DelCacheUsersMid(t *testing.T) {
+	Convey("test delete users mid", t, WithDao(func(d *Dao) {
+		mid := int64(908087)
+		err := d.DelCacheUsersMid(context.Background(), mid)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestDao_RawUsersKey(t *testing.T) {
+	Convey("test users mid", t, WithDao(func(d *Dao) {
+		keyID := int64(1)
+		data, err := d.UserByID(context.Background(), keyID)
+		So(err, ShouldBeNil)
+		Printf("%+v", data)
+	}))
+}

app/interface/main/activity/dao/bws/cache.go

@@ -0,0 +1,69 @@
+package bws
+
+import (
+	"context"
+	"fmt"
+
+	bwsmdl "go-common/app/interface/main/activity/model/bws"
+)
+
+func midKey(id int64) string {
+	return fmt.Sprintf("u_m_%d", id)
+}
+
+func keyKey(key string) string {
+	return fmt.Sprintf("u_k_%s", key)
+}
+func pointsKey(id int64) string {
+	return fmt.Sprintf("b_p_%d", id)
+}
+
+func achievesKey(id int64) string {
+	return fmt.Sprintf("b_a_%d", id)
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/cache/gen
+type _cache interface {
+	//cache: -sync=true
+	UsersMid(c context.Context, key int64) (*bwsmdl.Users, error)
+	//cache: -sync=true
+	UsersKey(c context.Context, key string) (*bwsmdl.Users, error)
+	//cache: -sync=true
+	Points(c context.Context, bid int64) (*bwsmdl.Points, error)
+	//cache: -sync=true
+	Achievements(c context.Context, bid int64) (*bwsmdl.Achievements, error)
+	//cache: -sync=true
+	UserAchieves(c context.Context, bid int64, key string) ([]*bwsmdl.UserAchieve, error)
+	//cache: -sync=true
+	UserPoints(c context.Context, bid int64, key string) ([]*bwsmdl.UserPoint, error)
+	//cache: -sync=true
+	AchieveCounts(c context.Context, bid int64, day string) ([]*bwsmdl.CountAchieves, error)
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/cache/mc
+type _mc interface {
+	//mc: -key=midKey
+	CacheUsersMid(c context.Context, key int64) (*bwsmdl.Users, error)
+	//mc: -key=midKey -expire=d.mcExpire -encode=pb
+	AddCacheUsersMid(c context.Context, key int64, value *bwsmdl.Users) error
+	//mc: -key=midKey
+	DelCacheUsersMid(c context.Context, key int64) error
+	//mc: -key=keyKey
+	CacheUsersKey(c context.Context, key string) (*bwsmdl.Users, error)
+	//mc: -key=keyKey -expire=d.mcExpire -encode=pb
+	AddCacheUsersKey(c context.Context, key string, value *bwsmdl.Users) error
+	//mc: -key=keyKey
+	DelCacheUsersKey(c context.Context, key string) error
+	//mc: -key=pointsKey
+	CachePoints(c context.Context, key int64) (*bwsmdl.Points, error)
+	//mc: -key=pointsKey -expire=d.mcExpire -encode=pb
+	AddCachePoints(c context.Context, key int64, value *bwsmdl.Points) error
+	//mc: -key=pointsKey
+	DelCachePoints(c context.Context, key int64) error
+	//mc: -key=achievesKey
+	CacheAchievements(c context.Context, key int64) (*bwsmdl.Achievements, error)
+	//mc: -key=achievesKey -expire=d.mcExpire -encode=pb
+	AddCacheAchievements(c context.Context, key int64, value *bwsmdl.Achievements) error
+	//mc: -key=achievesKey
+	DelCacheAchievements(c context.Context, key int64) error
+}

app/interface/main/activity/dao/bws/dao.cache.go

@@ -0,0 +1,208 @@
+// Code generated by $GOPATH/src/go-common/app/tool/cache/gen. DO NOT EDIT.
+
+/*
+  Package bws is a generated cache proxy package.
+  It is generated from:
+  type _cache interface {
+		//cache: -sync=true
+		UsersMid(c context.Context, key int64) (*bwsmdl.Users, error)
+		//cache: -sync=true
+		UsersKey(c context.Context, key string) (*bwsmdl.Users, error)
+		//cache: -sync=true
+		Points(c context.Context, bid int64) (*bwsmdl.Points, error)
+		//cache: -sync=true
+		Achievements(c context.Context, bid int64) (*bwsmdl.Achievements, error)
+		//cache: -sync=true
+		UserAchieves(c context.Context, bid int64, key string) ([]*bwsmdl.UserAchieve, error)
+		//cache: -sync=true
+		UserPoints(c context.Context, bid int64, key string) ([]*bwsmdl.UserPoint, error)
+		//cache: -sync=true
+		AchieveCounts(c context.Context, bid int64, day string) ([]*bwsmdl.CountAchieves, error)
+	}
+*/
+
+package bws
+
+import (
+	"context"
+
+	bwsmdl "go-common/app/interface/main/activity/model/bws"
+	"go-common/library/stat/prom"
+)
+
+var _ _cache
+
+// UsersMid get data from cache if miss will call source method, then add to cache.
+func (d *Dao) UsersMid(c context.Context, id int64) (res *bwsmdl.Users, err error) {
+	addCache := true
+	res, err = d.CacheUsersMid(c, id)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	if res != nil {
+		prom.CacheHit.Incr("UsersMid")
+		return
+	}
+	prom.CacheMiss.Incr("UsersMid")
+	res, err = d.RawUsersMid(c, id)
+	if err != nil {
+		return
+	}
+	miss := res
+	if !addCache {
+		return
+	}
+	d.AddCacheUsersMid(c, id, miss)
+	return
+}
+
+// UsersKey get data from cache if miss will call source method, then add to cache.
+func (d *Dao) UsersKey(c context.Context, id string) (res *bwsmdl.Users, err error) {
+	addCache := true
+	res, err = d.CacheUsersKey(c, id)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	if res != nil {
+		prom.CacheHit.Incr("UsersKey")
+		return
+	}
+	prom.CacheMiss.Incr("UsersKey")
+	res, err = d.RawUsersKey(c, id)
+	if err != nil {
+		return
+	}
+	miss := res
+	if !addCache {
+		return
+	}
+	d.AddCacheUsersKey(c, id, miss)
+	return
+}
+
+// Points get data from cache if miss will call source method, then add to cache.
+func (d *Dao) Points(c context.Context, id int64) (res *bwsmdl.Points, err error) {
+	addCache := true
+	res, err = d.CachePoints(c, id)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	if res != nil {
+		prom.CacheHit.Incr("Points")
+		return
+	}
+	prom.CacheMiss.Incr("Points")
+	res, err = d.RawPoints(c, id)
+	if err != nil {
+		return
+	}
+	miss := res
+	if !addCache {
+		return
+	}
+	d.AddCachePoints(c, id, miss)
+	return
+}
+
+// Achievements get data from cache if miss will call source method, then add to cache.
+func (d *Dao) Achievements(c context.Context, id int64) (res *bwsmdl.Achievements, err error) {
+	addCache := true
+	res, err = d.CacheAchievements(c, id)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	if res != nil {
+		prom.CacheHit.Incr("Achievements")
+		return
+	}
+	prom.CacheMiss.Incr("Achievements")
+	res, err = d.RawAchievements(c, id)
+	if err != nil {
+		return
+	}
+	miss := res
+	if !addCache {
+		return
+	}
+	d.AddCacheAchievements(c, id, miss)
+	return
+}
+
+// UserAchieves get data from cache if miss will call source method, then add to cache.
+func (d *Dao) UserAchieves(c context.Context, id int64, key string) (res []*bwsmdl.UserAchieve, err error) {
+	addCache := true
+	res, err = d.CacheUserAchieves(c, id, key)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	if len(res) != 0 {
+		prom.CacheHit.Incr("UserAchieves")
+		return
+	}
+	prom.CacheMiss.Incr("UserAchieves")
+	res, err = d.RawUserAchieves(c, id, key)
+	if err != nil {
+		return
+	}
+	miss := res
+	if !addCache {
+		return
+	}
+	d.AddCacheUserAchieves(c, id, miss, key)
+	return
+}
+
+// UserPoints get data from cache if miss will call source method, then add to cache.
+func (d *Dao) UserPoints(c context.Context, id int64, key string) (res []*bwsmdl.UserPoint, err error) {
+	addCache := true
+	res, err = d.CacheUserPoints(c, id, key)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	if len(res) != 0 {
+		prom.CacheHit.Incr("UserPoints")
+		return
+	}
+	prom.CacheMiss.Incr("UserPoints")
+	res, err = d.RawUserPoints(c, id, key)
+	if err != nil {
+		return
+	}
+	miss := res
+	if !addCache {
+		return
+	}
+	d.AddCacheUserPoints(c, id, miss, key)
+	return
+}
+
+// AchieveCounts get data from cache if miss will call source method, then add to cache.
+func (d *Dao) AchieveCounts(c context.Context, id int64, day string) (res []*bwsmdl.CountAchieves, err error) {
+	addCache := true
+	res, err = d.CacheAchieveCounts(c, id, day)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	if len(res) != 0 {
+		prom.CacheHit.Incr("AchieveCounts")
+		return
+	}
+	prom.CacheMiss.Incr("AchieveCounts")
+	res, err = d.RawAchieveCounts(c, id, day)
+	if err != nil {
+		return
+	}
+	miss := res
+	if !addCache {
+		return
+	}
+	d.AddCacheAchieveCounts(c, id, miss, day)
+	return
+}

app/interface/main/activity/dao/bws/mc.cache.go

@@ -0,0 +1,282 @@
+// Code generated by $GOPATH/src/go-common/app/tool/cache/mc. DO NOT EDIT.
+
+/*
+  Package bws is a generated mc cache package.
+  It is generated from:
+  type _mc interface {
+		//mc: -key=midKey
+		CacheUsersMid(c context.Context, key int64) (*bwsmdl.Users, error)
+		//mc: -key=midKey -expire=d.mcExpire -encode=pb
+		AddCacheUsersMid(c context.Context, key int64, value *bwsmdl.Users) error
+		//mc: -key=midKey
+		DelCacheUsersMid(c context.Context, key int64) error
+		//mc: -key=keyKey
+		CacheUsersKey(c context.Context, key string) (*bwsmdl.Users, error)
+		//mc: -key=keyKey -expire=d.mcExpire -encode=pb
+		AddCacheUsersKey(c context.Context, key string, value *bwsmdl.Users) error
+		//mc: -key=keyKey
+		DelCacheUsersKey(c context.Context, key string) error
+		//mc: -key=pointsKey
+		CachePoints(c context.Context, key int64) (*bwsmdl.Points, error)
+		//mc: -key=pointsKey -expire=d.mcExpire -encode=pb
+		AddCachePoints(c context.Context, key int64, value *bwsmdl.Points) error
+		//mc: -key=pointsKey
+		DelCachePoints(c context.Context, key int64) error
+		//mc: -key=achievesKey
+		CacheAchievements(c context.Context, key int64) (*bwsmdl.Achievements, error)
+		//mc: -key=achievesKey -expire=d.mcExpire -encode=pb
+		AddCacheAchievements(c context.Context, key int64, value *bwsmdl.Achievements) error
+		//mc: -key=achievesKey
+		DelCacheAchievements(c context.Context, key int64) error
+	}
+*/
+
+package bws
+
+import (
+	"context"
+	"fmt"
+
+	bwsmdl "go-common/app/interface/main/activity/model/bws"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+var _ _mc
+
+// CacheUsersMid get data from mc
+func (d *Dao) CacheUsersMid(c context.Context, id int64) (res *bwsmdl.Users, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := midKey(id)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheUsersMid")
+		log.Errorv(c, log.KV("CacheUsersMid", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &bwsmdl.Users{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheUsersMid")
+		log.Errorv(c, log.KV("CacheUsersMid", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheUsersMid Set data to mc
+func (d *Dao) AddCacheUsersMid(c context.Context, id int64, val *bwsmdl.Users) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := midKey(id)
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.mcExpire, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheUsersMid")
+		log.Errorv(c, log.KV("AddCacheUsersMid", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheUsersMid delete data from mc
+func (d *Dao) DelCacheUsersMid(c context.Context, id int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := midKey(id)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheUsersMid")
+		log.Errorv(c, log.KV("DelCacheUsersMid", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CacheUsersKey get data from mc
+func (d *Dao) CacheUsersKey(c context.Context, id string) (res *bwsmdl.Users, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyKey(id)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheUsersKey")
+		log.Errorv(c, log.KV("CacheUsersKey", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &bwsmdl.Users{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheUsersKey")
+		log.Errorv(c, log.KV("CacheUsersKey", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheUsersKey Set data to mc
+func (d *Dao) AddCacheUsersKey(c context.Context, id string, val *bwsmdl.Users) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyKey(id)
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.mcExpire, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheUsersKey")
+		log.Errorv(c, log.KV("AddCacheUsersKey", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheUsersKey delete data from mc
+func (d *Dao) DelCacheUsersKey(c context.Context, id string) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyKey(id)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheUsersKey")
+		log.Errorv(c, log.KV("DelCacheUsersKey", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CachePoints get data from mc
+func (d *Dao) CachePoints(c context.Context, id int64) (res *bwsmdl.Points, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := pointsKey(id)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CachePoints")
+		log.Errorv(c, log.KV("CachePoints", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &bwsmdl.Points{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CachePoints")
+		log.Errorv(c, log.KV("CachePoints", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCachePoints Set data to mc
+func (d *Dao) AddCachePoints(c context.Context, id int64, val *bwsmdl.Points) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := pointsKey(id)
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.mcExpire, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCachePoints")
+		log.Errorv(c, log.KV("AddCachePoints", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCachePoints delete data from mc
+func (d *Dao) DelCachePoints(c context.Context, id int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := pointsKey(id)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCachePoints")
+		log.Errorv(c, log.KV("DelCachePoints", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// CacheAchievements get data from mc
+func (d *Dao) CacheAchievements(c context.Context, id int64) (res *bwsmdl.Achievements, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := achievesKey(id)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheAchievements")
+		log.Errorv(c, log.KV("CacheAchievements", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &bwsmdl.Achievements{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheAchievements")
+		log.Errorv(c, log.KV("CacheAchievements", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheAchievements Set data to mc
+func (d *Dao) AddCacheAchievements(c context.Context, id int64, val *bwsmdl.Achievements) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := achievesKey(id)
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.mcExpire, Flags: memcache.FlagProtobuf}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheAchievements")
+		log.Errorv(c, log.KV("AddCacheAchievements", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// DelCacheAchievements delete data from mc
+func (d *Dao) DelCacheAchievements(c context.Context, id int64) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := achievesKey(id)
+	if err = conn.Delete(key); err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:DelCacheAchievements")
+		log.Errorv(c, log.KV("DelCacheAchievements", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}

app/interface/main/activity/dao/bws/point.go

@@ -0,0 +1,200 @@
+package bws
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+
+	bwsmdl "go-common/app/interface/main/activity/model/bws"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_userPointKeyFmt = "bws_u_p_%d_%s"
+	_pointsSQL       = "SELECT id,`name`,icon,fid,image,unlocked,lock_type,dic,rule,bid,lose_unlocked,other_ip,ower,ctime,mtime FROM act_bws_points WHERE del = 0 AND bid = ? ORDER BY ID"
+	_userPointSQL    = "SELECT id,pid,points,ctime FROM act_bws_user_points WHERE bid = ? AND `key` = ? AND del = 0"
+	_userPointAddSQL = "INSERT INTO act_bws_user_points(bid,pid,points,`key`) VALUES(?,?,?,?)"
+)
+
+func keyUserPoint(bid int64, key string) string {
+	return fmt.Sprintf(_userPointKeyFmt, bid, key)
+}
+
+// RawPoints points list
+func (d *Dao) RawPoints(c context.Context, bid int64) (res *bwsmdl.Points, err error) {
+	var (
+		rows *xsql.Rows
+		rs   []*bwsmdl.Point
+	)
+	if rows, err = d.db.Query(c, _pointsSQL, bid); err != nil {
+		log.Error("RawPoints: db.Exec(%d) error(%v)", bid, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(bwsmdl.Point)
+		if err = rows.Scan(&r.ID, &r.Name, &r.Icon, &r.Fid, &r.Image, &r.Unlocked, &r.LockType, &r.Dic, &r.Rule, &r.Bid, &r.LoseUnlocked, &r.OtherIp, &r.Ower, &r.Ctime, &r.Mtime); err != nil {
+			log.Error("RawPoints:row.Scan() error(%v)", err)
+			return
+		}
+		rs = append(rs, r)
+	}
+	if len(rs) > 0 {
+		res = new(bwsmdl.Points)
+		res.Points = rs
+	}
+	return
+}
+
+// RawUserPoints .
+func (d *Dao) RawUserPoints(c context.Context, bid int64, key string) (rs []*bwsmdl.UserPoint, err error) {
+	var (
+		rows *xsql.Rows
+	)
+	if rows, err = d.db.Query(c, _userPointSQL, bid, key); err != nil {
+		log.Error("RawUserPoints:db.Query error(%v)", err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		r := new(bwsmdl.UserPoint)
+		if err = rows.Scan(&r.ID, &r.Pid, &r.Points, &r.Ctime); err != nil {
+			log.Error("RawUserPoints:row.Scan() error(%v)", err)
+			return
+		}
+		rs = append(rs, r)
+	}
+	return
+}
+
+// AddUserPoint .
+func (d *Dao) AddUserPoint(c context.Context, bid, pid, points int64, key string) (lastID int64, err error) {
+	var res sql.Result
+	if res, err = d.db.Exec(c, _userPointAddSQL, bid, pid, points, key); err != nil {
+		log.Error("AddUserPoint error d.db.Exec(%d,%d,%d,%s) error(%v)", bid, pid, points, key, err)
+		return
+	}
+	return res.LastInsertId()
+}
+
+// CacheUserPoints .
+func (d *Dao) CacheUserPoints(c context.Context, bid int64, key string) (res []*bwsmdl.UserPoint, err error) {
+	var (
+		values   []interface{}
+		cacheKey = keyUserPoint(bid, key)
+		conn     = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if values, err = redis.Values(conn.Do("ZRANGE", cacheKey, 0, -1)); err != nil {
+		log.Error("CacheUserAchieves conn.Do(ZRANGE, %s) error(%v)", cacheKey, err)
+		return
+	} else if len(values) == 0 {
+		return
+	}
+	for len(values) > 0 {
+		var bs []byte
+		if values, err = redis.Scan(values, &bs); err != nil {
+			log.Error("CacheUserAchieves redis.Scan(%v) error(%v)", values, err)
+			return
+		}
+		item := new(bwsmdl.UserPoint)
+		if err = json.Unmarshal(bs, &item); err != nil {
+			log.Error("CacheUserAchieves conn.Do(ZRANGE, %s) error(%v)", cacheKey, err)
+			continue
+		}
+		res = append(res, item)
+	}
+	return
+}
+
+// AddCacheUserPoints .
+func (d *Dao) AddCacheUserPoints(c context.Context, bid int64, data []*bwsmdl.UserPoint, key string) (err error) {
+	var bs []byte
+	if len(data) == 0 {
+		return
+	}
+	cacheKey := keyUserPoint(bid, key)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	args := redis.Args{}.Add(cacheKey)
+	for _, v := range data {
+		if bs, err = json.Marshal(v); err != nil {
+			log.Error("AddCacheUserPoints json.Marshal() error(%v)", err)
+			return
+		}
+		args = args.Add(v.ID).Add(bs)
+	}
+	if err = conn.Send("ZADD", args...); err != nil {
+		log.Error("AddCacheUserPoints conn.Send(ZADD, %s, %v) error(%v)", cacheKey, args, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", cacheKey, d.userPointExpire); err != nil {
+		log.Error("AddCacheUserPoints conn.Send(Expire, %s) error(%v)", cacheKey, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("AddCacheUserPoints conn.Flush error(%v)", err)
+		return
+	}
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("AddCacheUserPoints conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// AppendUserPointsCache .
+func (d *Dao) AppendUserPointsCache(c context.Context, bid int64, key string, point *bwsmdl.UserPoint) (err error) {
+	var (
+		bs       []byte
+		ok       bool
+		cacheKey = keyUserPoint(bid, key)
+		conn     = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if ok, err = redis.Bool(conn.Do("EXPIRE", cacheKey, d.userPointExpire)); err != nil || !ok {
+		log.Error("AppendUserPointsCache conn.Do(EXPIRE %s) error(%v)", key, err)
+		return
+	}
+	args := redis.Args{}.Add(cacheKey)
+	if bs, err = json.Marshal(point); err != nil {
+		log.Error("AppendUserPointsCache json.Marshal() error(%v)", err)
+		return
+	}
+	args = args.Add(point.ID).Add(bs)
+	if err = conn.Send("ZADD", args...); err != nil {
+		log.Error("AppendUserPointsCache conn.Send(ZADD, %s, %v) error(%v)", cacheKey, args, err)
+		return
+	}
+	if err = conn.Send("EXPIRE", cacheKey, d.userPointExpire); err != nil {
+		log.Error("AppendUserPointsCache conn.Send(Expire, %s) error(%v)", cacheKey, err)
+		return
+	}
+	if err = conn.Flush(); err != nil {
+		log.Error("AppendUserPointsCache conn.Flush error(%v)", err)
+		return
+	}
+	for i := 0; i < 2; i++ {
+		if _, err = conn.Receive(); err != nil {
+			log.Error("AppendUserPointsCache conn.Receive() error(%v)", err)
+			return
+		}
+	}
+	return
+}
+
+// DelCacheUserPoints .
+func (d *Dao) DelCacheUserPoints(c context.Context, bid int64, key string) (err error) {
+	cacheKey := keyUserPoint(bid, key)
+	conn := d.redis.Get(c)
+	defer conn.Close()
+	if _, err = conn.Do("DEL", cacheKey); err != nil {
+		log.Error("DelCacheUserPoints conn.Do(DEL) key(%s) error(%v)", cacheKey, err)
+	}
+	return
+}

app/interface/main/activity/dao/bws/point_test.go

@@ -0,0 +1,48 @@
+package bws
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"go-common/app/interface/main/activity/model/bws"
+	xtime "go-common/library/time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestDao_RawUserPoints(t *testing.T) {
+	Convey("test cache user points", t, WithDao(func(d *Dao) {
+		bid := int64(3)
+		key := "9875fa517967622b"
+		data, err := d.RawUserPoints(context.Background(), bid, key)
+		So(err, ShouldBeNil)
+		bs, _ := json.Marshal(data)
+		Println(string(bs))
+	}))
+}
+
+func TestDao_CacheUserPoints(t *testing.T) {
+	Convey("test cache user points", t, WithDao(func(d *Dao) {
+		bid := int64(3)
+		key := "9875fa517967622b"
+		data, err := d.CacheUserPoints(context.Background(), bid, key)
+		So(err, ShouldBeNil)
+		bs, _ := json.Marshal(data)
+		Println(string(bs))
+	}))
+}
+
+func TestDao_AddCacheUserPoints(t *testing.T) {
+	Convey("add user points cache", t, WithDao(func(d *Dao) {
+		bid := int64(3)
+		key := "9875fa517967622b"
+		data := []*bws.UserPoint{
+			{ID: 1, Pid: 2, Points: 3, Ctime: xtime.Time(time.Now().Unix())},
+			{ID: 2, Pid: 3, Points: 4, Ctime: xtime.Time(time.Now().Unix())},
+		}
+		err := d.AddCacheUserPoints(context.Background(), bid, data, key)
+		So(err, ShouldBeNil)
+	}))
+}