431 lines
11 KiB
Go
431 lines
11 KiB
Go
|
package dao
|
||
|
|
|
||
|
|
import (
|
||
|
|
"context"
|
||
|
|
"encoding/json"
|
||
|
|
"fmt"
|
||
|
|
|
||
|
|
"go-common/app/interface/main/space/model"
|
||
|
|
"go-common/library/cache/redis"
|
||
|
|
"go-common/library/log"
|
||
|
|
)
|
||
|
|
|
||
|
|
const (
|
||
|
|
_keyCl = "cl_%d"
|
||
|
|
_keyClArc = "cla_%d_%d"
|
||
|
|
)
|
||
|
|
|
||
|
|
func keyCl(mid int64) string {
|
||
|
|
return fmt.Sprintf(_keyCl, mid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyClArc(mid, cid int64) string {
|
||
|
|
return fmt.Sprintf(_keyClArc, mid, cid)
|
||
|
|
}
|
||
|
|
|
||
|
|
func keyClArcSort(mid, cid int64) string {
|
||
|
|
return keyClArc(mid, cid) + "_s"
|
||
|
|
}
|
||
|
|
|
||
|
|
// ChannelCache get channel cache.
|
||
|
|
func (d *Dao) ChannelCache(c context.Context, mid, cid int64) (channel *model.Channel, err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyCl(mid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = redis.Bytes(conn.Do("HGET", key, cid)); err != nil {
|
||
|
|
if err == redis.ErrNil {
|
||
|
|
err = nil
|
||
|
|
channel = nil
|
||
|
|
} else {
|
||
|
|
log.Error("conn.Do(HGET,%s,%d) error(%v)", key, cid, err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
channel = new(model.Channel)
|
||
|
|
if err = json.Unmarshal(bs, channel); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%s) error(%v)", string(bs), err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetChannelCache add channel data cache.
|
||
|
|
func (d *Dao) SetChannelCache(c context.Context, mid, cid int64, channel *model.Channel) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
ok bool
|
||
|
|
key = keyCl(mid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bs, err = json.Marshal(channel); err != nil {
|
||
|
|
log.Error("json.Marshal() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if ok, err = redis.Bool(conn.Do("EXPIRE", key, d.clExpire)); err != nil || !ok {
|
||
|
|
log.Error("conn.Do(EXPIRE %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("HSET", key, cid, bs); err != nil {
|
||
|
|
log.Error("conn.Send(HSET,%s,%d) error(%v)", key, cid, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.clExpire); 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
|
||
|
|
}
|
||
|
|
|
||
|
|
// DelChannelCache delete channel cache from list.
|
||
|
|
func (d *Dao) DelChannelCache(c context.Context, mid, cid int64) (err error) {
|
||
|
|
var (
|
||
|
|
key = keyCl(mid)
|
||
|
|
arcsKey = keyClArc(mid, cid)
|
||
|
|
sortKey = keyClArcSort(mid, cid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if err = conn.Send("HDEL", key, cid); err != nil {
|
||
|
|
log.Error("conn.Send(HDEL,%s,%d) error(%v)", key, cid, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("DEL", arcsKey); err != nil {
|
||
|
|
log.Error("conn.Send(DEL,%s) error(%v)", arcsKey, err)
|
||
|
|
}
|
||
|
|
if err = conn.Send("DEL", sortKey); err != nil {
|
||
|
|
log.Error("conn.Send(DEL,%s) error(%v)", sortKey, err)
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("add conn.Receive()%d error(%v)", i+1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetChannelListCache add channel data cache.
|
||
|
|
func (d *Dao) SetChannelListCache(c context.Context, mid int64, channelList []*model.Channel) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key = keyCl(mid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("conn.Send(DEL, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
args := redis.Args{}.Add(key)
|
||
|
|
for _, channel := range channelList {
|
||
|
|
if bs, err = json.Marshal(channel); err != nil {
|
||
|
|
log.Error("json.Marshal() error(%v)", err)
|
||
|
|
continue
|
||
|
|
} else {
|
||
|
|
args = args.Add(channel.Cid).Add(string(bs))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err = conn.Send("HMSET", args...); err != nil {
|
||
|
|
log.Error("conn.Send(HMSET, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.clExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key, d.clExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// ChannelListCache get channel list cache.
|
||
|
|
func (d *Dao) ChannelListCache(c context.Context, mid int64) (channels []*model.Channel, err error) {
|
||
|
|
var (
|
||
|
|
bss [][]byte
|
||
|
|
key = keyCl(mid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if bss, err = redis.ByteSlices(conn.Do("HGETALL", key)); err != nil {
|
||
|
|
log.Error("conn.Do(HGETALL,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 1; i <= len(bss); i += 2 {
|
||
|
|
channel := new(model.Channel)
|
||
|
|
if err = json.Unmarshal(bss[i], channel); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%s) error(%v)", string(bss[i]), err)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
channels = append(channels, channel)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// ChannelArcsCache get channel archives cache.
|
||
|
|
func (d *Dao) ChannelArcsCache(c context.Context, mid, cid int64, start, end int, order bool) (arcs []*model.ChannelArc, err error) {
|
||
|
|
var (
|
||
|
|
bss [][]byte
|
||
|
|
values []interface{}
|
||
|
|
key = keyClArc(mid, cid)
|
||
|
|
sortKey = keyClArcSort(mid, cid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
cmd = "ZREVRANGE"
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if order {
|
||
|
|
cmd = "ZRANGE"
|
||
|
|
}
|
||
|
|
if values, err = redis.Values(conn.Do(cmd, sortKey, start, end, "WITHSCORES")); err != nil {
|
||
|
|
log.Error("conn.Do(ZREVRANGE, %s) error(%v)", sortKey, err)
|
||
|
|
return
|
||
|
|
} else if len(values) == 0 {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
arg := redis.Args{}.Add(key)
|
||
|
|
for len(values) > 0 {
|
||
|
|
arcSort := new(model.ChannelArcSort)
|
||
|
|
if values, err = redis.Scan(values, &arcSort.Aid, &arcSort.OrderNum); err != nil {
|
||
|
|
log.Error("redis.Scan(%v) error(%v)", values, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if arcSort.Aid > 0 {
|
||
|
|
arg = arg.Add(arcSort.Aid)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if bss, err = redis.ByteSlices(conn.Do("HMGET", arg...)); err != nil {
|
||
|
|
log.Error("conn.Do(HMGET,%s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for _, bs := range bss {
|
||
|
|
if len(bs) == 0 {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if len(bs) > 0 {
|
||
|
|
arc := new(model.ChannelArc)
|
||
|
|
if err = json.Unmarshal(bs, arc); err != nil {
|
||
|
|
log.Error("json.Unmarshal(%s) mid(%d) cid(%d) error(%v)", string(bs), mid, cid, err)
|
||
|
|
err = nil
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
arcs = append(arcs, arc)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// AddChannelArcCache add channel archives cache.
|
||
|
|
func (d *Dao) AddChannelArcCache(c context.Context, mid, cid int64, arcs []*model.ChannelArc) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
ok bool
|
||
|
|
key = keyClArc(mid, cid)
|
||
|
|
sortKey = keyClArcSort(mid, cid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if ok, err = redis.Bool(conn.Do("EXPIRE", key, d.clExpire)); err != nil && ok {
|
||
|
|
log.Error("conn.Do(EXPIRE %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if ok, err = redis.Bool(conn.Do("EXPIRE", sortKey, d.clExpire)); err != nil && ok {
|
||
|
|
log.Error("conn.Do(EXPIRE %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
args1 := redis.Args{}.Add(key)
|
||
|
|
args2 := redis.Args{}.Add(sortKey)
|
||
|
|
for _, arc := range arcs {
|
||
|
|
if bs, err = json.Marshal(arc); err != nil {
|
||
|
|
log.Error("json.Marshal() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
args1 = args1.Add(arc.Aid).Add(string(bs))
|
||
|
|
args2 = args2.Add(arc.OrderNum).Add(arc.Aid)
|
||
|
|
}
|
||
|
|
if err = conn.Send("HMSET", args1...); err != nil {
|
||
|
|
log.Error("conn.Send(HMSET, %s, %v) error(%v)", key, args1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.clExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s) error(%v)", key, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("ZADD", args2...); err != nil {
|
||
|
|
log.Error("conn.Send(ZADD, %s, %v) error(%v)", sortKey, args2, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", sortKey, d.clExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s) error(%v)", sortKey, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 4; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetChannelArcSortCache set channel archives sort cache
|
||
|
|
func (d *Dao) SetChannelArcSortCache(c context.Context, mid, cid int64, sort []*model.ChannelArcSort) (err error) {
|
||
|
|
var (
|
||
|
|
key = keyClArc(mid, cid)
|
||
|
|
sortKey = keyClArcSort(mid, cid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if err = conn.Send("DEL", sortKey); err != nil {
|
||
|
|
log.Error("conn.Send(DEL, %s) error(%v)", sortKey, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
args := redis.Args{}.Add(sortKey)
|
||
|
|
for _, v := range sort {
|
||
|
|
args = args.Add(v.OrderNum).Add(v.Aid)
|
||
|
|
}
|
||
|
|
if err = conn.Send("ZADD", args...); err != nil {
|
||
|
|
log.Error("conn.Send(ZADD, %s) error(%v)", sortKey, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", sortKey, d.clExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", sortKey, d.clExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key, d.clExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key, d.clExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 4; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// DelChannelArcCache delete channel archive cache from cache list.
|
||
|
|
func (d *Dao) DelChannelArcCache(c context.Context, mid, cid, aid int64) (err error) {
|
||
|
|
key := keyClArc(mid, cid)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
if err = conn.Send("HDEL", key, aid); err != nil {
|
||
|
|
log.Error("conn.Send(ZREM,%s,%d) error(%v)", key, aid, err)
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// DelChannelArcsCache delete all channel arcs cache when delete channel
|
||
|
|
func (d *Dao) DelChannelArcsCache(c context.Context, mid, cid int64) (err error) {
|
||
|
|
key := keyClArc(mid, cid)
|
||
|
|
conn := d.redis.Get(c)
|
||
|
|
defer conn.Close()
|
||
|
|
if err = conn.Send("DEL", key); err != nil {
|
||
|
|
log.Error("conn.Send(DEL,%s,%d,%d) error(%v)", key, mid, cid, err)
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
// SetChannelArcsCache add channel archive cache.
|
||
|
|
func (d *Dao) SetChannelArcsCache(c context.Context, mid, cid int64, arcs []*model.ChannelArc) (err error) {
|
||
|
|
var (
|
||
|
|
bs []byte
|
||
|
|
key1 = keyClArc(mid, cid)
|
||
|
|
key2 = keyClArcSort(mid, cid)
|
||
|
|
conn = d.redis.Get(c)
|
||
|
|
)
|
||
|
|
defer conn.Close()
|
||
|
|
if err = conn.Send("DEL", key1); err != nil {
|
||
|
|
log.Error("conn.Send(DEL, %s) error(%v)", key1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("DEL", key2); err != nil {
|
||
|
|
log.Error("conn.Send(DEL, %s) error(%v)", key2, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
args1 := redis.Args{}.Add(key1)
|
||
|
|
args2 := redis.Args{}.Add(key2)
|
||
|
|
for _, arc := range arcs {
|
||
|
|
if bs, err = json.Marshal(arc); err != nil {
|
||
|
|
log.Error("json.Marshal() error(%v)", err)
|
||
|
|
continue
|
||
|
|
} else {
|
||
|
|
args1 = args1.Add(arc.Aid).Add(string(bs))
|
||
|
|
}
|
||
|
|
args2 = args2.Add(arc.OrderNum).Add(arc.Aid)
|
||
|
|
}
|
||
|
|
if err = conn.Send("HMSET", args1...); err != nil {
|
||
|
|
log.Error("conn.Send(HMSET, %s) error(%v)", key1, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("ZADD", args2...); err != nil {
|
||
|
|
log.Error("conn.Send(ZADD, %s) error(%v)", key2, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key1, d.clExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key1, d.clExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Send("EXPIRE", key2, d.clExpire); err != nil {
|
||
|
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key2, d.clExpire, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if err = conn.Flush(); err != nil {
|
||
|
|
log.Error("conn.Flush error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for i := 0; i < 6; i++ {
|
||
|
|
if _, err = conn.Receive(); err != nil {
|
||
|
|
log.Error("conn.Receive() error(%v)", err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|