Create & Init Project...

app/service/live/xlottery/dao/BUILD

@@ -0,0 +1,76 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "cache_test.go",
+        "storm_test.go",
+    ],
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/live/xlottery/model:go_default_library",
+        "//library/cache/redis:go_default_library",
+        "//library/container/pool:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/time:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "api.go",
+        "award.go",
+        "cache.go",
+        "capsule.go",
+        "capsule_extra.go",
+        "coin.go",
+        "coin_config.go",
+        "dao.go",
+        "pool.go",
+        "pool_prize.go",
+        "prize_extra.go",
+        "prize_log.go",
+        "storm.go",
+    ],
+    importpath = "go-common/app/service/live/xlottery/dao",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/service/live/gift/api/liverpc:go_default_library",
+        "//app/service/live/rc/api/liverpc:go_default_library",
+        "//app/service/live/rc/api/liverpc/v1:go_default_library",
+        "//app/service/live/userext/api/liverpc:go_default_library",
+        "//app/service/live/xlottery/api/grpc/v1:go_default_library",
+        "//app/service/live/xlottery/conf:go_default_library",
+        "//app/service/live/xlottery/model:go_default_library",
+        "//app/service/main/account/rpc/client: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",
+        "//library/queue/databus/report: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"],
+)

app/service/live/xlottery/dao/api.go

@@ -0,0 +1,38 @@
+package dao
+
+import (
+	giftApi "go-common/app/service/live/gift/api/liverpc"
+	rcApi "go-common/app/service/live/rc/api/liverpc"
+	userExtApi "go-common/app/service/live/userext/api/liverpc"
+	"go-common/app/service/live/xlottery/conf"
+	account "go-common/app/service/main/account/rpc/client"
+	"go-common/library/net/rpc/liverpc"
+)
+
+// AccountApi liverpc user api
+var AccountApi *account.Service3
+
+// GiftApi liverpc gift api
+var GiftApi *giftApi.Client
+
+// RcApi rc api
+var RcApi *rcApi.Client
+
+// UserExtApi userext api
+var UserExtApi *userExtApi.Client
+
+// InitAPI init all service APIs
+func InitAPI() {
+	AccountApi = account.New3(nil)
+	GiftApi = giftApi.New(getConf("gift"))
+	RcApi = rcApi.New(getConf("rc"))
+	UserExtApi = userExtApi.New(getConf("userext"))
+}
+
+func getConf(appName string) *liverpc.ClientConfig {
+	c := conf.Conf.LiveRpc
+	if c != nil {
+		return c[appName]
+	}
+	return nil
+}

app/service/live/xlottery/dao/award.go

@@ -0,0 +1,22 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	"go-common/library/log"
+)
+
+const (
+	_addAwardRecordMysql = "insert into ap_award_record(uid, gift_name, gift_type, gift_num, source, source_id, create_time, expire_time, status, user_extra_field) values(?,?,?,?,?,?,?,?,?,?)"
+)
+
+// AddAward .
+func (d *Dao) AddAward(ctx context.Context, uid int64, expireTime string, giftType int64, giftName string, giftNum int64, source string, sourceId int64) bool {
+	sql := _addAwardRecordMysql
+	affect, err := d.execSqlWithBindParams(ctx, &sql, uid, giftName, giftType, giftNum, source, sourceId, time.Now().Format("2006-01-02 15:04:05"), expireTime, 0, "")
+	if err != nil {
+		log.Error("[dao.mysql_lottery | AddAward] uid(%d) gift_name(%s) gift_type(%s) source(%s) error(%v)", uid, giftName, giftType, source, err)
+	}
+	return affect > 0
+}

app/service/live/xlottery/dao/cache.go

@@ -0,0 +1,169 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	stderr "errors"
+
+	"github.com/pkg/errors"
+
+	"go-common/library/cache/redis"
+	"go-common/library/log"
+)
+
+// Incr incr
+func (d *Dao) Incr(context context.Context, name string) int {
+	conn := d.redis.Get(context)
+	defer conn.Close()
+	reply, _ := redis.Int(conn.Do("INCR", name))
+	return reply
+}
+
+// Lock .
+func (d *Dao) Lock(ctx context.Context, realKey string, ttl int, retry int, retryDelay int) (gotLock bool, lockValue string, err error) {
+
+	if retry <= 0 {
+		retry = 1
+	}
+	lockValue = "locked:" + randomString(5)
+	retryTimes := 0
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+
+	for ; retryTimes < retry; retryTimes++ {
+		var res interface{}
+		res, err = conn.Do("SET", realKey, lockValue, "PX", ttl, "NX")
+		if err != nil {
+			log.Error("redis_lock failed:%s:%s", realKey, err.Error())
+			break
+		}
+
+		if res != nil {
+			gotLock = true
+			break
+		}
+		time.Sleep(time.Duration(retryDelay * 1000))
+	}
+	return
+}
+
+// UnLock .
+func (d *Dao) UnLock(ctx context.Context, realKey string, lockValue string) (err error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	res, err := redis.String(conn.Do("GET", realKey))
+	if err != nil {
+		return
+	}
+	if res != lockValue {
+		err = ErrUnLockGet
+		return
+	}
+
+	_, err = conn.Do("DEL", realKey)
+
+	return
+}
+
+// Get get
+func (d *Dao) Get(ctx context.Context, key string) (string, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	return redis.String(conn.Do("GET", key))
+
+}
+
+// GetInt64 GetInt64
+func (d *Dao) GetInt64(ctx context.Context, key string) (int64, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	return redis.Int64(conn.Do("GET", key))
+}
+
+// Set Set
+func (d *Dao) Set(ctx context.Context, key string, value interface{}) (bool, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	if _, err := redis.String(conn.Do("SET", key, value)); err != nil {
+		return false, errors.WithStack(err)
+	}
+	return true, nil
+
+}
+
+// SetEx SetEx
+func (d *Dao) SetEx(ctx context.Context, key string, value interface{}, ex int) (bool, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	if _, err := redis.String(conn.Do("SET", key, value, "EX", ex)); err != nil {
+		return false, errors.WithStack(err)
+	}
+	return true, nil
+
+}
+
+//HMSet HMSet
+func (d *Dao) HMSet(ctx context.Context, key string, value interface{}) (bool, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	arg := redis.Args{}.Add(key).AddFlat(value)
+	if _, err := redis.String(conn.Do("HMSET", arg...)); err != nil {
+		return false, errors.WithStack(err)
+	}
+	return true, nil
+}
+
+//Del Del
+func (d *Dao) Del(ctx context.Context, key string) (int64, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	return redis.Int64(conn.Do("DEL", key))
+
+}
+
+//SIsMember SIsMember
+func (d *Dao) SIsMember(ctx context.Context, key, value string) (bool, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	return redis.Bool(conn.Do("SISMEMBER", key, value))
+}
+
+//SAdd SAdd
+func (d *Dao) SAdd(ctx context.Context, key, value string) (int, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	return redis.Int(conn.Do("SADD", key, value))
+}
+
+// Expire Expire
+func (d *Dao) Expire(ctx context.Context, key string, ttl int) (bool, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	return redis.Bool(conn.Do("EXPIRE", key, ttl))
+}
+
+//ErrEmptyMap ErrEmptyMap
+var ErrEmptyMap = stderr.New("empty map")
+
+// HGetAll HGetAll
+func (d *Dao) HGetAll(ctx context.Context, key string) (map[string]string, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	m, err := redis.StringMap(conn.Do("HGETALL", key))
+	if err != nil {
+		return nil, err
+	}
+	if len(m) <= 0 {
+		return nil, ErrEmptyMap
+	}
+	return m, nil
+
+}
+
+// SetWithNxEx SetWithNxEx
+func (d *Dao) SetWithNxEx(ctx context.Context, key, value string, ex int64) (string, error) {
+	conn := d.redis.Get(ctx)
+	defer conn.Close()
+	return redis.String(conn.Do("SET", key, value, "EX", ex, "NX"))
+}

