268 lines
8.3 KiB
Go
268 lines
8.3 KiB
Go
package dao
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
pb "go-common/app/service/main/coin/api"
|
|
"go-common/library/database/sql"
|
|
"go-common/library/log"
|
|
)
|
|
|
|
const (
|
|
_dayOfEachMonth = 25
|
|
_sharding = 50
|
|
_getTotalCoins = "SELECT aid,type,SUM(multiply) FROM coin_member_%d WHERE mid = ? GROUP BY aid,type ORDER BY cid desc LIMIT 20"
|
|
_getTotalCoinsByMid = "SELECT IFNULL(SUM(multiply),0) FROM coin_member_%d WHERE mid=? AND aid=? AND type=?"
|
|
_getTotalCoinsByMidAndUpMid = "SELECT IFNULL(coin_count,0) FROM coin_user_count_%02d WHERE mid=? AND up_mid=?"
|
|
_getCoinCount = "SELECT IFNULL(count,0) FROM coin_count WHERE aid=? AND type=?"
|
|
_updateCoinCount = "INSERT INTO coin_count(aid, type, `count`, ctime, mtime) VALUES(?,?,?,?,?) ON DUPLICATE KEY UPDATE count=count+?,mtime=?"
|
|
_insertCoinArchive = "INSERT LOW_PRIORITY INTO coin_archive_%d (aid,type,mid,timestamp,multiply) VALUES (?,?,?,?,?)"
|
|
_insertCoinMember = "INSERT LOW_PRIORITY INTO coin_member_%d (aid,type,mid,timestamp,multiply,up_mid) VALUES (?,?,?,?,?,?)"
|
|
_updateCoinMemberCount = "INSERT INTO coin_user_count_%02d(mid, up_mid, coin_count, ctime) VALUES(?,?,?,?) ON DUPLICATE KEY UPDATE coin_count=coin_count+?"
|
|
_getMemberVideoList = "SELECT aid,ip,timestamp,multiply FROM coin_member_%d WHERE mid = ? AND type=? AND timestamp > ? ORDER BY cid DESC LIMIT ?"
|
|
// coin settle
|
|
_hitSettlePeriod = "SELECT id FROM coin_settle_period WHERE to_year=? AND to_month=?"
|
|
_updateSettleBD = "UPDATE coin_settle_%d SET exp_sub=?,description=?,itime=?,mtime=? WHERE aid=? and type=?" // update for bigdata
|
|
_updateArchiveCoinsBD = "UPDATE coin_count SET count=?, mtime=? WHERE aid=? AND type=?" // update for bigdata
|
|
)
|
|
|
|
func (dao *Dao) midHit(mid int64) int64 {
|
|
return mid % _sharding
|
|
}
|
|
|
|
func (dao *Dao) aidHit(aid int64) int64 {
|
|
return aid % _sharding
|
|
}
|
|
|
|
func (dao *Dao) hitCoinPeriod(c context.Context, now time.Time) (id int64, err error) {
|
|
year, month, day := now.Year(), now.Month(), now.Day()
|
|
if now.Day() < _dayOfEachMonth {
|
|
err = fmt.Errorf("opreation from bigdata must after the %dth of each month, today is (%d)", _dayOfEachMonth, day)
|
|
log.Error("%v", err)
|
|
return
|
|
}
|
|
row := dao.coin.QueryRow(c, _hitSettlePeriod, year, month)
|
|
if err != nil {
|
|
log.Error("dao.hitCoinPeriodStmt.QueryRow(%d, %d) error(%v)", year, month, err)
|
|
return
|
|
}
|
|
if err = row.Scan(&id); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
if id == 0 {
|
|
err = fmt.Errorf("zero id at(%s)", now.String())
|
|
log.Error("%v", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpdateCoinSettleBD update table coin_settle_%d.
|
|
func (dao *Dao) UpdateCoinSettleBD(c context.Context, aid, tp, expSub int64, describe string, now time.Time) (affect int64, err error) {
|
|
id, err := dao.hitCoinPeriod(c, now)
|
|
if err != nil {
|
|
return
|
|
}
|
|
sqlStr := fmt.Sprintf(_updateSettleBD, id)
|
|
result, err := dao.coin.Exec(c, sqlStr, expSub, describe, now, now, aid, tp)
|
|
if err != nil {
|
|
log.Error("dao.coin.Exec(%s, %d, %s, %v, %v, %d) error(%v)", sqlStr, expSub, describe, now, now, aid, err)
|
|
return
|
|
}
|
|
affect, err = result.LastInsertId()
|
|
return
|
|
}
|
|
|
|
// CoinList return video list of coin added in one month
|
|
func (dao *Dao) CoinList(c context.Context, mid, tp, ts, size int64) (rcs []*pb.ModelList, err error) {
|
|
var rows *sql.Rows
|
|
if rows, err = dao.coin.Query(c, fmt.Sprintf(_getMemberVideoList, dao.midHit(mid)), mid, tp, ts, size); err != nil {
|
|
log.Error("dao.getMemberVideoList.Query() error(%v)", err)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var rc = &pb.ModelList{}
|
|
if err = rows.Scan(&rc.Aid, &rc.IP, &rc.Ts, &rc.Number); err != nil {
|
|
log.Error("row.Scan(),error(%v)", err)
|
|
rcs = nil
|
|
return
|
|
}
|
|
rcs = append(rcs, rc)
|
|
}
|
|
return
|
|
}
|
|
|
|
// CoinsAddedByMid get coin added by mid of aid&tp.
|
|
func (dao *Dao) CoinsAddedByMid(c context.Context, mid, aid, tp int64) (added int64, err error) {
|
|
row := dao.coin.QueryRow(c, fmt.Sprintf(_getTotalCoinsByMid, dao.midHit(mid)), mid, aid, tp)
|
|
if err = row.Scan(&added); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
PromError("mysql:CoinsAddedByMid")
|
|
log.Errorv(c,
|
|
log.KV("log", "row.Scan"),
|
|
log.KV("err", err),
|
|
log.KV("mid", mid),
|
|
log.KV("aid", aid),
|
|
)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// AddedCoins get coins added to up_mid.
|
|
func (dao *Dao) AddedCoins(c context.Context, mid, upMid int64) (added int64, err error) {
|
|
row := dao.coin.QueryRow(c, fmt.Sprintf(_getTotalCoinsByMidAndUpMid, dao.midHit(mid)), mid, upMid)
|
|
if err = row.Scan(&added); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Error("row.Scan error(%v)", err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// UserCoinsAdded get user coin added.
|
|
func (dao *Dao) UserCoinsAdded(c context.Context, mid int64) (addeds map[int64]int64, err error) {
|
|
var rows *sql.Rows
|
|
addeds = make(map[int64]int64)
|
|
if rows, err = dao.coin.Query(c, fmt.Sprintf(_getTotalCoins, dao.midHit(mid)), mid); err != nil {
|
|
log.Errorv(c,
|
|
log.KV("log", "dao.getTotalCoins"),
|
|
log.KV("err", err),
|
|
log.KV("mid", mid),
|
|
)
|
|
PromError("db:UserCoinsAdded")
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var (
|
|
added, aid, tp int64
|
|
)
|
|
if err = rows.Scan(&aid, &tp, &added); err != nil {
|
|
log.Errorv(c,
|
|
log.KV("log", "row.Scan"),
|
|
log.KV("err", err),
|
|
log.KV("mid", mid),
|
|
)
|
|
PromError("db:UserCoinsAdded")
|
|
addeds = nil
|
|
return
|
|
}
|
|
addeds[hashField(aid, tp)] = added
|
|
}
|
|
return
|
|
}
|
|
|
|
// InsertCoinArchive .
|
|
func (dao *Dao) InsertCoinArchive(c context.Context, aid, tp, mid, timestamp, multiply int64) (err error) {
|
|
if _, err = dao.coin.Exec(c, fmt.Sprintf(_insertCoinArchive, dao.aidHit(aid)), aid, tp, mid, timestamp, multiply); err != nil {
|
|
log.Errorv(c,
|
|
log.KV("log", "coin.Exec"),
|
|
log.KV("err", err),
|
|
log.KV("mid", mid),
|
|
log.KV("aid", aid),
|
|
)
|
|
PromError("db:InsertCoinArchive")
|
|
}
|
|
return
|
|
}
|
|
|
|
// InsertCoinMember .
|
|
func (dao *Dao) InsertCoinMember(c context.Context, aid, tp, mid, timestamp, multiply int64, upMid int64) (err error) {
|
|
if _, err = dao.coin.Exec(c, fmt.Sprintf(_insertCoinMember, dao.midHit(mid)), aid, tp, mid, timestamp, multiply, upMid); err != nil {
|
|
log.Errorv(c,
|
|
log.KV("log", "coin.Exec"),
|
|
log.KV("err", err),
|
|
log.KV("mid", mid),
|
|
log.KV("aid", aid),
|
|
)
|
|
PromError("db:InsertCoinMember")
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpdateItemCoinCount update coin_count.
|
|
func (dao *Dao) UpdateItemCoinCount(c context.Context, aid, tp, count int64) (err error) {
|
|
now := time.Now()
|
|
if _, err = dao.coin.Exec(c, _updateCoinCount, aid, tp, count, now, now, count, now); err != nil {
|
|
log.Errorv(c,
|
|
log.KV("log", "UpdateItemCoinCount("),
|
|
log.KV("err", err),
|
|
log.KV("count", count),
|
|
log.KV("aid", aid),
|
|
)
|
|
PromError("db:UpdateItemCoinCount")
|
|
}
|
|
return
|
|
}
|
|
|
|
// RawItemCoin get count by aid.
|
|
func (dao *Dao) RawItemCoin(c context.Context, aid, tp int64) (count int64, err error) {
|
|
row := dao.coin.QueryRow(c, _getCoinCount, aid, tp)
|
|
if err = row.Scan(&count); err != nil {
|
|
if err == sql.ErrNoRows {
|
|
err = nil
|
|
} else {
|
|
log.Errorv(c,
|
|
log.KV("log", "row.Scan"),
|
|
log.KV("err", err),
|
|
)
|
|
PromError("db:RawItemCoin")
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpdateCoinMemberCount for archive
|
|
func (dao *Dao) UpdateCoinMemberCount(c context.Context, mid, upMid, count int64) (err error) {
|
|
if _, err = dao.coin.Exec(c, fmt.Sprintf(_updateCoinMemberCount, dao.midHit(mid)), mid, upMid, count, time.Now(), count); err != nil {
|
|
log.Errorv(c,
|
|
log.KV("log", "updateCoinMemberCount"),
|
|
log.KV("mid", mid),
|
|
log.KV("upmid", upMid),
|
|
log.KV("count", count),
|
|
log.KV("err", err),
|
|
)
|
|
PromError("db:UpdateCoinMemberCount")
|
|
}
|
|
return
|
|
}
|
|
|
|
// BeginTran begin a tx.
|
|
func (dao *Dao) BeginTran(c context.Context) (t *sql.Tx, err error) {
|
|
t, err = dao.coin.Begin(c)
|
|
if err != nil {
|
|
PromError("db:BeginTran")
|
|
log.Errorv(c,
|
|
log.KV("log", "d.BeginTran"),
|
|
log.KV("err", err),
|
|
)
|
|
}
|
|
return
|
|
}
|
|
|
|
// UpdateItemCoins update table coin_archive
|
|
func (dao *Dao) UpdateItemCoins(c context.Context, aid, tp, coins int64, now time.Time) (affect int64, err error) {
|
|
if err != nil {
|
|
return
|
|
}
|
|
result, err := dao.coin.Exec(c, _updateArchiveCoinsBD, coins, now, aid, tp)
|
|
if err != nil {
|
|
log.Error("dao.coin.Exec(%s, %d, %s, %d) error(%v)", _updateArchiveCoinsBD, coins, now, aid, err)
|
|
return
|
|
}
|
|
affect, err = result.RowsAffected()
|
|
return
|
|
}
|