Create & Init Project...

app/service/live/xrewardcenter/dao/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["dao.go"],
+    importpath = "go-common/app/service/live/xrewardcenter/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/gift/api/liverpc:go_default_library",
+        "//app/service/live/room/api/liverpc:go_default_library",
+        "//app/service/live/xrewardcenter/conf: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/net/rpc/liverpc:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//app/service/live/xrewardcenter/dao/anchorReward:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/live/xrewardcenter/dao/anchorReward/BUILD

@@ -0,0 +1,69 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "dao.cache.go",
+        "dao.go",
+        "mc.cache.go",
+        "mc.go",
+        "mysql.go",
+        "redis.go",
+    ],
+    importpath = "go-common/app/service/live/xrewardcenter/dao/anchorReward",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//app/service/live/xrewardcenter/model/anchorTask:go_default_library",
+        "//library/cache/memcache:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/database/orm:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/jinzhu/gorm:go_default_library",
+        "//vendor/github.com/pkg/errors: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 = [
+        "dao.cache_test.go",
+        "dao_test.go",
+        "mc.cache_test.go",
+        "mc_test.go",
+        "mysql_test.go",
+        "redis_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/live/xrewardcenter/conf:go_default_library",
+        "//app/service/live/xrewardcenter/model/anchorTask:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/service/live/xrewardcenter/dao/anchorReward/dao.cache.go