app/service/live/xlottery/dao/cache_test.go

@@ -0,0 +1,91 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"go-common/library/cache/redis"
+	"go-common/library/container/pool"
+	xtime "go-common/library/time"
+)
+
+var p *redis.Pool
+var config *redis.Config
+var d *Dao
+var ctx = context.TODO()
+
+func init() {
+	config = getConfig()
+	p = redis.NewPool(config)
+	d = &Dao{redis: p}
+}
+
+func getConfig() (c *redis.Config) {
+	c = &redis.Config{
+		Name:         "test",
+		Proto:        "tcp",
+		Addr:         "127.0.0.1:6379",
+		DialTimeout:  xtime.Duration(time.Second),
+		ReadTimeout:  xtime.Duration(time.Second),
+		WriteTimeout: xtime.Duration(time.Second),
+	}
+	c.Config = &pool.Config{
+		Active:      20,
+		Idle:        2,
+		IdleTimeout: xtime.Duration(90 * time.Second),
+	}
+	return
+}
+
+func TestDao_Get(t *testing.T) {
+	v, e := d.Get(ctx, "golang")
+	fmt.Println(v, e)
+}
+
+func TestDao_Set(t *testing.T) {
+	fmt.Println(d.Set(ctx, "golang", 22))
+}
+
+func TestDao_SetEx(t *testing.T) {
+	got, err := d.SetEx(ctx, "golang", "b", 10)
+	fmt.Println(got, err)
+
+}
+
+func TestDao_Del(t *testing.T) {
+	got, err := d.Del(ctx, "golang")
+	fmt.Println(got, err)
+
+}
+
+func TestDao_HMSet(t *testing.T) {
+	m := map[string]interface{}{"id": 1, "uid": 2, "content": "sss"}
+
+	got, err := d.HMSet(ctx, "myhash", m)
+	fmt.Println(got, err)
+
+	v, _ := d.HGetAll(ctx, "myhash")
+
+	fmt.Printf("%+v\n", v)
+}
+
+func TestDao_Expire(t *testing.T) {
+	got, err := d.Expire(ctx, "ttl", 10)
+	fmt.Println(got, err)
+}
+
+func TestDao_HGetAll(t *testing.T) {
+	got, err := d.HGetAll(ctx, "myhash")
+	if err != nil && err != ErrEmptyMap {
+		fmt.Println(err.Error())
+	}
+
+	fmt.Printf("%+v ,%+v", got, err)
+
+}
+
+func TestDao_SetWithNxEx(t *testing.T) {
+	fmt.Println(d.SetWithNxEx(ctx, "python", "1", 100))
+}

app/service/live/xlottery/dao/capsule_extra.go

