1301 lines
33 KiB
Go
1301 lines
33 KiB
Go
|
package dao
|
||
|
|
|
||
|
|
import (
|
||
|
|
"context"
|
||
|
|
"encoding/json"
|
||
|
|
"fmt"
|
||
|
|
|
||
|
|
"go-common/app/interface/main/esports/model"
|
||
|
|
arcmdl "go-common/app/service/main/archive/api"
|
||
|
|
"go-common/library/cache/redis"
|
||
|
|
"go-common/library/log"
|
||
|
|
)
|
||
|
|
|
||
|
|
const (
|
||
|
|
_keyCont = "c_%d"
|
||
|
|
_keyVideo = "v_%d"
|
||
|
|
_keyCale = "c_%s_%s"
|
||
|
|
_keyFMat = "fm"
|
||
|
|
_keyFVideo = "fv"
|
||
|
|
_keySeason = "se"
|
||
|
|
_keySeasonM = "sp"
|
||
|
|
_keyC = "co_%d"
|
||
|
|
_keyCF = "cf_%d"
|
||
|
|
_keyCAF = "caf_%d"
|
||
|
|
_keyS = "s_%d"
|
||
|
|
_keyAct = "act_%d"
|
||
|
|
_keyModule = "module_%d"
|
||
|
|
_keyTop = "top_%d_%d"
|
||
|
|
_keyPoint = "point_%d_%d_%d"
|
||
|
|
_keyKnock = "knock_%d"
|
||
|
|
_keyMAct = "ma_%d"
|
||
|
|
_keyTeam = "team_%d"
|
||
|
|
_keyCSData = "c_s_data_%d"
|
||
|
|
_keyCRecent = "c_recent_%d_%d_%d_%d"
|
||
|
|
)
|
||
|
|
|
||
|
|
func keyCale(stime, etime string) string {
|
||
|
|
return fmt.Sprintf(_keyCale, stime, etime)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyCont(ps int) string {
|
||
|
|
return fmt.Sprintf(_keyCont, ps)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyVideo(ps int) string {
|
||
|
|
return fmt.Sprintf(_keyVideo, ps)
|
||
|
|
}
|
||
|
|
func keyContID(cid int64) string {
|
||
|
|
return fmt.Sprintf(_keyC, cid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyCoFav(mid int64) string {
|
||
|
|
return fmt.Sprintf(_keyCF, mid)
|
||
|
|
}
|
||
|
|
func keyCoAppFav(mid int64) string {
|
||
|
|
return fmt.Sprintf(_keyCAF, mid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keySID(sid int64) string {
|
||
|
|
return fmt.Sprintf(_keyS, sid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyTeamID(tid int64) string {
|
||
|
|
return fmt.Sprintf(_keyTeam, tid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyMatchAct(aid int64) string {
|
||
|
|
return fmt.Sprintf(_keyAct, aid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyCSData(cid int64) string {
|
||
|
|
return fmt.Sprintf(_keyCSData, cid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyCRecent(param *model.ParamCDRecent) string {
|
||
|
|
key := fmt.Sprintf(_keyCRecent, param.CID, param.HomeID, param.AwayID, param.Ps)
|
||
|
|
return key
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyMatchModule(mmid int64) string {
|
||
|
|
return fmt.Sprintf(_keyModule, mmid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyKnock(mdID int64) string {
|
||
|
|
return fmt.Sprintf(_keyKnock, mdID)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyTop(aid, ps int64) string {
|
||
|
|
return fmt.Sprintf(_keyTop, aid, ps)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyPoint(aid, mdID, ps int64) string {
|
||
|
|
return fmt.Sprintf(_keyPoint, aid, mdID, ps)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyMAct(aid int64) string {
|
||
|
|
return fmt.Sprintf(_keyMAct, aid)
|
||
|
|
}
|
||
|
|
|
||
|
|
// FMatCache get filter match from cache.
|
||
|
|
func (d *Dao) FMatCache(c context.Context) (res map[string][]*model.Filter, err error) {
|
||
|
|
res, err = d.filterCache(c, _keyFMat)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// FVideoCache get filter video from cache.
|
||
|
|
func (d *Dao) FVideoCache(c context.Context) (res map[string][]*model.Filter, err error) {
|
||
|
|
res, err = d.filterCache(c, _keyFVideo)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *Dao) filterCache(c context.Context, key string) (rs map[string][]*model.Filter, err error) {
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
var values []byte
|
||
|
|
if values, err = redis.Bytes(conn.Do("GET", key)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
log.Error("filterCache (%s) return nil ", key)
|
||
|
|
} else {
|
||
|
|
log.Error("conn.Do(GET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
rs = make(map[string][]*model.Filter)
|
||
|
|
if err = json.Unmarshal(values, &rs); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%v) error(%v)", values, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetFMatCache set filter match to cache.
|
||
|
|
func (d *Dao) SetFMatCache(c context.Context, fs map[string][]*model.Filter) (err error) {
|
||
|
|
err = d.setFilterCache(c, _keyFMat, fs)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetFVideoCache set filter match to cache.
|
||
|
|
func (d *Dao) SetFVideoCache(c context.Context, fs map[string][]*model.Filter) (err error) {
|
||
|
|
err = d.setFilterCache(c, _keyFVideo, fs)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *Dao) setFilterCache(c context.Context, key string, fs map[string][]*model.Filter) (err error) {
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
var bs []byte
|
||
|
|
if bs, err = json.Marshal(fs); err != nil {
|
||
|
|
log.Error("json.Marshal(%v) error(%v)", fs, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("SET", key, bs); err != nil {
|
||
|
|
log.Error("conn.Send(SET,%s,%s) error(%v)", key, string(bs), err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.filterExpire); err != nil {
|
||
|
|
log.Error("conn.Send(EXPIRE,%s,%d) error(%v)", key, d.filterExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 2; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Recevie(%d) error(%v0", i, err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// ContestCache get all contest from cache.
|
||
|
|
func (d *Dao) ContestCache(c context.Context, ps int) (res []*model.Contest, total int, err error) {
|
||
|
|
key := keyCont(ps)
|
||
|
|
res, total, err = d.cosCache(c, key)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// FavCoCache get fav contest from cache.
|
||
|
|
func (d *Dao) FavCoCache(c context.Context, mid int64) (res []*model.Contest, total int, err error) {
|
||
|
|
key := keyCoFav(mid)
|
||
|
|
res, total, err = d.cosCache(c, key)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// FavCoAppCache get fav contest from cache.
|
||
|
|
func (d *Dao) FavCoAppCache(c context.Context, mid int64) (res []*model.Contest, total int, err error) {
|
||
|
|
key := keyCoAppFav(mid)
|
||
|
|
res, total, err = d.cosCache(c, key)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *Dao) cosCache(c context.Context, key string) (res []*model.Contest, total int, err error) {
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
values, err := redis.Values(conn.Do("ZRANGE", key, 0, -1, "WITHSCORES"))
|
||
|
|
if err != nil {
|
||
|
|
log.Error("conn.Do(ZRANGE, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if len(values) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var num int64
|
||
|
|
for len(values) > 0 {
|
||
|
|
bs := []byte{}
|
||
|
|
if values, err = redis.Scan(values, &bs, &num); err != nil {
|
||
|
|
log.Error("redis.Scan(%v) error(%v)", values, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
cont := &model.Contest{}
|
||
|
|
if err = json.Unmarshal(bs, cont); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%v) error(%v)", bs, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = append(res, cont)
|
||
|
|
}
|
||
|
|
total = from(num)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetContestCache set all contest to cache.
|
||
|
|
func (d *Dao) SetContestCache(c context.Context, ps int, contests []*model.Contest, total int) (err error) {
|
||
|
|
key := keyCont(ps)
|
||
|
|
err = d.setCosCache(c, key, contests, total)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetFavCoCache set fav contest to cache.
|
||
|
|
func (d *Dao) SetFavCoCache(c context.Context, mid int64, contests []*model.Contest, total int) (err error) {
|
||
|
|
key := keyCoFav(mid)
|
||
|
|
err = d.setCosCache(c, key, contests, total)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetAppFavCoCache set fav contest to cache.
|
||
|
|
func (d *Dao) SetAppFavCoCache(c context.Context, mid int64, contests []*model.Contest, total int) (err error) {
|
||
|
|
key := keyCoAppFav(mid)
|
||
|
|
err = d.setCosCache(c, key, contests, total)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// DelFavCoCache delete fav contests cache.
|
||
|
|
func (d *Dao) DelFavCoCache(c context.Context, mid int64) (err error) {
|
||
|
|
key := keyCoFav(mid)
|
||
|
|
keyApp := keyCoAppFav(mid)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("conn.Send(DEL plaKey(%s) error(%v))", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("DEL", keyApp); err != nil {
|
||
|
|
log.Error("conn.Send(DEL pladKey(%s) error(%v))", keyApp, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("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
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *Dao) setCosCache(c context.Context, key string, contests []*model.Contest, total int) (err error) {
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
count := 0
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("conn.Send(DEL, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
args := redis.Args{}.Add(key)
|
||
|
|
for sort, contest := range contests {
|
||
|
|
bs, _ := json.Marshal(contest)
|
||
|
|
args = args.Add(combine(int64(sort), total)).Add(bs)
|
||
|
|
}
|
||
|
|
if err = conn.Send("ZADD", args...); err != nil {
|
||
|
|
log.Error("conn.Send(ZADD, %s, %v) error(%v)", key, args, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Send("EXPIRE", key, d.filterExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key, d.filterExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// CalendarCache get all calendar from cache.
|
||
|
|
func (d *Dao) CalendarCache(c context.Context, p *model.ParamFilter) (res []*model.Calendar, err error) {
|
||
|
|
var (
|
||
|
|
key = keyCale(p.Stime, p.Etime)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
values, err := redis.Values(conn.Do("ZRANGE", key, 0, -1, "WITHSCORES"))
|
||
|
|
if err != nil {
|
||
|
|
log.Error("conn.Do(ZRANGE, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if len(values) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var num int64
|
||
|
|
for len(values) > 0 {
|
||
|
|
bs := []byte{}
|
||
|
|
if values, err = redis.Scan(values, &bs, &num); err != nil {
|
||
|
|
log.Error("redis.Scan(%v) error(%v)", values, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
cale := &model.Calendar{}
|
||
|
|
if err = json.Unmarshal(bs, cale); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%v) error(%v)", bs, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = append(res, cale)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetCalendarCache set all calendar to cache.
|
||
|
|
func (d *Dao) SetCalendarCache(c context.Context, p *model.ParamFilter, cales []*model.Calendar) (err error) {
|
||
|
|
var (
|
||
|
|
key = keyCale(p.Stime, p.Etime)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
count := 0
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("conn.Send(DEL, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
args := redis.Args{}.Add(key)
|
||
|
|
for sort, cale := range cales {
|
||
|
|
bs, _ := json.Marshal(cale)
|
||
|
|
args = args.Add(sort).Add(bs)
|
||
|
|
}
|
||
|
|
if err = conn.Send("ZADD", args...); err != nil {
|
||
|
|
log.Error("conn.Send(ZADD, %s, %v) error(%v)", key, args, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Send("EXPIRE", key, d.filterExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key, d.filterExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// VideoCache get all video from cache.
|
||
|
|
func (d *Dao) VideoCache(c context.Context, ps int) (res []*arcmdl.Arc, total int, err error) {
|
||
|
|
var (
|
||
|
|
key = keyVideo(ps)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
values, err := redis.Values(conn.Do("ZRANGE", key, 0, -1, "WITHSCORES"))
|
||
|
|
if err != nil {
|
||
|
|
log.Error("conn.Do(ZRANGE, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if len(values) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var num int64
|
||
|
|
for len(values) > 0 {
|
||
|
|
bs := []byte{}
|
||
|
|
if values, err = redis.Scan(values, &bs, &num); err != nil {
|
||
|
|
log.Error("redis.Scan(%v) error(%v)", values, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
cont := &arcmdl.Arc{}
|
||
|
|
if err = json.Unmarshal(bs, cont); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%v) error(%v)", bs, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = append(res, cont)
|
||
|
|
}
|
||
|
|
total = from(num)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetVideoCache set all contest to cache.
|
||
|
|
func (d *Dao) SetVideoCache(c context.Context, ps int, videos []*arcmdl.Arc, total int) (err error) {
|
||
|
|
var (
|
||
|
|
key = keyVideo(ps)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
count := 0
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("conn.Send(DEL, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
args := redis.Args{}.Add(key)
|
||
|
|
for sort, video := range videos {
|
||
|
|
bs, _ := json.Marshal(video)
|
||
|
|
args = args.Add(combine(int64(sort), total)).Add(bs)
|
||
|
|
}
|
||
|
|
if err = conn.Send("ZADD", args...); err != nil {
|
||
|
|
log.Error("conn.Send(ZADD, %s, %v) error(%v)", key, args, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Send("EXPIRE", key, d.filterExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key, d.filterExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
func (d *Dao) seasonsCache(c context.Context, key string, start, end int) (res []*model.Season, total int, err error) {
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
values, err := redis.Values(conn.Do("ZRANGE", key, start, end, "WITHSCORES"))
|
||
|
|
if err != nil {
|
||
|
|
log.Error("conn.Do(ZRANGE, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if len(values) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var num int64
|
||
|
|
for len(values) > 0 {
|
||
|
|
bs := []byte{}
|
||
|
|
if values, err = redis.Scan(values, &bs, &num); err != nil {
|
||
|
|
log.Error("redis.Scan(%v) error(%v)", values, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
object := &model.Season{}
|
||
|
|
if err = json.Unmarshal(bs, object); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%v) error(%v)", bs, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = append(res, object)
|
||
|
|
}
|
||
|
|
total = from(num)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *Dao) setSeasonsCache(c context.Context, key string, seasons []*model.Season, total int) (err error) {
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
count := 0
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("conn.Send(DEL, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
for sort, season := range seasons {
|
||
|
|
bs, _ := json.Marshal(season)
|
||
|
|
if err = conn.Send("ZADD", key, combine(int64(sort), total), bs); err != nil {
|
||
|
|
log.Error("conn.Send(ZADD, %s, %s) error(%v)", key, string(bs), err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key, d.listExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SeasonCache get season list from cache.
|
||
|
|
func (d *Dao) SeasonCache(c context.Context, start, end int) (res []*model.Season, total int, err error) {
|
||
|
|
res, total, err = d.seasonsCache(c, _keySeason, start, end)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetSeasonCache set season list cache.
|
||
|
|
func (d *Dao) SetSeasonCache(c context.Context, seasons []*model.Season, total int) (err error) {
|
||
|
|
err = d.setSeasonsCache(c, _keySeason, seasons, total)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SeasonMCache get season list from cache.
|
||
|
|
func (d *Dao) SeasonMCache(c context.Context, start, end int) (res []*model.Season, total int, err error) {
|
||
|
|
res, total, err = d.seasonsCache(c, _keySeasonM, start, end)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetSeasonMCache set season list cache.
|
||
|
|
func (d *Dao) SetSeasonMCache(c context.Context, seasons []*model.Season, total int) (err error) {
|
||
|
|
err = d.setSeasonsCache(c, _keySeasonM, seasons, total)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func from(i int64) int {
|
||
|
|
return int(i & 0xffff)
|
||
|
|
}
|
||
|
|
|
||
|
|
func combine(sort int64, count int) int64 {
|
||
|
|
return sort<<16 | int64(count)
|
||
|
|
}
|
||
|
|
|
||
|
|
// CacheEpContests .
|
||
|
|
func (d *Dao) CacheEpContests(c context.Context, ids []int64) (res map[int64]*model.Contest, err error) {
|
||
|
|
var (
|
||
|
|
key string
|
||
|
|
args = redis.Args{}
|
||
|
|
bss [][]byte
|
||
|
|
)
|
||
|
|
for _, cid := range ids {
|
||
|
|
key = keyContID(cid)
|
||
|
|
args = args.Add(key)
|
||
|
|
}
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
if bss, err = redis.ByteSlices(conn.Do("MGET", args...)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
} else {
|
||
|
|
log.Error("CacheEpContests conn.Do(MGET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = make(map[int64]*model.Contest, len(ids))
|
||
|
|
for _, bs := range bss {
|
||
|
|
con := new(model.Contest)
|
||
|
|
if bs == nil {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if err = json.Unmarshal(bs, con); err != nil {
|
||
|
|
log.Error("CacheEpContests json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
err = nil
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
res[con.ID] = con
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddCacheEpContests .
|
||
|
|
func (d *Dao) AddCacheEpContests(c context.Context, data map[int64]*model.Contest) (err error) {
|
||
|
|
if len(data) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
keyID string
|
||
|
|
keyIDs []string
|
||
|
|
argsCid = redis.Args{}
|
||
|
|
)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
for _, v := range data {
|
||
|
|
if bs, err = json.Marshal(v); err != nil {
|
||
|
|
log.Error("json.Marshal err(%v)", err)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
keyID = keyContID(v.ID)
|
||
|
|
keyIDs = append(keyIDs, keyID)
|
||
|
|
argsCid = argsCid.Add(keyID).Add(string(bs))
|
||
|
|
}
|
||
|
|
if err = conn.Send("MSET", argsCid...); err != nil {
|
||
|
|
log.Error("AddCacheMatchSubjects conn.Send(MSET) error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count := 1
|
||
|
|
for _, v := range keyIDs {
|
||
|
|
count++
|
||
|
|
if err = conn.Send("EXPIRE", v, d.listExpire); err != nil {
|
||
|
|
log.Error("AddCacheMatchSubjects conn.Send(Expire, %s, %d) error(%v)", v, d.listExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// CacheEpSeasons .
|
||
|
|
func (d *Dao) CacheEpSeasons(c context.Context, ids []int64) (res map[int64]*model.Season, err error) {
|
||
|
|
var (
|
||
|
|
key string
|
||
|
|
args = redis.Args{}
|
||
|
|
bss [][]byte
|
||
|
|
)
|
||
|
|
for _, sid := range ids {
|
||
|
|
key = keySID(sid)
|
||
|
|
args = args.Add(key)
|
||
|
|
}
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
if bss, err = redis.ByteSlices(conn.Do("MGET", args...)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
} else {
|
||
|
|
log.Error("CacheEpSeasons conn.Do(MGET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = make(map[int64]*model.Season, len(ids))
|
||
|
|
for _, bs := range bss {
|
||
|
|
sea := new(model.Season)
|
||
|
|
if bs == nil {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if err = json.Unmarshal(bs, sea); err != nil {
|
||
|
|
log.Error("CacheEpSeasons json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
err = nil
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
res[sea.ID] = sea
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// CacheEpTeams .
|
||
|
|
func (d *Dao) CacheEpTeams(c context.Context, ids []int64) (res map[int64]*model.Team, err error) {
|
||
|
|
var (
|
||
|
|
key string
|
||
|
|
args = redis.Args{}
|
||
|
|
bss [][]byte
|
||
|
|
)
|
||
|
|
for _, tid := range ids {
|
||
|
|
key = keyTeamID(tid)
|
||
|
|
args = args.Add(key)
|
||
|
|
}
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
if bss, err = redis.ByteSlices(conn.Do("MGET", args...)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
} else {
|
||
|
|
log.Error("CacheEpTeams conn.Do(MGET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = make(map[int64]*model.Team, len(ids))
|
||
|
|
for _, bs := range bss {
|
||
|
|
team := new(model.Team)
|
||
|
|
if bs == nil {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if err = json.Unmarshal(bs, team); err != nil {
|
||
|
|
log.Error("CacheEpTeams json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
err = nil
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
res[team.ID] = team
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddCacheEpTeams .
|
||
|
|
func (d *Dao) AddCacheEpTeams(c context.Context, data map[int64]*model.Team) (err error) {
|
||
|
|
if len(data) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
keyID string
|
||
|
|
keyIDs []string
|
||
|
|
argsCid = redis.Args{}
|
||
|
|
)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
for _, v := range data {
|
||
|
|
if bs, err = json.Marshal(v); err != nil {
|
||
|
|
log.Error("AddCacheEpTeams.json.Marshal err(%v)", err)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
keyID = keyTeamID(v.ID)
|
||
|
|
keyIDs = append(keyIDs, keyID)
|
||
|
|
argsCid = argsCid.Add(keyID).Add(string(bs))
|
||
|
|
}
|
||
|
|
if err = conn.Send("MSET", argsCid...); err != nil {
|
||
|
|
log.Error("AddCacheEpTeams conn.Send(MSET) error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count := 1
|
||
|
|
for _, v := range keyIDs {
|
||
|
|
count++
|
||
|
|
if err = conn.Send("EXPIRE", v, d.listExpire); err != nil {
|
||
|
|
log.Error("AddCacheEpTeams conn.Send(Expire, %s, %d) error(%v)", v, d.listExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddCacheEpSeasons .
|
||
|
|
func (d *Dao) AddCacheEpSeasons(c context.Context, data map[int64]*model.Season) (err error) {
|
||
|
|
if len(data) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
keyID string
|
||
|
|
keyIDs []string
|
||
|
|
argsCid = redis.Args{}
|
||
|
|
)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
for _, v := range data {
|
||
|
|
if bs, err = json.Marshal(v); err != nil {
|
||
|
|
log.Error("json.Marshal err(%v)", err)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
keyID = keySID(v.ID)
|
||
|
|
keyIDs = append(keyIDs, keyID)
|
||
|
|
argsCid = argsCid.Add(keyID).Add(string(bs))
|
||
|
|
}
|
||
|
|
if err = conn.Send("MSET", argsCid...); err != nil {
|
||
|
|
log.Error("AddCacheEpSeasons conn.Send(MSET) error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count := 1
|
||
|
|
for _, v := range keyIDs {
|
||
|
|
count++
|
||
|
|
if err = conn.Send("EXPIRE", v, d.listExpire); err != nil {
|
||
|
|
log.Error("AddCacheEpSeasons conn.Send(Expire, %s, %d) error(%v)", v, d.listExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetActPageCache get act from cache.
|
||
|
|
func (d *Dao) GetActPageCache(c context.Context, id int64) (act *model.ActivePage, err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyMatchAct(id)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = redis.Bytes(conn.Do("GET", key)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
act = nil
|
||
|
|
} else {
|
||
|
|
log.Error("conn.Do(GET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
act = new(model.ActivePage)
|
||
|
|
if err = json.Unmarshal(bs, act); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetCSingleData get contest single data
|
||
|
|
func (d *Dao) GetCSingleData(c context.Context, id int64) (data *model.ContestDataPage, err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyCSData(id)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = redis.Bytes(conn.Do("GET", key)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
data = nil
|
||
|
|
} else {
|
||
|
|
log.Error("GetCSingleData conn.Do(GET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
data = new(model.ContestDataPage)
|
||
|
|
if err = json.Unmarshal(bs, data); err != nil {
|
||
|
|
log.Error("GetCSingleData json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddCSingleData add act first page value
|
||
|
|
func (d *Dao) AddCSingleData(c context.Context, id int64, act *model.ContestDataPage) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyCSData(id)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = json.Marshal(act); err != nil {
|
||
|
|
log.Error("AddCSingleData json.Marshal() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("SET", key, bs); err != nil {
|
||
|
|
log.Error("AddCSingleData conn.Send(SET,%s,%d) error(%v)", key, id, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("AddCSingleData conn.Send(EXPIRE,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("add conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 2; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("add conn.Receive()%d error(%v)", i+1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetCRecent get contest recent data
|
||
|
|
func (d *Dao) GetCRecent(c context.Context, param *model.ParamCDRecent) (data []*model.Contest, err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyCRecent(param)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = redis.Bytes(conn.Do("GET", key)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
data = nil
|
||
|
|
} else {
|
||
|
|
log.Error("GetCRecent conn.Do(GET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
data = make([]*model.Contest, 0)
|
||
|
|
if err = json.Unmarshal(bs, &data); err != nil {
|
||
|
|
log.Error("GetCRecent json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddCRecent add contest recent data
|
||
|
|
func (d *Dao) AddCRecent(c context.Context, param *model.ParamCDRecent, data []*model.Contest) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyCRecent(param)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = json.Marshal(data); err != nil {
|
||
|
|
log.Error("AddCRecent json.Marshal() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("SET", key, bs); err != nil {
|
||
|
|
log.Error("AddCRecent conn.Send(SET,%s,%v) error(%v)", key, param, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("AddCRecent conn.Send(EXPIRE,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("AddCRecent conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 2; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("AddCRecent conn.Receive()%d error(%v)", i+1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddActPageCache add act first page value
|
||
|
|
func (d *Dao) AddActPageCache(c context.Context, aid int64, act *model.ActivePage) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyMatchAct(aid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = json.Marshal(act); err != nil {
|
||
|
|
log.Error("json.Marshal() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("SET", key, bs); err != nil {
|
||
|
|
log.Error("conn.Send(SET,%s,%d) error(%v)", key, aid, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("conn.Send(EXPIRE,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("add conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 2; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("add conn.Receive()%d error(%v)", i+1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetActModuleCache get module from cache.
|
||
|
|
func (d *Dao) GetActModuleCache(c context.Context, mmid int64) (res []*arcmdl.Arc, err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyMatchModule(mmid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = redis.Bytes(conn.Do("GET", key)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
res = nil
|
||
|
|
} else {
|
||
|
|
log.Error("GetModuleCache conn.Do(GET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = json.Unmarshal(bs, &res); err != nil {
|
||
|
|
log.Error("GetModuleCache json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddActModuleCache add act first page cache
|
||
|
|
func (d *Dao) AddActModuleCache(c context.Context, mmid int64, module []*arcmdl.Arc) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyMatchModule(mmid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = json.Marshal(module); err != nil {
|
||
|
|
log.Error("AddActModuleCache json.Marshal() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("SET", key, bs); err != nil {
|
||
|
|
log.Error("AddActModuleCache conn.Send(SET,%s,%d) error(%v)", key, mmid, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("AddActModuleCache conn.Send(EXPIRE,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("AddActModuleCache add conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 2; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("AddActModuleCache add conn.Receive()%d error(%v)", i+1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetActTopCache get act top value cache
|
||
|
|
func (d *Dao) GetActTopCache(c context.Context, aid, ps int64) (res []*model.Contest, total int, err error) {
|
||
|
|
key := keyTop(aid, ps)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
values, err := redis.Values(conn.Do("ZRANGE", key, 0, -1, "WITHSCORES"))
|
||
|
|
if err != nil {
|
||
|
|
log.Error("GetActTopCache conn.Do(ZRANGE, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if len(values) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var num int64
|
||
|
|
for len(values) > 0 {
|
||
|
|
bs := []byte{}
|
||
|
|
if values, err = redis.Scan(values, &bs, &num); err != nil {
|
||
|
|
log.Error("redis.Scan(%v) error(%v)", values, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
cont := &model.Contest{}
|
||
|
|
if err = json.Unmarshal(bs, cont); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%v) error(%v)", bs, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = append(res, cont)
|
||
|
|
}
|
||
|
|
total = from(num)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddActTopCache add act top cache
|
||
|
|
func (d *Dao) AddActTopCache(c context.Context, aid, ps int64, tops []*model.Contest, total int) (err error) {
|
||
|
|
key := keyTop(aid, ps)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
count := 0
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Send(DEL, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
args := redis.Args{}.Add(key)
|
||
|
|
for sort, contest := range tops {
|
||
|
|
bs, _ := json.Marshal(contest)
|
||
|
|
args = args.Add(combine(int64(sort), total)).Add(bs)
|
||
|
|
}
|
||
|
|
if err = conn.Send("ZADD", args...); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Send(ZADD, %s, %v) error(%v)", key, args, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Send(Expire, %s, %d) error(%v)", key, d.listExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetActPointsCache get act point value
|
||
|
|
func (d *Dao) GetActPointsCache(c context.Context, aid, mdID, ps int64) (res []*model.Contest, total int, err error) {
|
||
|
|
key := keyPoint(aid, mdID, ps)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
values, err := redis.Values(conn.Do("ZRANGE", key, 0, -1, "WITHSCORES"))
|
||
|
|
if err != nil {
|
||
|
|
log.Error("GetActTopCache conn.Do(ZRANGE, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if len(values) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
var num int64
|
||
|
|
for len(values) > 0 {
|
||
|
|
bs := []byte{}
|
||
|
|
if values, err = redis.Scan(values, &bs, &num); err != nil {
|
||
|
|
log.Error("redis.Scan(%v) error(%v)", values, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
cont := &model.Contest{}
|
||
|
|
if err = json.Unmarshal(bs, cont); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%v) error(%v)", bs, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
res = append(res, cont)
|
||
|
|
}
|
||
|
|
total = from(num)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddActPointsCache add act point data cache
|
||
|
|
func (d *Dao) AddActPointsCache(c context.Context, aid, mdID, ps int64, points []*model.Contest, total int) (err error) {
|
||
|
|
key := keyPoint(aid, mdID, ps)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
count := 0
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Send(DEL, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
args := redis.Args{}.Add(key)
|
||
|
|
for sort, contest := range points {
|
||
|
|
bs, _ := json.Marshal(contest)
|
||
|
|
args = args.Add(combine(int64(sort), total)).Add(bs)
|
||
|
|
}
|
||
|
|
if err = conn.Send("ZADD", args...); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Send(ZADD, %s, %v) error(%v)", key, args, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Send(Expire, %s, %d) error(%v)", key, d.listExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
count++
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("AddActTopCache conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetActKnockoutCache add act knockout cache value
|
||
|
|
func (d *Dao) GetActKnockoutCache(c context.Context, mdID int64) (res [][]*model.TreeList, err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyKnock(mdID)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = redis.Bytes(conn.Do("GET", key)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
res = nil
|
||
|
|
} else {
|
||
|
|
log.Error("GetActKnockoutCache conn.Do(GET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = json.Unmarshal(bs, &res); err != nil {
|
||
|
|
log.Error("GetActKnockoutCache json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddActKnockoutCache add act knockout cache value
|
||
|
|
func (d *Dao) AddActKnockoutCache(c context.Context, mdID int64, knock [][]*model.TreeList) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyKnock(mdID)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = json.Marshal(knock); err != nil {
|
||
|
|
log.Error("AddActKnockoutCache json.Marshal() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("SET", key, bs); err != nil {
|
||
|
|
log.Error("AddActKnockoutCache conn.Send(SET,%s,%d) error(%v)", key, mdID, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("AddActKnockoutCache conn.Send(EXPIRE,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("AddActKnockoutCache add conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 2; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("AddActModuleCache add conn.Receive()%d error(%v)", i+1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddActKnockCacheTime add act knockout cache value time
|
||
|
|
func (d *Dao) AddActKnockCacheTime(c context.Context, mdID int64) (err error) {
|
||
|
|
var (
|
||
|
|
key = keyKnock(mdID)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("AddActKnockCacheTime conn.Send(EXPIRE,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("AddActKnockCacheTime add conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("AddActKnockCacheTime add error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetMActCache get act cache value
|
||
|
|
func (d *Dao) GetMActCache(c context.Context, aid int64) (res *model.Active, err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyMAct(aid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = redis.Bytes(conn.Do("GET", key)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
res = nil
|
||
|
|
} else {
|
||
|
|
log.Error("GetMActCache conn.Do(GET,%s) error(%v)", key, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = json.Unmarshal(bs, &res); err != nil {
|
||
|
|
log.Error("GetMActCache json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddMActCache add act cache value
|
||
|
|
func (d *Dao) AddMActCache(c context.Context, aid int64, act *model.Active) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyMAct(aid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = json.Marshal(act); err != nil {
|
||
|
|
log.Error("AddMActCache json.Marshal() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("SET", key, bs); err != nil {
|
||
|
|
log.Error("AddMActCache conn.Send(SET,%s,%d) error(%v)", key, aid, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.listExpire); err != nil {
|
||
|
|
log.Error("AddMActCache conn.Send(EXPIRE,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("AddMActCache add conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 2; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("AddMActCache add conn.Receive()%d error(%v)", i+1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|