@@ -0,0 +1,54 @@
+// Code generated by $GOPATH/src/go-common/app/tool/cache/gen. DO NOT EDIT.
+
+/*
+  Package anchorReward is a generated cache proxy package.
+  It is generated from:
+  type _cache interface {
+		// cache: -sync=true -nullcache=&model.AnchorRewardConf{ID:-1} -check_null_code=$.ID==-1
+		RewardConf(c context.Context, id int64) (*model.AnchorRewardConf, error)
+	}
+*/
+
+package anchorReward
+
+import (
+	"context"
+
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/stat/prom"
+)
+
+var _ _cache
+
+// RewardConf get data from cache if miss will call source method, then add to cache.
+func (d *Dao) RewardConf(c context.Context, id int64) (res *model.AnchorRewardConf, err error) {
+	addCache := true
+	res, err = d.CacheRewardConf(c, id)
+	if err != nil {
+		addCache = false
+		err = nil
+	}
+	defer func() {
+		if res != nil && res.ID == -1 {
+			res = nil
+		}
+	}()
+	if res != nil {
+		prom.CacheHit.Incr("RewardConf")
+		return
+	}
+	prom.CacheMiss.Incr("RewardConf")
+	res, err = d.RawRewardConf(c, id)
+	if err != nil {
+		return
+	}
+	miss := res
+	if miss == nil {
+		miss = &model.AnchorRewardConf{ID: -1}
+	}
+	if !addCache {
+		return
+	}
+	d.AddCacheRewardConf(c, id, miss)
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/dao.cache_test.go

@@ -0,0 +1,24 @@
+package anchorReward
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardRewardConf(t *testing.T) {
+	convey.Convey("RewardConf", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.RewardConf(c, id)
+			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/service/live/xrewardcenter/dao/anchorReward/dao.go

@@ -0,0 +1,418 @@
+package anchorReward
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/service/live/xrewardcenter/conf"
+	AnchorTaskModel "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	"go-common/library/database/orm"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+	xtime "go-common/library/time"
+	"math"
+	"time"
+
+	"bytes"
+	"encoding/json"
+	bm "go-common/library/net/http/blademaster"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+
+	"github.com/jinzhu/gorm"
+)
+
+// OrderExist .
+const (
+	//  缓存过期时间
+	rewardConfExpire = 3600
+	rewardConfPrefix = "rconf_v1_%d"
+)
+
+// Dao dao
+type Dao struct {
+	c                   *conf.Config
+	mc                  *memcache.Pool
+	redis               *redis.Pool
+	orm                 *gorm.DB
+	db                  *xsql.DB
+	keyRewardConfExpire int32
+	client              *bm.Client
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:                   c,
+		mc:                  memcache.NewPool(c.Memcache),
+		redis:               redis.NewPool(c.Redis),
+		db:                  xsql.NewMySQL(c.MySQL),
+		orm:                 orm.NewMySQL(c.ORM),
+		keyRewardConfExpire: rewardConfExpire,
+		client:              bm.NewClient(c.HTTPClient),
+	}
+	dao.initORM()
+	return
+}
+
+func keyRewardConf(id int64) string {
+	return fmt.Sprintf(rewardConfPrefix, id)
+}
+
+func (d *Dao) initORM() {
+	d.orm.LogMode(true)
+	d.orm.SingularTable(true)
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/cache/gen
+type _cache interface {
+	// cache: -sync=true -nullcache=&model.AnchorRewardConf{ID:-1} -check_null_code=$.ID==-1
+	RewardConf(c context.Context, id int64) (*model.AnchorRewardConf, error)
+}
+
+//go:generate $GOPATH/src/go-common/app/tool/cache/mc
+type _mc interface {
+	// 获取奖励配置
+	// mc: -key=keyRewardConf
+	CacheRewardConf(c context.Context, id int64) (*model.AnchorRewardConf, error)
+
+	// 保存奖励配置
+	// mc: -key=keyRewardConf -expire=d.keyRewardConfExpire -encode=json|gzip
+	AddCacheRewardConf(c context.Context, id int64, value *model.AnchorRewardConf) error
+}
+
+// AddReward add Reward to a user.
+func (d *Dao) AddReward(c context.Context, iRewardID int64, uid int64, iSource int64, iRoomid int64, iLifespan int64) (err error) {
+	//aReward, _ := getRewardConfByLid(iRewardID)
+
+	m, _ := time.ParseDuration(fmt.Sprintf("+%dh", iLifespan))
+
+	arg := &AnchorTaskModel.AnchorReward{
+		Uid:         uid,
+		RewardId:    iRewardID,
+		Roomid:      iRoomid,
+		Source:      iSource,
+		AchieveTime: xtime.Time(time.Now().Unix()),
+		ExpireTime:  xtime.Time(time.Now().Add(m).Unix()),
+		Status:      model.RewardUnUsed,
+	}
+
+	//spew.Dump
+	// (arg)
+	if err := d.orm.Create(arg).Error; err != nil {
+		log.Error("addReward(%v) error(%v)", arg, err)
+		return err
+	}
+
+	if err := d.SetNewReward(c, uid, int64(1)); err != nil {
+		log.Error("addRewardMc(%v) error(%v)", uid, err)
+	}
+
+	if err := d.SetHasReward(c, uid, int64(1)); err != nil {
+		log.Error("SetHasReward(%v) error(%v)", uid, err)
+	}
+
+	log.Info("addReward (%v) succ", arg)
+
+	return
+}
+
+//GetByUidPage get reward by uid and page.
+func (d *Dao) GetByUidPage(c context.Context, uid int64, page int64, pageSize int64, status []int64) (pager *model.AnchorRewardPager, list []*model.AnchorRewardObject, err error) {
+	err = nil
+	pager = &model.AnchorRewardPager{}
+	list = []*model.AnchorRewardObject{}
+
+	var (
+		Items []*AnchorTaskModel.AnchorReward
+		count int64
+	)
+	iOffSet := (page - 1) * pageSize
+
+	db := d.orm.Where("status in (?)", status).Where("uid=?", uid)
+	db.Model(&AnchorTaskModel.AnchorReward{}).Count(&count)
+
+	if err = db.Model(&AnchorTaskModel.AnchorReward{}).Limit(pageSize).Offset(iOffSet).Order("mtime DESC, id").Find(&Items).Error; err != nil {
+		log.Error("get ap_anchor_task_reward_list uid(%v) error(%v)", uid, err)
+		return
+	}
+
+	for _, v := range Items {
+		aReward, err := d.RewardConf(c, v.RewardId)
+		if err != nil {
+			log.Error("RewardConf(%v) error(%v)", v.RewardId, err)
+			return pager, list, err
+		}
+
+		if aReward == nil {
+			continue
+		}
+
+		aListItem := &model.AnchorRewardObject{
+			Id:          v.Id,
+			RewardType:  aReward.RewardType,
+			Status:      v.Status,
+			RewardId:    v.RewardId,
+			Name:        aReward.Name,
+			Icon:        aReward.Icon,
+			AchieveTime: v.AchieveTime.Time().Format("2006-01-02 15:04:05"),
+			ExpireTime:  v.ExpireTime.Time().Format("2006-01-02 15:04:05"),
+			UseTime:     v.UseTime.Time().Format("2006-01-02 15:04:05"),
+			Source:      v.Source,
+			RewardIntro: aReward.RewardIntro,
+		}
+
+		list = append(list, aListItem)
+	}
+	pager = &model.AnchorRewardPager{
+		Page:       page,
+		PageSize:   pageSize,
+		TotalPage:  int64(math.Ceil(float64(count) / float64(pageSize))),
+		TotalCount: count,
+	}
+
+	return
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) (err error) {
+	if d.orm != nil {
+		d.orm.DB().PingContext(c)
+	}
+
+	err = d.pingMC(c)
+	return
+}
+
+// GetById get reward by id.
+func (d *Dao) GetById(id int64) (reward *model.AnchorReward, err error) {
+	rewards := []*model.AnchorReward{}
+	if err := d.orm.Model(&model.AnchorReward{}).Find(&rewards, "id=?", id).Error; err != nil {
+		log.Error("getRewardById (%v) error(%v)", id, err)
+		return reward, err
+	}
+	if len(rewards) != 0 {
+		reward = rewards[0]
+	}
+
+	return
+}
+
+// UseReward use reward by id.
+func (d *Dao) UseReward(id int64, usePlat string) (rst bool, err error) {
+	if err := d.orm.
+		Model(&model.AnchorReward{}).
+		Where("id=?", id).
+		Update(map[string]interface{}{"status": model.RewardUsed, "use_plat": usePlat, "use_time": xtime.Time(time.Now().Unix())}).Error; err != nil {
+		log.Error("useReward (%v) error(%v)", id, err)
+		return rst, err
+	}
+	rst = true
+	return
+}
+
+// HasNewReward .
+func (d *Dao) HasNewReward(c context.Context, uid int64) (rst int64, err error) {
+	rst, _ = d.GetNewReward(c, uid)
+	return
+}
+
+func (d *Dao) findByUid(uid int64, limitOne bool) (reward *model.AnchorReward, err error) {
+	rewards := []*model.AnchorReward{}
+	db := d.orm.Where("uid=?", uid)
+
+	if limitOne {
+		db = db.Limit(1)
+	}
+
+	if err := db.Model(&model.AnchorReward{}).Find(&rewards).Error; err != nil {
+		log.Error("getRewardById (%v) error(%v)", uid, err)
+		return reward, err
+	}
+	if len(rewards) != 0 {
+		reward = rewards[0]
+	}
+
+	return
+}
+
+// HasReward returns if a user have reward.
+func (d *Dao) HasReward(c context.Context, uid int64) (r int64, err error) {
+	rst, err := d.GetHasReward(c, uid)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			reward, err2 := d.findByUid(uid, true)
+			if err2 != nil {
+				return rst, err2
+			}
+			if reward != nil {
+				rst = int64(1)
+				d.SetHasReward(c, uid, rst)
+			} else {
+				rst = int64(0)
+				d.SetHasReward(c, uid, rst)
+			}
+			return rst, err
+		}
+		log.Error("HasReward(%v) error(%v)", uid, err)
+		return rst, err
+	}
+	return rst, err
+}
+
+// CheckOrderID check orderid is valid.
+func (d *Dao) CheckOrderID(c context.Context, id string) (exist int64, err error) {
+	exist = 0
+	if exist, err = d.GetOrder(c, id); err != nil {
+		//spew.Dump(exist, err)
+		if err == memcache.ErrNotFound {
+			err = nil
+		}
+		return exist, err
+	}
+	return exist, err
+}
+
+// SaveOrderID save order id.
+func (d *Dao) SaveOrderID(c context.Context, id string) error {
+	err := d.SaveOrder(c, id)
+	return err
+}
+
+// SetExpire .
+func (d *Dao) SetExpire(now time.Time) (err error) {
+	var (
+		db = d.orm
+	)
+
+	setMap := map[string]interface{}{
+		"status": model.RewardExpired,
+	}
+
+	if err = db.Model(model.AnchorReward{}).
+		Where("status=? AND reward_id = ? AND expire_time <= ?", model.RewardUnUsed, 1, now.Format("2006-01-02 15:04:05")).
+		Update(setMap).
+		Error; err != nil {
+		log.Error("SetExpire (%v) error(%v)", setMap, err)
+		return err
+	}
+	return
+}
+
+// CountExpire .
+func (d *Dao) CountExpire(interval int64, now time.Time) (err error) {
+	var (
+		c      = context.TODO()
+		db     = d.orm
+		result = &[]model.AnchorReward{}
+	)
+
+	dur, _ := time.ParseDuration("-" + strconv.FormatInt(interval, 10) + "s")
+	begin := now.Add(dur)
+
+	//spew.Dump(begin.Format("2006-01-02 15:04:05"))
+	//spew.Dump(now.Format("2006-01-02 15:04:05"))
+	sqlTemp :=
+		"SELECT * FROM ap_anchor_task_reward_list WHERE status = ? AND expire_time > ? AND expire_time <= ? AND reward_id= ?"
+
+	db.Raw(sqlTemp,
+		model.RewardExpired,
+		begin.Format("2006-01-02 15:04:05"),
+		now.Format("2006-01-02 15:04:05"),
+		1).Scan(&result)
+
+	for _, v := range *result {
+		d.AddExpireCountCache(c, fmt.Sprintf(model.CountExpireUserKey, v.Uid), model.ExpireCountTime)
+	}
+	return
+}
+
+// SendBroadcastV2 .
+func (d *Dao) SendBroadcastV2(c context.Context, uid int64, roomid int64, rewardId int64) (err error) {
+	log.Info("send reward broadcast begin:%d", roomid)
+
+	var endPoint string = fmt.Sprintf("http://live-dm.bilibili.co/dm/1/push?cid=%d&ensure=1", roomid)
+
+	postJson := make(map[string]interface{})
+	postJson["cmd"] = "new_anchor_reward"
+	postJson["uid"] = uid
+	postJson["roomid"] = roomid
+	postJson["reward_id"] = rewardId
+
+	bytesData, err := json.Marshal(postJson)
+	if err != nil {
+		log.Error("json.Marshal(%v) error(%v)", postJson, err)
+		return
+	}
+
+	req, err := http.NewRequest("POST", endPoint, bytes.NewReader(bytesData))
+
+	req.Header.Add("Content-Type", "application/json")
+
+	if err != nil {
+		log.Error("http.NewRequest(%v) url(%v) error(%v)", postJson, endPoint, err)
+		return
+	}
+
+	var v interface{}
+
+	if err = d.client.Do(c, req, v); err != nil {
+		log.Error("s.client.Do error(%v) res (%v)", err, v)
+		return
+	}
+	log.Info("s.client.Do endpoint (%v) req (%v) res (%v)", endPoint, postJson, v)
+
+	return
+}
+
+// SendBroadcast .
+func (d *Dao) SendBroadcast(uid int64, roomid int64, rewardId int64) (err error) {
+	log.Info("send reward broadcast begin:%d", roomid)
+
+	var endPoint = fmt.Sprintf("http://live-dm.bilibili.co/dm/1/push?cid=%d&ensure=1", roomid)
+
+	postJson := make(map[string]interface{})
+	postJson["cmd"] = "new_anchor_reward"
+	postJson["uid"] = uid
+	postJson["roomid"] = roomid
+	postJson["reward_id"] = rewardId
+
+	bytesData, err := json.Marshal(postJson)
+	if err != nil {
+		log.Error("json.Marshal(%v) error(%v)", postJson, err)
+		return
+	}
+
+	req, err := http.NewRequest("POST", endPoint, bytes.NewReader(bytesData))
+
+	req.Header.Add("Content-Type", "application/json")
+
+	if err != nil {
+		log.Error("http.NewRequest(%v) url(%v) error(%v)", postJson, endPoint, err)
+		return
+	}
+
+	client := http.Client{
+		Timeout: time.Second,
+	}
+
+	// use httpClient to send request
+	response, err := client.Do(req)
+
+	if err != nil {
+		log.Error("sending request to API endpoint(%v) error(%v)", req, err)
+		return
+	}
+
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		log.Error("parse resp body(%v) error(%v)", body, err)
+	}
+
+	log.Info("send reward broadcast end:%d", roomid)
+
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/dao_test.go

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