@@ -0,0 +1,80 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"go-common/app/service/live/xlottery/model"
+	"strings"
+
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getExtraDataByTypeMysql = "select type, item_value, item_extra, ctime, mtime from capsule_extra_data where uid = ? and type in (%v)"
+	_addExtraDataMysql       = "insert into capsule_extra_data(uid,type,item_value,item_extra) values "
+	_updateExtraValueMysql   = "update capsule_extra_data set item_value = ? where uid = ? and type = ?"
+)
+
+// GetExtraDataByType 添加数据
+func (d *Dao) GetExtraDataByType(ctx context.Context, uid int64, types []string) (extraData []*model.ExtraData, err error) {
+	var rows *sql.Rows
+	var typeString []string
+	for _, etype := range types {
+		typeString = append(typeString, "'"+etype+"'")
+	}
+	sqlStr := fmt.Sprintf(_getExtraDataByTypeMysql, strings.Join(typeString, ","))
+	if rows, err = d.db.Query(ctx, sqlStr, uid); err != nil {
+		log.Error("[dao.extra | GetExtraDataByType] query(%s) error (%v)", sqlStr, err)
+		return
+	}
+	defer rows.Close()
+	extraData = make([]*model.ExtraData, 0)
+	for rows.Next() {
+		p := &model.ExtraData{}
+		if err = rows.Scan(&p.Type, &p.ItemValue, &p.ItemExtra, &p.Ctime, &p.Mtime); err != nil {
+			log.Error("[dao.extra | GetExtraDataByType] scan error, err %v", err)
+			return
+		}
+		extraData = append(extraData, p)
+	}
+	return
+}
+
+// AddExtraData 添加数据
+func (d *Dao) AddExtraData(ctx context.Context, extraData []*model.ExtraData) (status bool, err error) {
+	sqlStr := _addExtraDataMysql + strings.Repeat("(?,?,?,?),", len(extraData))
+	slen := len(sqlStr) - 1
+	sqlStr = sqlStr[0:slen]
+	values := make([]interface{}, len(extraData)*4)
+	for i, extra := range extraData {
+		values[i*4] = extra.Uid
+		values[i*4+1] = extra.Type
+		values[i*4+2] = extra.ItemValue
+		values[i*4+3] = extra.ItemExtra
+	}
+	res, err := d.db.Exec(ctx, sqlStr, values...)
+	if err != nil {
+		log.Error("[dao.extra | AddExtraData] add(%s) error (%v)", sqlStr, err)
+		return
+	}
+	rows, _ := res.RowsAffected()
+	status = rows > 0
+	return
+}
+
+// UpdateExtraValue 更新数据
+func (d *Dao) UpdateExtraValue(ctx context.Context, uid int64, etype string, itemValue int64) (status bool, err error) {
+	res, err := d.db.Exec(ctx, _updateExtraValueMysql, itemValue, uid, etype)
+	if err != nil {
+		log.Error("[dao.extra | UpdateExtraValue] update(%s) error(%v)", _updateExtraValueMysql, err)
+		return false, err
+	}
+	var rows int64
+	rows, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.extra | UpdateExtraValue]  err %v", err)
+		return false, err
+	}
+	return rows > 0, nil
+}

app/service/live/xlottery/dao/coin.go

@@ -0,0 +1,130 @@
+package dao
+
+import (
+	"context"
+
+	v1pb "go-common/app/service/live/xlottery/api/grpc/v1"
+	"go-common/app/service/live/xlottery/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getAllCoin   = "SELECT id, title, gift_type, change_num, start_time, end_time, status FROM capsule_coin"
+	_updateStatus = "UPDATE capsule_coin SET status = ? WHERE id = ?"
+	_delCoin      = "DELETE FROM capsule_coin WHERE id = ?"
+	_createCoin   = "INSERT INTO capsule_coin (title, gift_type, change_num, start_time, end_time, status) VALUES (?,?,?,?,?,?)"
+	_updateCoin   = "UPDATE capsule_coin SET title = ?, gift_type = ?, change_num = ?, start_time = ?, end_time = ?, status = ? WHERE id = ?"
+	_getOnCoin    = "SELECT id, title, gift_type, change_num, start_time, end_time, status FROM capsule_coin WHERE status = 1"
+)
+
+//GetAllCoin 获取所有扭蛋币
+func (d *Dao) GetAllCoin(ctx context.Context) (coins []*model.Coin, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(ctx, _getAllCoin); err != nil {
+		log.Error("[dao.coin | GetALLCoin] query(%s) error (%v)", _getAllCoin, err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		p := &model.Coin{}
+		if err = rows.Scan(&p.Id, &p.Title, &p.GiftType, &p.ChangeNum, &p.StartTime, &p.EndTime, &p.Status); err != nil {
+			log.Error("[dao.coin | GetAllCoin] scan error, err %v", err)
+			return
+		}
+		coins = append(coins, p)
+	}
+	return
+}
+
+//GetCoinMap 批量获取扭蛋币
+func (d *Dao) GetCoinMap(ctx context.Context) (coinMap map[int64]*model.Coin, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(ctx, _getOnCoin); err != nil {
+		log.Error("[dao.coin | GetCoinMap] query(%s) error(%v)", _getOnCoin, err)
+		return
+	}
+	defer rows.Close()
+
+	coinMap = make(map[int64]*model.Coin)
+	for rows.Next() {
+		p := &model.Coin{}
+		if err = rows.Scan(&p.Id, &p.Title, &p.GiftType, &p.ChangeNum, &p.StartTime, &p.EndTime, &p.Status); err != nil {
+			log.Error("[dao.coin | GetCoinMap] scan error, err %v", err)
+			return
+		}
+		coinMap[p.Id] = p
+	}
+	return
+}
+
+//UpdateCoinStatus 更新扭蛋币状态
+func (d *Dao) UpdateCoinStatus(ctx context.Context, id int64, status int64) (bool, error) {
+	res, err := d.db.Exec(ctx, _updateStatus, status, id)
+	if err != nil {
+		log.Error("[dao.coin | UpdateCStatus] query(%s) error(%v)", _updateStatus, err)
+		return false, err
+	}
+	var rows int64
+	rows, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.coin | UpdateCStatus] no coin is affected, err %v", err)
+		return false, err
+	}
+	return rows > 0, nil
+}
+
+//DeleteCoin 删除扭蛋币
+func (d *Dao) DeleteCoin(ctx context.Context, id int64) (status bool, err error) {
+	res, err := d.db.Exec(ctx, _delCoin, id)
+	if err != nil {
+		log.Error("[dao.coin | DelCoin] query(%s), error(%v)", _delCoin, err)
+		return
+	}
+	var rows int64
+	rows, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.coin | DelCoin] no coin is deleted, err %v", err)
+		return
+	}
+	status = rows > 0
+	return
+}
+
+// CreateCoin 更新扭蛋币
+func (d *Dao) CreateCoin(ctx context.Context, data *v1pb.UpdateCoinConfigReq) (ret int64, err error) {
+	title := data.Title
+	giftType := data.GiftType
+	changeNum := data.ChangeNum
+	startTime := data.StartTime
+	endTime := data.EndTime
+	status := 1
+	res, err := d.db.Exec(ctx, _createCoin, title, giftType, changeNum, startTime, endTime, status)
+	if err != nil {
+		log.Error("[dao.coin | CreateCoin] query(%s) error (%v)", _createCoin, err)
+		return
+	}
+	ret, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.coin | CreateCoin]no coin is added, err %v", err)
+		return
+	}
+	return
+}
+
+// UpdateCoin 更新扭蛋币
+func (d *Dao) UpdateCoin(ctx context.Context, data *v1pb.UpdateCoinConfigReq) (status bool, err error) {
+	id := data.Id
+	title := data.Title
+	giftType := data.GiftType
+	changeNum := data.ChangeNum
+	startTime := data.StartTime
+	endTime := data.EndTime
+	_, err = d.db.Exec(ctx, _updateCoin, title, giftType, changeNum, startTime, endTime, 1, id)
+	if err != nil {
+		log.Error("[dao.coin | UpdateCoin] query(%s) error %v", _updateCoin, err)
+		return
+	}
+	return true, nil
+}

