You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
985 lines
26 KiB
985 lines
26 KiB
package like |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"fmt" |
|
"net/http" |
|
"net/url" |
|
"strconv" |
|
"time" |
|
|
|
"go-common/app/interface/main/activity/model/like" |
|
"go-common/library/cache/memcache" |
|
"go-common/library/cache/redis" |
|
"go-common/library/database/elastic" |
|
"go-common/library/database/sql" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
"go-common/library/net/metadata" |
|
xtime "go-common/library/time" |
|
"go-common/library/xstr" |
|
|
|
"github.com/pkg/errors" |
|
) |
|
|
|
const ( |
|
_selLikeSQL = "SELECT id,wid FROM likes where state = 1 AND sid = ? ORDER BY type" |
|
_likeSQL = "SELECT id,sid,type,mid,wid,state,stick_top,ctime,mtime FROM likes WHERE id = ? and state = 1" |
|
_likeMoreLidSQL = "SELECT id,sid,type,mid,wid,state,stick_top,ctime,mtime FROM likes WHERE id > ? order by id asc limit 1000" |
|
_likesBySidSQL = "SELECT id,sid,type,mid,wid,state,stick_top,ctime,mtime FROM likes WHERE id > ? and sid = ? and state = 1 order by id asc limit 1000" |
|
_likesSQL = "SELECT id,sid,type,mid,wid,state,stick_top,ctime,mtime FROM likes WHERE id IN (%s) and state = 1" |
|
_likeListSQL = "SELECT id,wid,ctime FROM likes WHERE state = 1 AND sid = ? ORDER BY id DESC" |
|
_likeMaxIDSQL = "SELECT id FROM likes ORDER BY id DESC limit 1" |
|
_keyLikeTagFmt = "l_t_%d_%d" |
|
_keyLikeTagCntsFmt = "l_t_cs_%d" |
|
_keyLikeRegionFmt = "l_r_%d_%d" |
|
// likeAPI ip frequence key the old is ddos:like:ip:%s |
|
_keyIPRequestFmt = "go:ddos:l:ip:%s" |
|
// the cache set of like order by ctime the old is bilibili-activity:ctime:%d |
|
_keyLikeListCtimeFmt = "go:bl-a:ctime:%d" |
|
_keyLikeListRandomFmt = "go:bl-a:random:%d" |
|
// the cache set of like type order by ctime |
|
_keyLikeListTypeCtimeFmt = "go:b:a:t:%d:%d" |
|
// storyKing LikeAct cache |
|
_keyStoryDilyLikeFmt = "go:s:d:m:%s:%d:%d" |
|
// storyKing each likeAct cahce |
|
_keyStoryEachLikeFmt = "go:s:ea:m:%s:%d:%d:%d" |
|
// es index |
|
_activity = "activity" |
|
// EsOrderLikes archive center likes. |
|
EsOrderLikes = "likes" |
|
// EsOrderCoin archive center coin . |
|
EsOrderCoin = "coin" |
|
// EsOrderReply archive center reply. |
|
EsOrderReply = "reply" |
|
// EsOrderShare archive center share. |
|
EsOrderShare = "share" |
|
// EsOrderClick archive center click |
|
EsOrderClick = "click" |
|
// EsOrderDm archive center dm |
|
EsOrderDm = "dm" |
|
// EsOrderFav archive center fav |
|
EsOrderFav = "fav" |
|
// ActOrderLike activity list like order. |
|
ActOrderLike = "like" |
|
// ActOrderCtime activity list ctime order. |
|
ActOrderCtime = "ctime" |
|
// ActOrderRandom order random . |
|
ActOrderRandom = "random" |
|
) |
|
|
|
// ipRequestKey . |
|
func ipRequestKey(ip string) string { |
|
return fmt.Sprintf(_keyIPRequestFmt, ip) |
|
} |
|
|
|
func likeListCtimeKey(sid int64) string { |
|
return fmt.Sprintf(_keyLikeListCtimeFmt, sid) |
|
} |
|
|
|
func likeListRandomKey(sid int64) string { |
|
return fmt.Sprintf(_keyLikeListRandomFmt, sid) |
|
} |
|
|
|
func likeListTypeCtimeKey(types int, sid int64) string { |
|
return fmt.Sprintf(_keyLikeListTypeCtimeFmt, types, sid) |
|
} |
|
|
|
func keyLikeTag(sid, tagID int64) string { |
|
return fmt.Sprintf(_keyLikeTagFmt, sid, tagID) |
|
} |
|
|
|
func keyLikeTagCounts(sid int64) string { |
|
return fmt.Sprintf(_keyLikeTagCntsFmt, sid) |
|
} |
|
|
|
func keyLikeRegion(sid int64, regionID int16) string { |
|
return fmt.Sprintf(_keyLikeRegionFmt, sid, regionID) |
|
} |
|
|
|
func keyStoryLikeKey(sid, mid int64, daily string) string { |
|
return fmt.Sprintf(_keyStoryDilyLikeFmt, daily, sid, mid) |
|
} |
|
|
|
func keyStoryEachLike(sid, mid, lid int64, daily string) string { |
|
return fmt.Sprintf(_keyStoryEachLikeFmt, daily, sid, mid, lid) |
|
} |
|
|
|
// LikeTypeList dao sql. |
|
func (dao *Dao) LikeTypeList(c context.Context, sid int64) (ns []*like.Like, err error) { |
|
rows, err := dao.db.Query(c, _selLikeSQL, sid) |
|
if err != nil { |
|
log.Error("LikeTypeList dao.db.Query error(%v)", err) |
|
return |
|
} |
|
ns = make([]*like.Like, 0) |
|
defer rows.Close() |
|
for rows.Next() { |
|
n := &like.Like{} |
|
if err = rows.Scan(&n.ID, &n.Wid); err != nil { |
|
log.Error("row.Scan error(%v)", err) |
|
return |
|
} |
|
ns = append(ns, n) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("row.Scan row error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// LikeList dao sql |
|
func (dao *Dao) LikeList(c context.Context, sid int64) (ns []*like.Item, err error) { |
|
rows, err := dao.db.Query(c, _likeListSQL, sid) |
|
if err != nil { |
|
log.Error("LikeList dao.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
n := new(like.Item) |
|
if err = rows.Scan(&n.ID, &n.Wid, &n.Ctime); err != nil { |
|
log.Error("row.Scan error(%v)", err) |
|
return |
|
} |
|
ns = append(ns, n) |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("row.Scan row error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// RawLikes get likes by wid. |
|
func (dao *Dao) RawLikes(c context.Context, ids []int64) (data map[int64]*like.Item, err error) { |
|
rows, err := dao.db.Query(c, fmt.Sprintf(_likesSQL, xstr.JoinInts(ids))) |
|
if err != nil { |
|
log.Error("Likes dao.db.Query error(%v)", err) |
|
return |
|
} |
|
defer rows.Close() |
|
data = make(map[int64]*like.Item) |
|
for rows.Next() { |
|
res := &like.Item{} |
|
if err = rows.Scan(&res.ID, &res.Sid, &res.Type, &res.Mid, &res.Wid, &res.State, &res.StickTop, &res.Ctime, &res.Mtime); err != nil { |
|
log.Error("Likes row.Scan error(%v)", err) |
|
return |
|
} |
|
data[res.ID] = res |
|
} |
|
if err = rows.Err(); err != nil { |
|
log.Error("Likes row.Scan row error(%v)", err) |
|
} |
|
|
|
return |
|
} |
|
|
|
// LikeTagCache get like tag cache. |
|
func (dao *Dao) LikeTagCache(c context.Context, sid, tagID int64, start, end int) (likes []*like.Item, err error) { |
|
var values []interface{} |
|
key := keyLikeTag(sid, tagID) |
|
conn := dao.redis.Get(c) |
|
defer conn.Close() |
|
if values, err = redis.Values(conn.Do("ZREVRANGE", key, start, end)); err != nil { |
|
log.Error("LikeTagCache conn.Do(ZREVRANGE, %s) error(%v)", key, err) |
|
return |
|
} else if len(values) == 0 { |
|
return |
|
} |
|
for len(values) > 0 { |
|
var bs []byte |
|
if values, err = redis.Scan(values, &bs); err != nil { |
|
log.Error("LikeRegionCache redis.Scan(%v) error(%v)", values, err) |
|
return |
|
} |
|
like := new(like.Item) |
|
if err = json.Unmarshal(bs, &like); err != nil { |
|
log.Error("LikeRegionCache conn.Do(ZRANGE, %s) error(%v)", key, err) |
|
continue |
|
} |
|
if like.ID > 0 { |
|
likes = append(likes, like) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// LikeTagCnt get like tag cnt. |
|
func (dao *Dao) LikeTagCnt(c context.Context, sid, tagID int64) (count int, err error) { |
|
key := keyLikeTag(sid, tagID) |
|
conn := dao.redis.Get(c) |
|
defer conn.Close() |
|
if count, err = redis.Int(conn.Do("ZCARD", key)); err != nil { |
|
log.Error("LikeRegionCnt conn.Do(ZCARD, %s) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// SetLikeTagCache set like tag cache no expire. |
|
func (dao *Dao) SetLikeTagCache(c context.Context, sid, tagID int64, likes []*like.Item) (err error) { |
|
var bs []byte |
|
key := keyLikeTag(sid, tagID) |
|
conn := dao.redis.Get(c) |
|
defer conn.Close() |
|
if err = conn.Send("DEL", key); err != nil { |
|
log.Error("SetLikeTagCache conn.Send(DEL, %s) error(%v)", key, err) |
|
return |
|
} |
|
args := redis.Args{}.Add(key) |
|
for _, v := range likes { |
|
if bs, err = json.Marshal(v); err != nil { |
|
log.Error("SetLikeTagCache json.Marshal() error(%v)", err) |
|
return |
|
} |
|
args = args.Add(v.Ctime).Add(bs) |
|
} |
|
if err = conn.Send("ZADD", args...); err != nil { |
|
log.Error("conn.Send(ZADD, %s) error(%v)", key, 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 |
|
} |
|
|
|
// LikeRegionCache get like region cache. |
|
func (dao *Dao) LikeRegionCache(c context.Context, sid int64, regionID int16, start, end int) (likes []*like.Item, err error) { |
|
var values []interface{} |
|
key := keyLikeRegion(sid, regionID) |
|
conn := dao.redis.Get(c) |
|
defer conn.Close() |
|
if values, err = redis.Values(conn.Do("ZREVRANGE", key, start, end)); err != nil { |
|
log.Error("LikeRegionCache conn.Do(ZREVRANGE, %s) error(%v)", key, err) |
|
return |
|
} else if len(values) == 0 { |
|
return |
|
} |
|
for len(values) > 0 { |
|
var bs []byte |
|
if values, err = redis.Scan(values, &bs); err != nil { |
|
log.Error("LikeRegionCache redis.Scan(%v) error(%v)", values, err) |
|
return |
|
} |
|
like := new(like.Item) |
|
if err = json.Unmarshal(bs, &like); err != nil { |
|
log.Error("LikeRegionCache conn.Do(ZREVRANGE, %s) error(%v)", key, err) |
|
continue |
|
} |
|
if like.ID > 0 { |
|
likes = append(likes, like) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// LikeRegionCnt get like region cnt. |
|
func (dao *Dao) LikeRegionCnt(c context.Context, sid int64, regionID int16) (count int, err error) { |
|
key := keyLikeRegion(sid, regionID) |
|
conn := dao.redis.Get(c) |
|
defer conn.Close() |
|
if count, err = redis.Int(conn.Do("ZCARD", key)); err != nil { |
|
log.Error("LikeRegionCnt conn.Do(ZCARD, %s) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// SetLikeRegionCache set like region cache. |
|
func (dao *Dao) SetLikeRegionCache(c context.Context, sid int64, regionID int16, likes []*like.Item) (err error) { |
|
var bs []byte |
|
key := keyLikeRegion(sid, regionID) |
|
conn := dao.redis.Get(c) |
|
defer conn.Close() |
|
if err = conn.Send("DEL", key); err != nil { |
|
log.Error("SetLikeTagCache conn.Send(DEL, %s) error(%v)", key, err) |
|
return |
|
} |
|
args := redis.Args{}.Add(key) |
|
for _, v := range likes { |
|
if bs, err = json.Marshal(v); err != nil { |
|
log.Error("SetLikeRegionCache json.Marshal() error(%v)", err) |
|
return |
|
} |
|
args = args.Add(v.Ctime).Add(bs) |
|
} |
|
if err = conn.Send("ZADD", args...); err != nil { |
|
log.Error("conn.Send(ZADD, %s) error(%v)", key, 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 |
|
} |
|
|
|
// SetTagLikeCountsCache . |
|
func (dao *Dao) SetTagLikeCountsCache(c context.Context, sid int64, counts map[int64]int32) (err error) { |
|
key := keyLikeTagCounts(sid) |
|
conn := dao.redis.Get(c) |
|
defer conn.Close() |
|
args := redis.Args{}.Add(key) |
|
for tagID, count := range counts { |
|
args = args.Add(tagID).Add(count) |
|
} |
|
if _, err = conn.Do("HMSET", args...); err != nil { |
|
log.Error("SetLikeCountsCache conn.Do(HMSET) key(%s) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// TagLikeCountsCache get tag like counts cache. |
|
func (dao *Dao) TagLikeCountsCache(c context.Context, sid int64, tagIDs []int64) (counts map[int64]int32, err error) { |
|
if len(tagIDs) == 0 { |
|
return |
|
} |
|
key := keyLikeTagCounts(sid) |
|
conn := dao.redis.Get(c) |
|
defer conn.Close() |
|
args := redis.Args{}.Add(key).AddFlat(tagIDs) |
|
var tmpCounts []int |
|
if tmpCounts, err = redis.Ints(conn.Do("HMGET", args...)); err != nil { |
|
log.Error("redis.Ints(HMGET) key(%s) args(%v) error(%v)", key, args, err) |
|
return |
|
} |
|
if len(tmpCounts) != len(tagIDs) { |
|
return |
|
} |
|
counts = make(map[int64]int32, len(tagIDs)) |
|
for i, tagID := range tagIDs { |
|
counts[tagID] = int32(tmpCounts[i]) |
|
} |
|
return |
|
} |
|
|
|
// RawLike get like by id . |
|
func (dao *Dao) RawLike(c context.Context, id int64) (res *like.Item, err error) { |
|
res = new(like.Item) |
|
row := dao.db.QueryRow(c, _likeSQL, id) |
|
if err = row.Scan(&res.ID, &res.Sid, &res.Type, &res.Mid, &res.Wid, &res.State, &res.StickTop, &res.Ctime, &res.Mtime); err != nil { |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
} else { |
|
err = errors.Wrap(err, "LikeByID:QueryRow") |
|
} |
|
} |
|
return |
|
} |
|
|
|
// LikeListMoreLid get likes data with like.id greater than lid |
|
func (dao *Dao) LikeListMoreLid(c context.Context, lid int64) (res []*like.Item, err error) { |
|
var rows *sql.Rows |
|
if rows, err = dao.db.Query(c, _likeMoreLidSQL, lid); err != nil { |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
} else { |
|
err = errors.Wrap(err, "LikeListMoreLid:dao.db.Query()") |
|
} |
|
return |
|
} |
|
defer rows.Close() |
|
res = make([]*like.Item, 0, 1000) |
|
for rows.Next() { |
|
a := &like.Item{} |
|
if err = rows.Scan(&a.ID, &a.Sid, &a.Type, &a.Mid, &a.Wid, &a.State, &a.StickTop, &a.Ctime, &a.Mtime); err != nil { |
|
err = errors.Wrap(err, "LikeListMoreLid:rows.Scan()") |
|
return |
|
} |
|
res = append(res, a) |
|
} |
|
if err = rows.Err(); err != nil { |
|
err = errors.Wrap(err, "LikeListMoreLid: rows.Err()") |
|
} |
|
return |
|
} |
|
|
|
// LikesBySid get sid all likes . |
|
func (dao *Dao) LikesBySid(c context.Context, lid, sid int64) (res []*like.Item, err error) { |
|
var rows *sql.Rows |
|
if rows, err = dao.db.Query(c, _likesBySidSQL, lid, sid); err != nil { |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
} else { |
|
err = errors.Wrap(err, "LikesBySid:dao.db.Query()") |
|
} |
|
return |
|
} |
|
defer rows.Close() |
|
res = make([]*like.Item, 0, 1000) |
|
for rows.Next() { |
|
a := &like.Item{} |
|
if err = rows.Scan(&a.ID, &a.Sid, &a.Type, &a.Mid, &a.Wid, &a.State, &a.StickTop, &a.Ctime, &a.Mtime); err != nil { |
|
err = errors.Wrap(err, "LikesBySid:rows.Scan()") |
|
return |
|
} |
|
res = append(res, a) |
|
} |
|
if err = rows.Err(); err != nil { |
|
err = errors.Wrap(err, "LikesBySid:rows.Err()") |
|
} |
|
return |
|
} |
|
|
|
// IPReqquestCheck check ip has ben used or not . |
|
func (dao *Dao) IPReqquestCheck(c context.Context, ip string) (val int, err error) { |
|
var ( |
|
mcKey = ipRequestKey(ip) |
|
conn = dao.mc.Get(c) |
|
item *memcache.Item |
|
) |
|
defer conn.Close() |
|
if item, err = conn.Get(mcKey); err != nil { |
|
if err == memcache.ErrNotFound { |
|
err = nil |
|
val = 0 |
|
} else { |
|
err = errors.Wrap(err, "IPReqquestCheck:conn.Get() error") |
|
} |
|
return |
|
} |
|
if err = conn.Scan(item, &val); err != nil { |
|
err = errors.Wrap(err, "IPReqquestCheck:conn.Scan() ") |
|
} |
|
return |
|
} |
|
|
|
// SetIPRequest set ip has been used |
|
func (dao *Dao) SetIPRequest(c context.Context, ip string) (err error) { |
|
var ( |
|
conn = dao.mc.Get(c) |
|
item = &memcache.Item{ |
|
Key: ipRequestKey(ip), |
|
Expiration: dao.mcLikeIPExpire, |
|
Flags: memcache.FlagRAW, |
|
Value: []byte("1"), |
|
} |
|
) |
|
defer conn.Close() |
|
if err = conn.Set(item); err != nil { |
|
err = errors.Wrap(err, "SetIPRequest:conn.Set()") |
|
} |
|
return |
|
} |
|
|
|
// LikeCtime . |
|
func (dao *Dao) LikeCtime(c context.Context, sid int64, start, end int) (res []int64, err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
key = likeListCtimeKey(sid) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Int64s(conn.Do("ZREVRANGE", key, start, end)); err != nil { |
|
if err == redis.ErrNil { |
|
err = nil |
|
} else { |
|
err = errors.Wrap(err, "conn.Do(ZREVRANGE)") |
|
} |
|
} |
|
return |
|
} |
|
|
|
// LikeRandom . |
|
func (dao *Dao) LikeRandom(c context.Context, sid int64, start, end int) (res []int64, err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
key = likeListRandomKey(sid) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Int64s(conn.Do("ZREVRANGE", key, start, end)); err != nil { |
|
if err == redis.ErrNil { |
|
err = nil |
|
} else { |
|
err = errors.Wrap(err, "conn.Do(ZREVRANGE)") |
|
} |
|
} |
|
return |
|
} |
|
|
|
// LikeRandomCount . |
|
func (dao *Dao) LikeRandomCount(c context.Context, sid int64) (res int64, err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
key = likeListRandomKey(sid) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Int64(conn.Do("ZCARD", key)); err != nil { |
|
log.Error("LikeRandomCount conn.Do(ZCARD, %s) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// SetLikeRandom . |
|
func (dao *Dao) SetLikeRandom(c context.Context, sid int64, ids []int64) (err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
key = likeListRandomKey(sid) |
|
) |
|
defer conn.Close() |
|
if len(ids) == 0 { |
|
return |
|
} |
|
args := redis.Args{}.Add(key) |
|
for k, v := range ids { |
|
args = args.Add(k + 1).Add(v) |
|
} |
|
if err = conn.Send("ZADD", args...); err != nil { |
|
err = errors.Wrap(err, "conn.Send(ZADD)") |
|
return |
|
} |
|
if err = conn.Send("EXPIRE", key, dao.randomExpire); err != nil { |
|
err = errors.Wrap(err, "conn.Send(EXPIRE)") |
|
return |
|
} |
|
if err = conn.Flush(); err != nil { |
|
err = errors.Wrap(err, "conn.Flush()") |
|
return |
|
} |
|
for i := 0; i < 2; i++ { |
|
if _, err = conn.Receive(); err != nil { |
|
err = errors.Wrapf(err, "conn.Receive(%d)", i) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// LikeCount . |
|
func (dao *Dao) LikeCount(c context.Context, sid int64) (res int64, err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
key = likeListCtimeKey(sid) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Int64(conn.Do("ZCARD", key)); err != nil { |
|
log.Error("LikeCount conn.Do(ZCARD, %s) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// LikeListCtime set like list by ctime. |
|
func (dao *Dao) LikeListCtime(c context.Context, sid int64, items []*like.Item) (err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
key = likeListCtimeKey(sid) |
|
max = 0 |
|
) |
|
defer conn.Close() |
|
args := redis.Args{}.Add(key) |
|
for _, v := range items { |
|
args = args.Add(v.Ctime).Add(v.ID) |
|
if v.Type != 0 { |
|
typeKey := likeListTypeCtimeKey(v.Type, sid) |
|
typeArgs := redis.Args{}.Add(typeKey).Add(v.Ctime).Add(v.ID) |
|
if err = conn.Send("ZADD", typeArgs...); err != nil { |
|
log.Error("LikeListCtime:conn.Send(%v) error(%v)", v, err) |
|
return |
|
} |
|
max++ |
|
} |
|
} |
|
if err = conn.Send("ZADD", args...); err != nil { |
|
log.Error("LikeListCtime:conn.Send(%v) error(%v)", items, err) |
|
return |
|
} |
|
max++ |
|
if err = conn.Flush(); err != nil { |
|
log.Error("LikeListCtime:conn.Flush error(%v)", err) |
|
return |
|
} |
|
for i := 0; i < max; i++ { |
|
if _, err = conn.Receive(); err != nil { |
|
log.Error("LikeListCtime:conn.Receive(%d) error(%v)", i, err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
//DelLikeListCtime delete likeList Ctime cache . |
|
func (dao *Dao) DelLikeListCtime(c context.Context, sid int64, items []*like.Item) (err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
key = likeListCtimeKey(sid) |
|
max = 0 |
|
) |
|
defer conn.Close() |
|
args := redis.Args{}.Add(key) |
|
for _, v := range items { |
|
args = args.Add(v.ID) |
|
if v.Type != 0 { |
|
typeKey := likeListTypeCtimeKey(v.Type, sid) |
|
if err = conn.Send("ZREM", typeKey, v.ID); err != nil { |
|
log.Error("DelLikeListCtime:conn.Send(%v) error(%v)", v, err) |
|
return |
|
} |
|
max++ |
|
} |
|
} |
|
if err = conn.Send("ZREM", args...); err != nil { |
|
log.Error("DelLikeListCtime:conn.Send(%v) error(%v)", args, err) |
|
return |
|
} |
|
max++ |
|
if err = conn.Flush(); err != nil { |
|
log.Error("DelLikeListCtime:conn.Flush error(%v)", err) |
|
return |
|
} |
|
for i := 0; i < max; i++ { |
|
if _, err = conn.Receive(); err != nil { |
|
log.Error("DelLikeListCtime:conn.Receive(%d) error(%v)", i, err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// LikeMaxID get likes last id . |
|
func (dao *Dao) LikeMaxID(c context.Context) (res *like.Item, err error) { |
|
res = new(like.Item) |
|
rows := dao.db.QueryRow(c, _likeMaxIDSQL) |
|
if err = rows.Scan(&res.ID); err != nil { |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
} else { |
|
err = errors.Wrap(err, "LikeMaxID:QueryRow") |
|
} |
|
} |
|
return |
|
} |
|
|
|
// GroupItemData like data. |
|
func (dao *Dao) GroupItemData(c context.Context, sid int64, ck string) (data []*like.GroupItem, err error) { |
|
var req *http.Request |
|
if req, err = dao.client.NewRequest(http.MethodGet, fmt.Sprintf(dao.likeItemURL, sid), metadata.String(c, metadata.RemoteIP), url.Values{}); err != nil { |
|
return |
|
} |
|
req.Header.Set("Cookie", ck) |
|
var res struct { |
|
Code int `json:"code"` |
|
Data struct { |
|
List []*like.GroupItem `json:"list"` |
|
} `json:"data"` |
|
} |
|
if err = dao.client.Do(c, req, &res, dao.likeItemURL); err != nil { |
|
err = errors.Wrapf(err, "LikeData dao.client.Do sid(%d)", sid) |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
err = errors.Wrapf(ecode.Int(res.Code), "LikeData sid(%d)", sid) |
|
return |
|
} |
|
data = res.Data.List |
|
return |
|
} |
|
|
|
// RawSourceItemData get source data. |
|
func (dao *Dao) RawSourceItemData(c context.Context, sid int64) (sids []int64, err error) { |
|
var res struct { |
|
Code int `json:"code"` |
|
Data struct { |
|
List []*struct { |
|
Data struct { |
|
Sid string `json:"sid"` |
|
} `json:"data"` |
|
} `json:"list"` |
|
} `json:"data"` |
|
} |
|
if err = dao.client.RESTfulGet(c, dao.sourceItemURL, metadata.String(c, metadata.RemoteIP), url.Values{}, &res, sid); err != nil { |
|
err = errors.Wrapf(err, "LikeData dao.client.RESTfulGet sid(%d)", sid) |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
err = errors.Wrapf(ecode.Int(res.Code), "LikeData sid(%d)", sid) |
|
return |
|
} |
|
for _, v := range res.Data.List { |
|
if sid, e := strconv.ParseInt(v.Data.Sid, 10, 64); e != nil { |
|
continue |
|
} else { |
|
sids = append(sids, sid) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// SourceItem get source data json raw message. |
|
func (dao *Dao) SourceItem(c context.Context, sid int64) (source json.RawMessage, err error) { |
|
var res struct { |
|
Code int `json:"code"` |
|
Data json.RawMessage `json:"data"` |
|
} |
|
if err = dao.client.RESTfulGet(c, dao.sourceItemURL, metadata.String(c, metadata.RemoteIP), url.Values{}, &res, sid); err != nil { |
|
err = errors.Wrapf(err, "LikeData dao.client.RESTfulGet sid(%d)", sid) |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
err = errors.Wrapf(ecode.Int(res.Code), "LikeData sid(%d)", sid) |
|
return |
|
} |
|
source = res.Data |
|
return |
|
} |
|
|
|
// StoryLikeSum . |
|
func (dao *Dao) StoryLikeSum(c context.Context, sid, mid int64) (res int64, err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
now = time.Now().Format("2006-01-02") |
|
key = keyStoryLikeKey(sid, mid, now) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Int64(conn.Do("GET", key)); err != nil { |
|
if err == redis.ErrNil { |
|
err = nil |
|
res = -1 |
|
} else { |
|
err = errors.Wrap(err, "redis.Do(get)") |
|
} |
|
} |
|
return |
|
} |
|
|
|
// IncrStoryLikeSum . |
|
func (dao *Dao) IncrStoryLikeSum(c context.Context, sid, mid int64, score int64) (res int64, err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
now = time.Now().Format("2006-01-02") |
|
key = keyStoryLikeKey(sid, mid, now) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Int64(conn.Do("INCRBY", key, score)); err != nil { |
|
err = errors.Wrap(err, "redis.Do(get)") |
|
} |
|
return |
|
} |
|
|
|
// SetLikeSum . |
|
func (dao *Dao) SetLikeSum(c context.Context, sid, mid int64, sum int64) (err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
now = time.Now().Format("2006-01-02") |
|
key = keyStoryLikeKey(sid, mid, now) |
|
res bool |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Bool(conn.Do("SETNX", key, sum)); err != nil { |
|
err = errors.Wrap(err, "redis.Bool(SETNX)") |
|
return |
|
} |
|
if res { |
|
conn.Do("EXPIRE", key, 86400) |
|
} else { |
|
err = errors.New("redis.Bool(SETNX) res false") |
|
} |
|
return |
|
} |
|
|
|
// StoryEachLikeSum . |
|
func (dao *Dao) StoryEachLikeSum(c context.Context, sid, mid, lid int64) (res int64, err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
now = time.Now().Format("2006-01-02") |
|
key = keyStoryEachLike(sid, mid, lid, now) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Int64(conn.Do("GET", key)); err != nil { |
|
if err == redis.ErrNil { |
|
err = nil |
|
res = -1 |
|
} else { |
|
err = errors.Wrap(err, "redis.Do(get)") |
|
} |
|
} |
|
return |
|
} |
|
|
|
// IncrStoryEachLikeAct . |
|
func (dao *Dao) IncrStoryEachLikeAct(c context.Context, sid, mid, lid int64, score int64) (res int64, err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
now = time.Now().Format("2006-01-02") |
|
key = keyStoryEachLike(sid, mid, lid, now) |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Int64(conn.Do("INCRBY", key, score)); err != nil { |
|
err = errors.Wrap(err, "redis.Do(get)") |
|
} |
|
return |
|
} |
|
|
|
// SetEachLikeSum . |
|
func (dao *Dao) SetEachLikeSum(c context.Context, sid, mid, lid int64, sum int64) (err error) { |
|
var ( |
|
conn = dao.redis.Get(c) |
|
now = time.Now().Format("2006-01-02") |
|
key = keyStoryEachLike(sid, mid, lid, now) |
|
res bool |
|
) |
|
defer conn.Close() |
|
if res, err = redis.Bool(conn.Do("SETNX", key, sum)); err != nil { |
|
err = errors.Wrap(err, "redis.Bool(SETNX)") |
|
return |
|
} |
|
if res { |
|
conn.Do("EXPIRE", key, 86400) |
|
} else { |
|
err = errors.New("redis.Bool(SETNX) res false") |
|
} |
|
return |
|
} |
|
|
|
// ListFromES . |
|
func (dao *Dao) ListFromES(c context.Context, sid int64, order string, ps, pn int, seed int64) (res *like.ListInfo, err error) { |
|
actResult := new(struct { |
|
Result []struct { |
|
ID int64 `json:"id"` |
|
Wid int64 `json:"wid"` |
|
Ctime xtime.Time `json:"ctime"` |
|
Sid int64 `json:"sid"` |
|
Type int `json:"type"` |
|
Mid int64 `json:"mid"` |
|
State int `json:"state"` |
|
Mtime xtime.Time `json:"mtime"` |
|
Likes int64 `json:"likes"` |
|
Click int64 `json:"click"` |
|
Coin int64 `json:"coin"` |
|
Share int64 `json:"share"` |
|
Reply int64 `json:"reply"` |
|
Dm int64 `json:"dm"` |
|
Fav int64 `json:"fav"` |
|
} `json:"result"` |
|
Page *like.Page `json:"page"` |
|
}) |
|
req := dao.es.NewRequest(_activity).Index(_activity).WhereEq("sid", sid).WhereEq("state", 1).Ps(ps).Pn(pn) |
|
if order != "" { |
|
req.Order(order, elastic.OrderDesc) |
|
} |
|
if seed > 0 { |
|
req.OrderRandomSeed(time.Unix(seed, 0).Format("2006-01-02 15:04:05")) |
|
} |
|
req.Fields("id", "sid", "wid", "mid", "type", "ctime", "mtime", "state", "click", "likes", "coin", "share", "reply", "dm", "fav") |
|
if err = req.Scan(c, &actResult); err != nil { |
|
err = errors.Wrap(err, "req.Scan") |
|
return |
|
} |
|
if len(actResult.Result) == 0 { |
|
return |
|
} |
|
res = &like.ListInfo{Page: actResult.Page, List: make([]*like.List, 0, len(actResult.Result))} |
|
for _, v := range actResult.Result { |
|
a := &like.List{ |
|
Likes: v.Likes, |
|
Click: v.Click, |
|
Coin: v.Coin, |
|
Share: v.Share, |
|
Reply: v.Reply, |
|
Dm: v.Dm, |
|
Fav: v.Fav, |
|
Item: &like.Item{ |
|
ID: v.ID, |
|
Wid: v.Wid, |
|
Ctime: v.Ctime, |
|
Sid: v.Sid, |
|
Type: v.Type, |
|
Mid: v.Mid, |
|
State: v.State, |
|
Mtime: v.Mtime, |
|
}, |
|
} |
|
res.List = append(res.List, a) |
|
} |
|
return |
|
} |
|
|
|
// MultiTags . |
|
func (dao *Dao) MultiTags(c context.Context, wids []int64) (tagList map[int64][]string, err error) { |
|
if len(wids) == 0 { |
|
return |
|
} |
|
var res struct { |
|
Code int `json:"code"` |
|
Data map[int64][]*like.Tag `json:"data"` |
|
} |
|
params := url.Values{} |
|
params.Set("aids", xstr.JoinInts(wids)) |
|
if err = dao.client.Get(c, dao.tagURL, "", params, &res); err != nil { |
|
log.Error("MultiTags:dao.client.Get(%s) error(%+v)", dao.tagURL, err) |
|
return |
|
} |
|
if res.Code != ecode.OK.Code() { |
|
err = ecode.Int(res.Code) |
|
return |
|
} |
|
tagList = make(map[int64][]string, len(res.Data)) |
|
for k, v := range res.Data { |
|
if len(v) == 0 { |
|
continue |
|
} |
|
tagList[k] = make([]string, 0, len(v)) |
|
for _, val := range v { |
|
tagList[k] = append(tagList[k], val.Name) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// OidInfoFromES . |
|
func (dao *Dao) OidInfoFromES(c context.Context, oids []int64, sType int) (res map[int64]*like.Item, err error) { |
|
actResult := new(struct { |
|
Result []struct { |
|
ID int64 `json:"id"` |
|
Wid int64 `json:"wid"` |
|
Ctime xtime.Time `json:"ctime"` |
|
Sid int64 `json:"sid"` |
|
Type int `json:"type"` |
|
Mid int64 `json:"mid"` |
|
State int `json:"state"` |
|
Mtime xtime.Time `json:"mtime"` |
|
Likes int64 `json:"likes"` |
|
Click int64 `json:"click"` |
|
Coin int64 `json:"coin"` |
|
Share int64 `json:"share"` |
|
Reply int64 `json:"reply"` |
|
Dm int64 `json:"dm"` |
|
Fav int64 `json:"fav"` |
|
} `json:"result"` |
|
Page *like.Page `json:"page"` |
|
}) |
|
req := dao.es.NewRequest(_activity).Index(_activity).WhereIn("wid", oids).WhereEq("type", sType) |
|
req.Fields("id", "sid", "wid", "mid", "type", "ctime", "mtime", "state") |
|
if err = req.Scan(c, &actResult); err != nil { |
|
err = errors.Wrap(err, "req.Scan") |
|
return |
|
} |
|
if len(actResult.Result) == 0 { |
|
return |
|
} |
|
res = make(map[int64]*like.Item, len(actResult.Result)) |
|
for _, v := range actResult.Result { |
|
res[v.Wid] = &like.Item{ |
|
ID: v.ID, |
|
Wid: v.Wid, |
|
Ctime: v.Ctime, |
|
Sid: v.Sid, |
|
Type: v.Type, |
|
Mid: v.Mid, |
|
State: v.State, |
|
Mtime: v.Mtime, |
|
} |
|
} |
|
return |
|
}
|
|
|