app/service/live/xrewardcenter/dao/anchorReward/mc.cache.go

@@ -0,0 +1,71 @@
+// Code generated by $GOPATH/src/go-common/app/tool/cache/mc. DO NOT EDIT.
+
+/*
+  Package anchorReward is a generated mc cache package.
+  It is generated from:
+  type _mc interface {
+		// 获取奖励配置
+		// mc: -key=keyRewardConf
+		CacheRewardConf(c context.Context, id int64) (*model.AnchorRewardConf, error)
+
+		// 保存奖励配置
+		// mc: -key=keyRewardConf -expire=d.keyRewardConfExpire -encode=json|gzip
+		AddCacheRewardConf(c context.Context, id int64, value *model.AnchorRewardConf) error
+	}
+*/
+
+package anchorReward
+
+import (
+	"context"
+	"fmt"
+
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+var _ _mc
+
+// CacheRewardConf 获取奖励配置
+func (d *Dao) CacheRewardConf(c context.Context, id int64) (res *model.AnchorRewardConf, err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyRewardConf(id)
+	reply, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			err = nil
+			return
+		}
+		prom.BusinessErrCount.Incr("mc:CacheRewardConf")
+		log.Errorv(c, log.KV("CacheRewardConf", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	res = &model.AnchorRewardConf{}
+	err = conn.Scan(reply, res)
+	if err != nil {
+		prom.BusinessErrCount.Incr("mc:CacheRewardConf")
+		log.Errorv(c, log.KV("CacheRewardConf", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}
+
+// AddCacheRewardConf 保存奖励配置
+func (d *Dao) AddCacheRewardConf(c context.Context, id int64, val *model.AnchorRewardConf) (err error) {
+	if val == nil {
+		return
+	}
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	key := keyRewardConf(id)
+	item := &memcache.Item{Key: key, Object: val, Expiration: d.keyRewardConfExpire, Flags: memcache.FlagJSON | memcache.FlagGzip}
+	if err = conn.Set(item); err != nil {
+		prom.BusinessErrCount.Incr("mc:AddCacheRewardConf")
+		log.Errorv(c, log.KV("AddCacheRewardConf", fmt.Sprintf("%+v", err)), log.KV("key", key))
+		return
+	}
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/mc.cache_test.go

@@ -0,0 +1,41 @@
+package anchorReward
+
+import (
+	"context"
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardCacheRewardConf(t *testing.T) {
+	convey.Convey("CacheRewardConf", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.CacheRewardConf(c, id)
+			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 TestAnchorRewardAddCacheRewardConf(t *testing.T) {
+	convey.Convey("AddCacheRewardConf", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			id  = int64(0)
+			val = &model.AnchorRewardConf{}
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.AddCacheRewardConf(c, id, val)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/service/live/xrewardcenter/dao/anchorReward/mc.go

@@ -0,0 +1,176 @@
+package anchorReward
+
+import (
+	"context"
+	"fmt"
+
+	"go-common/library/cache/memcache"
+	"go-common/library/log"
+
+	"go-common/app/service/live/xrewardcenter/model/anchorTask"
+
+	"github.com/pkg/errors"
+)
+
+const (
+	//NewRewardCache have new reward.
+	NewRewardCache = "new_reward:v1:%d"
+	//HasRewardCache have a reward
+	HasRewardCache = "has_reward:v1:%d"
+)
+
+// HasNewReward .
+type HasNewReward struct {
+	HasNewReward int64 `json:"has_new_reward"`
+}
+
+// pingMC .
+func (d *Dao) pingMC(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	if err = conn.Set(&memcache.Item{Key: "ping", Value: []byte{1}, Expiration: 0}); err != nil {
+		err = errors.Wrap(err, "conn.Store(set,ping,1)")
+	}
+	return
+}
+
+func newRewardKey(uid int64) string {
+	return fmt.Sprintf(NewRewardCache, uid)
+}
+
+// SetNewReward get MRRecord from mc
+func (d *Dao) SetNewReward(c context.Context, uid int64, hasNew int64) (err error) {
+	var (
+		conn = d.mc.Get(c)
+		key  = newRewardKey(uid)
+	)
+
+	defer conn.Close()
+
+	log.Info("SetNewReward.mc.set(%v) (%v)", key, hasNew)
+
+	if err = conn.Set(&memcache.Item{
+		Key:        key,
+		Object:     hasNew,
+		Flags:      memcache.FlagJSON,
+		Expiration: 3600,
+	}); err != nil {
+		log.Error("SetNewReward.mc.set(%v %v) error(%v)", key, hasNew, err)
+		return
+	}
+	return
+}
+
+// GetNewReward set MRRecord to mc
+func (d *Dao) GetNewReward(c context.Context, uid int64) (r int64, err error) {
+	r = 0
+
+	var (
+		key  = newRewardKey(uid)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+
+	item, err := conn.Get(key)
+
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			return r, err
+		}
+		err = errors.Wrapf(err, "conn.get(%v,%v)", key, item)
+		return r, err
+	}
+
+	if err = conn.Scan(item, &r); err != nil {
+		log.Error("mc.Scan(%s) error(%v)", string(item.Value), err)
+	}
+
+	return
+}
+
+// GetHasReward .
+func (d *Dao) GetHasReward(c context.Context, uid int64) (r int64, err error) {
+	var (
+		key  = hasRewardKey(uid)
+		conn = d.mc.Get(c)
+	)
+	defer conn.Close()
+
+	r = 0
+	item, err := conn.Get(key)
+	if err != nil {
+		if err == memcache.ErrNotFound {
+			return r, err
+		}
+		err = errors.Wrapf(err, "mc.get(%s,%v)", key, item)
+		return r, err
+	}
+
+	if err = conn.Scan(item, &r); err != nil {
+		log.Error("mc.Scan(%s) error(%v)", string(item.Value), err)
+	}
+	//spew.Dump(r, err)
+
+	return
+}
+
+func hasRewardKey(uid int64) string {
+	return fmt.Sprintf(HasRewardCache, uid)
+}
+
+// SetHasReward save whether one user have reward.
+func (d *Dao) SetHasReward(c context.Context, uid int64, isHave int64) (err error) {
+	var (
+		conn = d.mc.Get(c)
+		key  = hasRewardKey(uid)
+	)
+
+	defer conn.Close()
+
+	log.Info("SetHasReward.mc.set(%v %v)", key, isHave)
+
+	if err = conn.Set(&memcache.Item{
+		Key:        key,
+		Object:     isHave,
+		Flags:      memcache.FlagJSON,
+		Expiration: 3600 * 24,
+	}); err != nil {
+		log.Error("SetHasReward.mc.set(%v %v) error(%v)", key, isHave, err)
+		return
+	}
+	return
+}
+
+// GetOrder get order by id from cache.
+func (d *Dao) GetOrder(c context.Context, id string) (exists int64, err error) {
+
+	conn := d.mc.Get(c)
+	defer conn.Close()
+
+	_, err = conn.Get(id)
+
+	if err != nil {
+		exists = 0
+		return exists, err
+	}
+	exists = anchorTask.RewardExists
+	return exists, err
+}
+
+// SaveOrder save orderid in cache.
+func (d *Dao) SaveOrder(c context.Context, id string) (err error) {
+
+	conn := d.mc.Get(c)
+	defer conn.Close()
+
+	if err = conn.Set(&memcache.Item{
+		Key:        id,
+		Value:      []byte{1},
+		Expiration: 3600,
+	}); err != nil {
+		log.Error("(%v) error(%v)", id, err)
+		return
+	}
+
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/mc_test.go

@@ -0,0 +1,145 @@
+package anchorReward
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardpingMC(t *testing.T) {
+	convey.Convey("pingMC", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+		)
+		ctx.Convey("When everything gose positive", 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 TestAnchorRewardnewRewardKey(t *testing.T) {
+	convey.Convey("newRewardKey", t, func(ctx convey.C) {
+		var (
+			uid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := newRewardKey(uid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardSetNewReward(t *testing.T) {
+	convey.Convey("SetNewReward", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			uid    = int64(0)
+			hasNew = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetNewReward(c, uid, hasNew)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardGetNewReward(t *testing.T) {
+	convey.Convey("GetNewReward", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			uid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			r, err := d.GetNewReward(c, uid)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(r, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardGetHasReward(t *testing.T) {
+	convey.Convey("GetHasReward", t, func(ctx convey.C) {
+		var (
+			c   = context.Background()
+			uid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			r, err := d.GetHasReward(c, uid)
+			ctx.Convey("Then err should be nil.r should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(r, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardhasRewardKey(t *testing.T) {
+	convey.Convey("hasRewardKey", t, func(ctx convey.C) {
+		var (
+			uid = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := hasRewardKey(uid)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardSetHasReward(t *testing.T) {
+	convey.Convey("SetHasReward", t, func(ctx convey.C) {
+		var (
+			c      = context.Background()
+			uid    = int64(0)
+			isHave = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SetHasReward(c, uid, isHave)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardGetOrder(t *testing.T) {
+	convey.Convey("GetOrder", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			exists, err := d.GetOrder(c, id)
+			ctx.Convey("Then err should be nil.exists should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(exists, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardSaveOrder(t *testing.T) {
+	convey.Convey("SaveOrder", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.SaveOrder(c, id)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}

app/service/live/xrewardcenter/dao/anchorReward/mysql.go

@@ -0,0 +1,22 @@
+package anchorReward
+
+import (
+	"context"
+	model "go-common/app/service/live/xrewardcenter/model/anchorTask"
+	"go-common/library/log"
+)
+
+// RawRewardConf return reward config from db.
+func (d *Dao) RawRewardConf(c context.Context, id int64) (res *model.AnchorRewardConf, err error) {
+	rewards := []*model.AnchorRewardConf{}
+
+	if err := d.orm.Model(&model.AnchorReward{}).Find(&rewards, "id=?", id).Error; err != nil {
+		log.Error("getRewardById (%v) error(%v)", id, err)
+		return nil, err
+	}
+	if len(rewards) != 0 {
+		res = rewards[0]
+	}
+
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/mysql_test.go

@@ -0,0 +1,24 @@
+package anchorReward
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardRawRewardConf(t *testing.T) {
+	convey.Convey("RawRewardConf", t, func(ctx convey.C) {
+		var (
+			c  = context.Background()
+			id = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.RawRewardConf(c, id)
+			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/service/live/xrewardcenter/dao/anchorReward/redis.go

@@ -0,0 +1,119 @@
+package anchorReward
+
+import (
+	"context"
+	"go-common/library/cache/redis"
+
+	"go-common/library/log"
+)
+
+const (
+	_preLock        = "lk_"
+	_preExpireCount = "ec_"
+)
+
+func lockKey(key string) string {
+	return _preLock + key
+}
+
+func expireCountKey(key string) string {
+	return _preExpireCount + key
+}
+
+//DelLockCache del lock cache.
+func (d *Dao) DelLockCache(c context.Context, k string) (err error) {
+	var (
+		key  = lockKey(k)
+		conn = d.redis.Get(c)
+	)
+	defer conn.Close()
+	if _, err = conn.Do("DEL", key); err != nil {
+		log.Error("DelLockCache.conn.Do(del,%v) err(%v)", key, err)
+	} else {
+		log.Info("DelLockCache.conn.Do(del,%v)", key)
+	}
+	return
+}
+
+// GetExpireCountCache .
+func (d *Dao) GetExpireCountCache(c context.Context, k string) (count int64, err error) {
+	var (
+		key  = expireCountKey(k)
+		conn = d.redis.Get(c)
+	)
+
+	//spew.Dump(k)
+	defer conn.Close()
+	item, err := redis.Int(conn.Do("GET", key))
+	if err != nil {
+		if err == redis.ErrNil {
+			count = 0
+			err = nil
+		} else {
+			log.Error("conn.Do(GET %s) error(%v)", key, err)
+			return 0, err
+		}
+	}
+	count = int64(item)
+
+	return
+}
+
+// AddExpireCountCache .
+func (d *Dao) AddExpireCountCache(c context.Context, k string, times int64) (err error) {
+	var (
+		key  = expireCountKey(k)
+		conn = d.redis.Get(c)
+	)
+	//spew.Dump(k)
+	defer conn.Close()
+	if _, err = conn.Do("INCR", key); err != nil {
+		log.Error("conn.Do(incr,%v) err(%v)", key, err)
+	}
+
+	if _, err = redis.Bool(conn.Do("EXPIRE", key, times)); err != nil {
+		log.Error("conn.Do(EXPIRE, %s, %d) error(%v)", key, times, err)
+		return
+	}
+	return
+
+}
+
+// ClearExpireCountCache .
+func (d *Dao) ClearExpireCountCache(c context.Context, k string) (err error) {
+	var (
+		key  = expireCountKey(k)
+		conn = d.redis.Get(c)
+	)
+	//spew.Dump(k)
+	defer conn.Close()
+	if _, err = conn.Do("DEL", key); err != nil {
+		log.Error("conn.Do(del,%v) err(%v)", key, err)
+		return
+	}
+
+	return
+}
+
+//SetNxLock redis lock.
+func (d *Dao) SetNxLock(c context.Context, k string, times int64) (res bool, err error) {
+	var (
+		key  = lockKey(k)
+		conn = d.redis.Get(c)
+	)
+
+	defer conn.Close()
+	if res, err = redis.Bool(conn.Do("SETNX", key, "1")); err != nil {
+		log.Error("conn.Do(SETNX(%d)) error(%v)", key, err)
+		return
+	}
+	//spew.Dump(res, err )
+	if res {
+		if _, err = redis.Bool(conn.Do("EXPIRE", key, times)); err != nil {
+			log.Error("conn.Do(EXPIRE, %s, %d) error(%v)", key, times, err)
+			return
+		}
+		log.Info("conn.Do(EXPIRE, %s, %d) ", key, times)
+	}
+	return
+}

app/service/live/xrewardcenter/dao/anchorReward/redis_test.go

@@ -0,0 +1,115 @@
+package anchorReward
+
+import (
+	"context"
+	"testing"
+
+	"github.com/smartystreets/goconvey/convey"
+)
+
+func TestAnchorRewardlockKey(t *testing.T) {
+	convey.Convey("lockKey", t, func(ctx convey.C) {
+		var (
+			key = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := lockKey(key)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardexpireCountKey(t *testing.T) {
+	convey.Convey("expireCountKey", t, func(ctx convey.C) {
+		var (
+			key = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			p1 := expireCountKey(key)
+			ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) {
+				ctx.So(p1, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardDelLockCache(t *testing.T) {
+	convey.Convey("DelLockCache", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			k = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.DelLockCache(c, k)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardGetExpireCountCache(t *testing.T) {
+	convey.Convey("GetExpireCountCache", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			k = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			count, err := d.GetExpireCountCache(c, k)
+			ctx.Convey("Then err should be nil.count should not be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+				ctx.So(count, convey.ShouldNotBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardAddExpireCountCache(t *testing.T) {
+	convey.Convey("AddExpireCountCache", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			k     = ""
+			times = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.AddExpireCountCache(c, k, times)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardClearExpireCountCache(t *testing.T) {
+	convey.Convey("ClearExpireCountCache", t, func(ctx convey.C) {
+		var (
+			c = context.Background()
+			k = ""
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			err := d.ClearExpireCountCache(c, k)
+			ctx.Convey("Then err should be nil.", func(ctx convey.C) {
+				ctx.So(err, convey.ShouldBeNil)
+			})
+		})
+	})
+}
+
+func TestAnchorRewardSetNxLock(t *testing.T) {
+	convey.Convey("SetNxLock", t, func(ctx convey.C) {
+		var (
+			c     = context.Background()
+			k     = ""
+			times = int64(0)
+		)
+		ctx.Convey("When everything gose positive", func(ctx convey.C) {
+			res, err := d.SetNxLock(c, k, times)
+			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/service/live/xrewardcenter/dao/dao.go

@@ -0,0 +1,83 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/service/live/xrewardcenter/conf"
+	"go-common/library/cache/memcache"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+
+	gift_api "go-common/app/service/live/gift/api/liverpc"
+	room_api "go-common/app/service/live/room/api/liverpc"
+	"go-common/library/net/rpc/liverpc"
+)
+
+// Dao dao
+type Dao struct {
+	c     *conf.Config
+	mc    *memcache.Pool
+	redis *redis.Pool
+	db    *xsql.DB
+}
+
+// New init mysql db
+func New(c *conf.Config) (dao *Dao) {
+	dao = &Dao{
+		c:     c,
+		mc:    memcache.NewPool(c.Memcache),
+		redis: redis.NewPool(c.Redis),
+		db:    xsql.NewMySQL(c.MySQL),
+	}
+	return
+}
+
+// RoomAPI .
+var RoomAPI *room_api.Client
+
+// GiftAPI .
+var GiftAPI *gift_api.Client
+
+// InitAPI init all service APIs
+func InitAPI() {
+	RoomAPI = room_api.New(getConf("room"))
+	GiftAPI = gift_api.New(getConf("gift"))
+}
+
+func getConf(appName string) *liverpc.ClientConfig {
+	c := conf.Conf.LiveRpc
+	if c != nil {
+		return c[appName]
+	}
+	return nil
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	d.mc.Close()
+	d.redis.Close()
+	d.db.Close()
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	if err := d.db.Ping(c); err != nil {
+		log.Error("ping db error(%v)", err)
+		return err
+	}
+
+	return d.pingMemcache(c)
+}
+
+func (d *Dao) pingMemcache(c context.Context) (err error) {
+	conn := d.mc.Get(c)
+	defer conn.Close()
+	err = conn.Set(&memcache.Item{Key: "ping", Value: []byte("pong"), Expiration: 0})
+
+	if err != nil {
+		log.Error("mc.ping.Store error(%v)", err)
+		return err
+	}
+	return err
+}