app/service/live/xlottery/dao/coin_config.go

@@ -0,0 +1,113 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	v1pb "go-common/app/service/live/xlottery/api/grpc/v1"
+	"go-common/app/service/live/xlottery/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getCoinConfig    = "SELECT coin_id, type, area_v2_parent_id, area_v2_id, gift_id FROM capsule_coin_config WHERE coin_id = ? AND status = 1 "
+	_getCoinConfigMap = "SELECT coin_id, type, area_v2_parent_id, area_v2_id, gift_id FROM capsule_coin_config WHERE coin_id in (%v) AND status = 1"
+	_updateCoinConfig = "UPDATE capsule_coin_config SET status = ? WHERE coin_id = ?"
+	_addCoinConfig    = "INSERT INTO capsule_coin_config (type,gift_id,area_v2_parent_id,area_v2_id,coin_id,status) VALUES "
+)
+
+//GetCoinConfig 获取扭蛋币配置
+func (d *Dao) GetCoinConfig(ctx context.Context, coinId int64) (configs []*model.CoinConfig, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(ctx, _getCoinConfig, coinId); err != nil {
+		log.Error("[dao.coin_config | GetCoinConfig]query(%s) error(%v)", _getCoinConfig, err)
+		return
+	}
+	defer rows.Close()
+
+	configs = make([]*model.CoinConfig, 0)
+	for rows.Next() {
+		d := &model.CoinConfig{}
+		if err = rows.Scan(&d.CoinId, &d.Type, &d.AreaV2ParentId, &d.AreaV2Id, &d.GiftId); err != nil {
+			log.Error("[dao.coin_config | GetCoinConfig] scan error, err %v", err)
+			return
+		}
+		configs = append(configs, d)
+	}
+	return
+}
+
+//GetCoinConfigMap 批量获取扭蛋币
+func (d *Dao) GetCoinConfigMap(ctx context.Context, coinIds []int64) (configMap map[int64][]*model.CoinConfig, err error) {
+	var rows *sql.Rows
+	stringCoinIds := make([]string, 0)
+	for _, coinId := range coinIds {
+		stringCoinIds = append(stringCoinIds, strconv.FormatInt(coinId, 10))
+	}
+	coinString := strings.Join(stringCoinIds, ",")
+	if rows, err = d.db.Query(ctx, fmt.Sprintf(_getCoinConfigMap, coinString)); err != nil {
+		log.Error("[dao.coin_config | GetCoinConfigMap]query(%s) error(%v)", _getCoinConfigMap, err)
+		return
+	}
+	defer rows.Close()
+
+	configMap = make(map[int64][]*model.CoinConfig)
+	for rows.Next() {
+		d := &model.CoinConfig{}
+		if err = rows.Scan(&d.CoinId, &d.Type, &d.AreaV2ParentId, &d.AreaV2Id, &d.GiftId); err != nil {
+			log.Error("[dao.coin_config | GetCoinConfigMap] scan error, err %v", err)
+			return
+		}
+		if _, ok := configMap[d.CoinId]; !ok {
+			configMap[d.CoinId] = make([]*model.CoinConfig, 0)
+		}
+		configMap[d.CoinId] = append(configMap[d.CoinId], d)
+	}
+	return
+}
+
+//UpdateCoinConfig 更新扭蛋币配置
+func (d *Dao) UpdateCoinConfig(ctx context.Context, coinId int64, areaIds []*v1pb.UpdateCoinConfigReq_AreaIds, giftIds []int64) (status bool, err error) {
+	_, err = d.db.Exec(ctx, _updateCoinConfig, 2, coinId)
+	if err != nil {
+		log.Error("[dao.coin_config | UpdateCoinConfig] query(%s) error(%v)", _updateCoinConfig, err)
+		return
+	}
+	rowFields := make([][6]interface{}, 0)
+	for _, giftId := range giftIds {
+		rowFields = append(rowFields, [6]interface{}{2, giftId, 0, 0, coinId, 1})
+	}
+	if len(areaIds) != 0 {
+		for _, areaId := range areaIds {
+			if areaId.IsAll == 1 {
+				rowFields = append(rowFields, [6]interface{}{1, 0, areaId.ParentId, areaId.ParentId, coinId, 1})
+			} else {
+				for _, areaV2Id := range areaId.List {
+					rowFields = append(rowFields, [6]interface{}{1, 0, areaId.ParentId, areaV2Id, coinId, 1})
+				}
+
+			}
+		}
+	}
+	sqlStr := _addCoinConfig + strings.Repeat("(?,?,?,?,?,?),", len(rowFields))
+	slen := len(sqlStr) - 1
+	sqlStr = sqlStr[0:slen]
+	values := make([]interface{}, len(rowFields)*6)
+	for i, field := range rowFields {
+		for j, v := range field {
+			ix := i*6 + j
+			values[ix] = v
+		}
+	}
+	res, err := d.db.Exec(ctx, sqlStr, values...)
+	if err != nil {
+		log.Error("[dao.coin_config | UpdateCoinConfig] insert(%s) error(%v)", sqlStr, err)
+		return
+	}
+	rows, _ := res.RowsAffected()
+	status = rows > 0
+	return
+}

app/service/live/xlottery/dao/dao.go

@@ -0,0 +1,63 @@
+package dao
+
+import (
+	"context"
+	"time"
+
+	"math/rand"
+
+	"go-common/app/service/live/xlottery/conf"
+	"go-common/library/cache/redis"
+	xsql "go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+// 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,
+		redis: redis.NewPool(c.Redis.Lottery),
+		db:    xsql.NewMySQL(c.Database.Lottery),
+	}
+	return
+}
+
+// Close close the resource.
+func (d *Dao) Close() {
+	d.redis.Close()
+	d.db.Close()
+}
+
+// Ping dao ping
+func (d *Dao) Ping(c context.Context) error {
+	return d.db.Ping(c)
+}
+
+//　通过提供的sql和bind来更新，没有实际业务意义，只是为了少写重复代码
+func (d *Dao) execSqlWithBindParams(c context.Context, sql *string, bindParams ...interface{}) (affect int64, err error) {
+	res, err := d.db.Exec(c, *sql, bindParams...)
+	if err != nil {
+		log.Error("db.Exec(%s) error(%v)", *sql, err)
+		return
+	}
+	return res.RowsAffected()
+}
+
+func randomString(l int) string {
+	str := "0123456789abcdefghijklmnopqrstuvwxyz"
+	bytes := []byte(str)
+	result := []byte{}
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	for i := 0; i < l; i++ {
+		result = append(result, bytes[r.Intn(len(bytes))])
+	}
+	return string(result)
+}

app/service/live/xlottery/dao/pool.go

@@ -0,0 +1,169 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	v1pb "go-common/app/service/live/xlottery/api/grpc/v1"
+	"go-common/app/service/live/xlottery/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getPool       = "SELECT id, coin_id, title, rule, start_time, end_time, status, is_bottom FROM capsule_pool"
+	_getOnePool    = "SELECT id, coin_id,title,rule,start_time,end_time,status, is_bottom FROM capsule_pool WHERE id = ?"
+	_updatePStatus = "UPDATE capsule_pool SET status = ? WHERE id = ?"
+	_delPool       = "DELETE FROM capsule_pool WHERE id = ?"
+	_createPool    = "INSERT INTO capsule_pool (coin_id,title,rule,start_time,end_time,status) VALUES (?,?,?,?,?,0)"
+	_updatePool    = "UPDATE capsule_pool SET coin_id = ?, title = ?, rule = ?, start_time = ?, end_time = ? WHERE id = ?"
+	_getPoolMap    = "SELECT id, coin_id, title, rule, start_time, end_time, status, is_bottom FROM capsule_pool WHERE status = 1 and coin_id in (%v)"
+)
+
+//GetAllPool 获取奖池信息
+func (d *Dao) GetAllPool(ctx context.Context) (pools []*model.Pool, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(ctx, _getPool); err != nil {
+		log.Error("[dao.pool | GetAllPool] query(%s) error(%v)", _getPool, err)
+		return
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		p := &model.Pool{}
+		if err = rows.Scan(&p.Id, &p.CoinId, &p.Title, &p.Description, &p.StartTime, &p.EndTime, &p.Status, &p.IsBottom); err != nil {
+			log.Error("[dao.pool | GetAllPool] scan error, err %v", err)
+			return
+		}
+		pools = append(pools, p)
+	}
+	return
+}
+
+//GetPoolMap 批量奖池信息
+func (d *Dao) GetPoolMap(ctx context.Context, coinIds []int64) (poolMap map[int64][]*model.Pool, err error) {
+	var rows *sql.Rows
+	stringCoinIds := make([]string, 0)
+	for _, coinId := range coinIds {
+		stringCoinIds = append(stringCoinIds, strconv.FormatInt(coinId, 10))
+	}
+	coinString := strings.Join(stringCoinIds, ",")
+	if rows, err = d.db.Query(ctx, fmt.Sprintf(_getPoolMap, coinString)); err != nil {
+		log.Error("[dao.pool | GetPoolMap]query(%s) error(%v)", _getPoolMap, err)
+		return
+	}
+	defer rows.Close()
+
+	poolMap = make(map[int64][]*model.Pool)
+	for rows.Next() {
+		d := &model.Pool{}
+		if err = rows.Scan(&d.Id, &d.CoinId, &d.Title, &d.Description, &d.StartTime, &d.EndTime, &d.Status, &d.IsBottom); err != nil {
+			log.Error("[dao.pool |GetPoolMap] scan error, err %v", err)
+			return
+		}
+		if _, ok := poolMap[d.CoinId]; !ok {
+			poolMap[d.CoinId] = make([]*model.Pool, 0)
+		}
+		poolMap[d.CoinId] = append(poolMap[d.CoinId], d)
+	}
+	return
+}
+
+// GetPoolById 通过ID获取奖池信息
+func (d *Dao) GetPoolById(ctx context.Context, poolID int64) (pool *model.Pool, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(ctx, _getOnePool, poolID); err != nil {
+		log.Error("[dao.pool | GetPoolById]query(%s) error(%v)", _getOnePool, err)
+		return
+	}
+	defer rows.Close()
+	for rows.Next() {
+		p := &model.Pool{}
+		if err = rows.Scan(&p.Id, &p.CoinId, &p.Title, &p.Description, &p.StartTime, &p.EndTime, &p.Status, &p.IsBottom); err != nil {
+			log.Error("[dao.pool | GetPoolById] scan error, err %v", err)
+			return
+		}
+		pool = p
+	}
+	return
+}
+
+//UpdatePoolStatus 更新奖池状态
+func (d *Dao) UpdatePoolStatus(ctx context.Context, id int64, status int64) (bool, error) {
+	//s := fmt.Sprintf(_updatePStatus, status, id)
+	res, err := d.db.Exec(ctx, _updatePStatus, status, id)
+	if err != nil {
+		log.Error("[dao.pool | UpdatePoolStatus] query(%s) error(%v)", _updatePStatus, err)
+		return false, err
+	}
+	var rows int64
+	rows, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.pool | UpdatePoolStatus] no coin is affected, err %v", err)
+		return false, err
+	}
+	return rows > 0, nil
+}
+
+//DelPool 删除奖池
+func (d *Dao) DelPool(ctx context.Context, id int64) (rows int64, err error) {
+	res, err := d.db.Exec(ctx, _delPool, id)
+	if err != nil {
+		log.Error("[dao.pool | DelPool]query(%s) error(%v)", _delPool, err)
+		return
+	}
+	rows, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.pool | DelPool]no pool is deleted, err %v", err)
+		return
+	}
+	return
+}
+
+//CreatePool 新建奖池
+func (d *Dao) CreatePool(ctx context.Context, data *v1pb.UpdatePoolReq) (status bool, err error) {
+	coinId := data.CoinId
+	title := data.Title
+	startTime := data.StartTime
+	endTime := data.EndTime
+	rule := data.Rule
+	//s := fmt.Sprintf(_createPool,coinTitle,title,rule,startTime,endTime)
+	res, err := d.db.Exec(ctx, _createPool, coinId, title, rule, startTime, endTime)
+	if err != nil {
+		log.Error("[dao.pool | CreatePool] query(%s) error(%v)", _createPool, err)
+		return
+	}
+	var rows int64
+	rows, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.pool | CreatePool] no pool is created, err %v", err)
+		return
+	}
+	status = rows > 0
+	return
+}
+
+//UpdatePool 更新奖池
+func (d *Dao) UpdatePool(ctx context.Context, data *v1pb.UpdatePoolReq) (status bool, err error) {
+	id := data.Id
+	coinId := data.CoinId
+	title := data.Title
+	startTime := data.StartTime
+	endTime := data.EndTime
+	rule := data.Rule
+	res, err := d.db.Exec(ctx, _updatePool, coinId, title, rule, startTime, endTime, id)
+	if err != nil {
+		log.Error("[dao.pool | UpdatePool] query(%s) error(%v)", _updatePool, err)
+		return
+	}
+	var rows int64
+	rows, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.pool | UpdatePool] no pool is updated, err %v", err)
+		return
+	}
+	status = rows > 0
+	return
+}

app/service/live/xlottery/dao/pool_prize.go

@@ -0,0 +1,116 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	v1pb "go-common/app/service/live/xlottery/api/grpc/v1"
+	"go-common/app/service/live/xlottery/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getPoolPrize    = "SELECT id, pool_id, type, num, object_id,expire, web_url, mobile_url, description, jump_url, pro_type, chance, loop_num, limit_num, weight FROM capsule_pool_prize WHERE pool_id = ? and status = 1 order by ctime"
+	_delPoolPrize    = "UPDATE capsule_pool_prize set status = 0 WHERE id = ?"
+	_addPoolPrize    = "INSERT INTO capsule_pool_prize(pool_id,type,num,object_id,expire,web_url,mobile_url,description,jump_url,pro_type,chance,loop_num,limit_num,weight,status) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+	_updatePoolPrize = "UPDATE capsule_pool_prize SET pool_id=?, type=?, num=?, object_id=?,expire=?, web_url=?, mobile_url=?, description=?, jump_url=?, pro_type=?, chance=?, loop_num=?, limit_num=?,weight=? WHERE id = ?"
+	_getPoolPrizeMap = "SELECT id, pool_id, type, num, object_id,expire, web_url, mobile_url, description, jump_url, pro_type, chance, loop_num, limit_num, weight FROM capsule_pool_prize WHERE pool_id in (%s) and status = 1 order by ctime"
+)
+
+// GetPoolPrize 获取奖池奖品
+func (d *Dao) GetPoolPrize(ctx context.Context, poolID int64) (poolPrize []*model.PoolPrize, err error) {
+	var rows *sql.Rows
+	if rows, err = d.db.Query(ctx, _getPoolPrize, poolID); err != nil {
+		log.Error("[dao.pool_prize | GetPoolPrize]query(%s) error(%v)", _getPoolPrize, err)
+		return
+	}
+	defer rows.Close()
+
+	poolPrize = make([]*model.PoolPrize, 0)
+	for rows.Next() {
+		p := &model.PoolPrize{}
+		if err = rows.Scan(&p.Id, &p.PoolId, &p.Type, &p.Num, &p.ObjectId, &p.Expire, &p.WebUrl, &p.MobileUrl, &p.Description, &p.JumpUrl, &p.ProType, &p.Chance, &p.LoopNum, &p.LimitNum, &p.Weight); err != nil {
+			log.Error("[dao.pool_prize | GetPoolPrize] scan error, err %v", err)
+			return
+		}
+		poolPrize = append(poolPrize, p)
+	}
+	return
+}
+
+// GetPoolPrizeMap 批量奖池奖品
+func (d *Dao) GetPoolPrizeMap(ctx context.Context, poolIds []int64) (poolPrizeMap map[int64][]*model.PoolPrize, err error) {
+	var rows *sql.Rows
+	stringPoolIds := make([]string, 0)
+	for _, poolId := range poolIds {
+		stringPoolIds = append(stringPoolIds, strconv.FormatInt(poolId, 10))
+	}
+	poolString := strings.Join(stringPoolIds, ",")
+	if rows, err = d.db.Query(ctx, fmt.Sprintf(_getPoolPrizeMap, poolString)); err != nil {
+		log.Error("[dao.pool_prize | GetPoolPrizeMap] query(%s) error(%v)", _getPoolPrizeMap, err)
+		return
+	}
+	defer rows.Close()
+
+	poolPrizeMap = make(map[int64][]*model.PoolPrize)
+	for rows.Next() {
+		d := &model.PoolPrize{}
+		if err = rows.Scan(&d.Id, &d.PoolId, &d.Type, &d.Num, &d.ObjectId, &d.Expire, &d.WebUrl, &d.MobileUrl, &d.Description, &d.JumpUrl, &d.ProType, &d.Chance, &d.LoopNum, &d.LimitNum, &d.Weight); err != nil {
+			log.Error("[dao.pool_prize | GetPoolPrizeMap] scan error, err %v", err)
+			return
+		}
+		if _, ok := PrizeNameMap[d.Type]; !ok {
+			continue
+		}
+		if _, ok := poolPrizeMap[d.PoolId]; !ok {
+			poolPrizeMap[d.PoolId] = make([]*model.PoolPrize, 0)
+		}
+		poolPrizeMap[d.PoolId] = append(poolPrizeMap[d.PoolId], d)
+	}
+	return
+}
+
+// DeletePoolPrize 删除奖池奖品
+func (d *Dao) DeletePoolPrize(ctx context.Context, id int64) (status bool, err error) {
+	res, err := d.db.Exec(ctx, _delPoolPrize, id)
+	if err != nil {
+		log.Error("[dao.pool_prize | DelPoolDetail] query(%s) error (%v)", _delPoolPrize, err)
+		return
+	}
+	var rows int64
+	rows, err = res.RowsAffected()
+	if err != nil {
+		log.Error("[dao.pool_prize | DelPoolDetail] no poolDetail is deleted, err %v", err)
+		return
+	}
+	status = rows > 0
+	return
+}
+
+// AddPoolPrize 创建奖池奖品
+func (d *Dao) AddPoolPrize(ctx context.Context, data *v1pb.UpdatePoolPrizeReq) (prizeId int64, err error) {
+	res, err := d.db.Exec(ctx, _addPoolPrize, data.PoolId, data.Type, data.Num, data.ObjectId, data.Expire, data.WebUrl, data.MobileUrl, data.Description, data.JumpUrl, data.ProType, data.Chance, data.Loop, data.Limit, data.Weight, 1)
+	if err != nil {
+		log.Error("[dao.pool_prize | CreatePoolPrize] query(%s) error (%v)", _addPoolPrize, err)
+		return
+	}
+	prizeId, err = res.LastInsertId()
+	if err != nil {
+		log.Error("[dao.pool_prize | CreatePoolPrize] insertLastId error(%v)", err)
+		return
+	}
+	return
+}
+
+// UpdatePoolPrize 更新奖池奖品
+func (d *Dao) UpdatePoolPrize(ctx context.Context, data *v1pb.UpdatePoolPrizeReq) (status bool, err error) {
+	_, err = d.db.Exec(ctx, _updatePoolPrize, data.PoolId, data.Type, data.Num, data.ObjectId, data.Expire, data.WebUrl, data.MobileUrl, data.Description, data.JumpUrl, data.ProType, data.Chance, data.Loop, data.Limit, data.Weight, data.Id)
+	if err != nil {
+		log.Error("[dao.pool_prize | UpdatePoolPrize] query(%s) error(%v)", _updatePoolPrize, err)
+		return
+	}
+	return true, nil
+}

app/service/live/xlottery/dao/prize_extra.go

@@ -0,0 +1,78 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_getWhiteList    = "select prize_id, item_id from capsule_prize_extra WHERE prize_id in (%v) and type = ? and status = 1 order by id"
+	_updateWhiteList = "UPDATE capsule_prize_extra SET status = ? WHERE prize_id = ?"
+	_addWhiteUser    = "INSERT INTO capsule_prize_extra (prize_id,type,item_id,status) VALUES "
+	_whiteType       = 1
+)
+
+// GetWhiteUserMap 获取白名单用户
+func (d *Dao) GetWhiteUserMap(ctx context.Context, prizeIds []int64) (userMap map[int64][]int64, err error) {
+	var rows *sql.Rows
+	stringPrizeIds := make([]string, len(prizeIds))
+	for ix, prizeId := range prizeIds {
+		stringPrizeIds[ix] = strconv.FormatInt(prizeId, 10)
+	}
+	sqlStr := fmt.Sprintf(_getWhiteList, strings.Join(stringPrizeIds, ","))
+	if rows, err = d.db.Query(ctx, sqlStr, _whiteType); err != nil {
+		log.Error("[dao.pool_prize | GetPoolPrize]query(%s) error(%v)", _getWhiteList, err)
+		return
+	}
+	defer rows.Close()
+
+	userMap = make(map[int64][]int64)
+	for rows.Next() {
+		var uid, prizeId int64
+		if err = rows.Scan(&prizeId, &uid); err != nil {
+			log.Error("[dao.pool_prize | GetWhiteUser] scan error, err %v", err)
+			return
+		}
+		if _, ok := userMap[prizeId]; !ok {
+			userMap[prizeId] = make([]int64, 0)
+		}
+		userMap[prizeId] = append(userMap[prizeId], uid)
+	}
+	return
+}
+
+// AddWhiteUser 添加白名单用户
+func (d *Dao) AddWhiteUser(ctx context.Context, prizeId int64, uids []int64) (status bool, err error) {
+	_, err = d.db.Exec(ctx, _updateWhiteList, 0, prizeId)
+	if err != nil {
+		log.Error("[dao.pool_prize | AddWhiteUids] update(%s) error(%v)", _updateWhiteList, err)
+		return
+	}
+	rowFields := make([][4]interface{}, 0)
+	for _, uid := range uids {
+		rowFields = append(rowFields, [4]interface{}{prizeId, _whiteType, uid, 1})
+	}
+	sqlStr := _addWhiteUser + strings.Repeat("(?,?,?,?),", len(rowFields))
+	slen := len(sqlStr) - 1
+	sqlStr = sqlStr[0:slen]
+	values := make([]interface{}, len(rowFields)*4)
+	for i, field := range rowFields {
+		for j, v := range field {
+			ix := i*4 + j
+			values[ix] = v
+		}
+	}
+	res, err := d.db.Exec(ctx, sqlStr, values...)
+	if err != nil {
+		log.Error("[dao.prize_extra | AddWhiteUser] add(%s) error (%v)", sqlStr, err)
+		return
+	}
+	rows, _ := res.RowsAffected()
+	status = rows > 0
+	return
+}

app/service/live/xlottery/dao/prize_log.go

@@ -0,0 +1,56 @@
+package dao
+
+import (
+	"context"
+	"go-common/app/service/live/xlottery/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_addPrizeData     = "INSERT INTO capsule_prize_log (prize_id,uid,day,timestamp) VALUES (?,?,?,?)"
+	_getUserPrizeData = "SELECT prize_id,uid,day,`timestamp` from capsule_prize_log where prize_id = ? and uid = ? order by id desc"
+	_getPrizeDayData  = "SELECT prize_id,uid,day,`timestamp` from capsule_prize_log where prize_id = ? and day = ? order by id desc"
+)
+
+// AddPrizeData 添加特殊奖品获奖记录
+func (d *Dao) AddPrizeData(ctx context.Context, prizeId, uid int64, day string, timestamp int64) (status bool, err error) {
+	res, err := d.db.Exec(ctx, _addPrizeData, prizeId, uid, day, timestamp)
+	if err != nil {
+		log.Error("[dao.prize_extra | AddWhiteUser] add(%s) error (%v)", _addPrizeData, err)
+		return
+	}
+	rows, _ := res.RowsAffected()
+	status = rows > 0
+	return
+}
+
+// GetUserPrizeLog 获取特殊奖品记录
+func (d *Dao) GetUserPrizeLog(ctx context.Context, prizeId int64, uid int64) (prizeLog *model.PrizeLog, err error) {
+	row := d.db.QueryRow(ctx, _getUserPrizeData, prizeId, uid)
+	prizeLog = &model.PrizeLog{}
+	err = row.Scan(&prizeLog.PrizeId, &prizeLog.Uid, &prizeLog.Day, &prizeLog.Timestamp)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		log.Error("[dao.pool_prize | GetUserPrizeLog]query(%s) error(%v)", _getUserPrizeData, err)
+		return
+	}
+	return prizeLog, nil
+}
+
+// GetPrizeDayLog 获取特殊奖品记录
+func (d *Dao) GetPrizeDayLog(ctx context.Context, prizeId int64, day string) (prizeLog *model.PrizeLog, err error) {
+	row := d.db.QueryRow(ctx, _getPrizeDayData, prizeId, day)
+	prizeLog = &model.PrizeLog{}
+	err = row.Scan(&prizeLog.PrizeId, &prizeLog.Uid, &prizeLog.Day, &prizeLog.Timestamp)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		log.Error("[dao.pool_prize | GetPrizeDayLog]query(%s) error(%v)", _getPrizeDayData, err)
+		return
+	}
+	return
+}

app/service/live/xlottery/dao/storm.go

@@ -0,0 +1,54 @@
+package dao
+
+import (
+	"context"
+
+	"go-common/app/service/live/xlottery/model"
+
+	"github.com/pkg/errors"
+)
+
+// InsertSpecialGift 插入SpecialGift
+func (d *Dao) InsertSpecialGift(sg *model.SpecialGift) (int64, error) {
+
+	stmt, err := d.db.Prepare("insert into ap_special_gift (uid,room_id,gift_id,gift_num,create_time, custom_field) values (?,?,?,?,?,?) ")
+	if err != nil {
+		return 0, errors.WithStack(err)
+	}
+
+	result, err := stmt.Exec(context.TODO(), sg.UID, sg.RoomID, sg.GiftID, sg.GiftNum, sg.CreateTime, sg.CustomField)
+	if err != nil {
+		return 0, errors.WithStack(err)
+	}
+	return result.LastInsertId()
+}
+
+// FindBeatByBeatIDAndUID 根据beatid 和 uid 查询 beat
+func (d *Dao) FindBeatByBeatIDAndUID(id, uid int64) (*model.Beat, error) {
+	row := d.db.QueryRow(context.TODO(), "select id ,uid ,content,status, operator,update_time,ctime ,mtime from ap_user_beats_info where  id = ? and uid = ?", id, uid)
+	var b model.Beat
+	err := row.Scan(&b.ID, &b.UID, &b.Content, &b.Status, &b.Operator, &b.UpdateTime, &b.Ctime, &b.Mtime)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	return &b, nil
+}
+
+// FindShieldKeyWorkByUID 根据uid 查找屏蔽词
+func (d *Dao) FindShieldKeyWorkByUID(uid int64) ([]*model.ShieldKeyWork, error) {
+	row, err := d.db.Query(context.TODO(), "select id, uid ,original_keyword, keyword, ctime from ap_shield_keywork where uid = ?", uid)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	skArray := make([]*model.ShieldKeyWork, 0)
+	for row.Next() {
+		var b model.ShieldKeyWork
+		err := row.Scan(&b.ID, &b.UID, &b.OriginalKeyword, &b.KeyWord, &b.Ctime)
+		if err != nil {
+			return nil, errors.WithStack(err)
+		}
+		skArray = append(skArray, &b)
+	}
+
+	return skArray, nil
+}

app/service/live/xlottery/dao/storm_test.go

@@ -0,0 +1,58 @@
+package dao
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"go-common/app/service/live/xlottery/model"
+	xsql "go-common/library/database/sql"
+	xtime "go-common/library/time"
+)
+
+var db *xsql.DB
+
+func init() {
+	c := &xsql.Config{
+		Addr:         "172.16.38.117:3312",
+		DSN:          "live:oWni@ElNs0P0C(dphdj*F1y4@tcp(172.16.38.117:3312)/live-app?timeout=2000ms&readTimeout=2000ms&writeTimeout=2000ms&parseTime=true&loc=Local&charset=utf8,utf8mb4",
+		Active:       10,
+		Idle:         5,
+		IdleTimeout:  xtime.Duration(time.Minute),
+		QueryTimeout: xtime.Duration(time.Minute),
+		ExecTimeout:  xtime.Duration(time.Minute),
+		TranTimeout:  xtime.Duration(time.Minute),
+	}
+	db = xsql.NewMySQL(c)
+}
+func TestDao_InsertSpecialGift(t *testing.T) {
+	d := &Dao{
+		db: db,
+	}
+	got, err := d.InsertSpecialGift(&model.SpecialGift{
+		UID:        333,
+		RoomID:     33,
+		GiftID:     33,
+		GiftNum:    1,
+		CreateTime: time.Now(),
+		CustomField: "{\"content\":\"真是无法无天了。\"	}",
+	})
+	fmt.Println(got, err)
+}
+
+func TestDao_FindBeatByBeatIDAndUID(t *testing.T) {
+	d := &Dao{
+		db: db,
+	}
+	got, err := d.FindBeatByBeatIDAndUID(123, 10666892)
+
+	fmt.Println(got, err)
+}
+
+func TestDao_FindShieldKeyWorkByUID(t *testing.T) {
+	d := &Dao{
+		db: db,
+	}
+	got, err := d.FindShieldKeyWorkByUID(12209)
+	fmt.Println(got, err)
+}