333 lines
9.0 KiB
Go
333 lines
9.0 KiB
Go
package followmod
|
|
|
|
import (
|
|
"91porn-server/common/db"
|
|
"91porn-server/common/log"
|
|
"91porn-server/models"
|
|
"fmt"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
"time"
|
|
)
|
|
|
|
var mdb *db.MongoDB
|
|
|
|
const table = models.Follow
|
|
|
|
func coll(t *db.MongoTool) *db.MongoTool {
|
|
if t == nil {
|
|
return mdb.Coll(table)
|
|
}
|
|
return t.Coll(table)
|
|
}
|
|
|
|
// initIndex 初始化索引
|
|
func initIndex() {
|
|
many := []mongo.IndexModel{
|
|
{
|
|
Keys: bson.D{{"followUID", -1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{"uid", 1}, {"followUID", 1}},
|
|
Options: options.Index().SetUnique(true),
|
|
},
|
|
{
|
|
Keys: bson.D{{"uniq", 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{"createdAt", -1}},
|
|
},
|
|
}
|
|
_, err := coll(nil).CreateIndex(many)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
|
|
}
|
|
return
|
|
}
|
|
|
|
// AddFollow 添加关注
|
|
func AddFollow(uid uint64, followUID uint64, isShort bool) (int64, error) {
|
|
set := bson.M{"uniq": Unique(uid, followUID), "createdAt": time.Now()}
|
|
if isShort {
|
|
set["newsType"] = "SHORT"
|
|
}
|
|
res, err := coll(nil).UpsertOne(
|
|
bson.M{"uid": uid, "followUID": followUID},
|
|
bson.M{"$set": set})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "AddFollow", table, "UpsertOne", err),
|
|
log.Any("uid", uid), log.Any("followUID", followUID),
|
|
)
|
|
}
|
|
if res != nil {
|
|
return res.UpsertedCount, err
|
|
}
|
|
return 0, err
|
|
}
|
|
|
|
// CloseFollow 取消关注
|
|
func CloseFollow(uid uint64, followUID uint64) (int64, error) {
|
|
res, err := coll(nil).DeleteOne(
|
|
bson.M{"uid": uid, "followUID": followUID})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CloseFollow", table, "DeleteOne", err),
|
|
log.Any("uid", uid), log.Any("followUID", followUID),
|
|
)
|
|
}
|
|
if res != nil {
|
|
return res.DeletedCount, err
|
|
}
|
|
return 0, err
|
|
}
|
|
|
|
// IsFollow 是否关注
|
|
func IsFollow(uid uint64, followUID uint64) (bool, error) {
|
|
f := FollowModel{}
|
|
err := coll(nil).FindOne(&f, bson.M{"uid": uid, "followUID": followUID})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsFollow", table, "Count", err), log.Any("uid", uid), log.Any("followUID", followUID))
|
|
return false, err
|
|
}
|
|
if f.FollowUID == 0 {
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// IsFollowUsers 是否关注这些用户
|
|
func IsFollowUsers(uid uint64, followUIDs []uint64) (map[uint64]bool, error) {
|
|
if followUIDs == nil {
|
|
followUIDs = []uint64{}
|
|
}
|
|
m := make(map[uint64]bool)
|
|
if uid == 0 || len(followUIDs) == 0 {
|
|
return m, nil
|
|
}
|
|
var infos []FollowModel
|
|
err := coll(nil).Find(&infos, bson.M{"uid": uid, "followUID": bson.M{"$in": followUIDs}})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsFollowUsers", table, "Find", err),
|
|
log.Any("uid", uid), log.Any("followUIDs", followUIDs),
|
|
)
|
|
return m, err
|
|
}
|
|
for _, i := range infos {
|
|
m[i.FollowUID] = true
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// IsFollowedByUsers 是否被这些用户关注
|
|
func IsFollowedByUsers(followUID uint64, uids []uint64) (map[uint64]bool, error) {
|
|
if uids == nil {
|
|
uids = []uint64{}
|
|
}
|
|
m := make(map[uint64]bool)
|
|
var infos []FollowModel
|
|
err := coll(nil).Find(&infos, bson.M{"followUID": followUID, "uid": bson.M{"$in": uids}})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsFollowedByUsers", table, "Find", err),
|
|
log.Any("followUID", followUID), log.Any("uids", uids),
|
|
)
|
|
return m, err
|
|
}
|
|
for _, i := range infos {
|
|
m[i.UID] = true
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// FollowStatueMap 从给定的hash列表中获取like状态映射:hash->Statue
|
|
// hash通过Vector.hash()获取
|
|
func FollowStatueMap(uniqList []string) (map[string]bool, error) {
|
|
filter := bson.M{
|
|
"uniq": bson.M{"$in": uniqList},
|
|
}
|
|
existLikeList := make([]FollowModel, 0, len(uniqList))
|
|
err := coll(nil).Find(&existLikeList, filter)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FollowStatueMap", table, "Find", err),
|
|
log.Any("uniqList", uniqList),
|
|
)
|
|
return nil, err
|
|
}
|
|
m := make(map[string]bool, len(existLikeList))
|
|
//初始化
|
|
for _, uniq := range uniqList {
|
|
m[uniq] = false
|
|
}
|
|
//已经关注的
|
|
for _, v := range existLikeList {
|
|
uniq := v.Uniq
|
|
m[uniq] = true
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// GetFollowCount 获取关注总数
|
|
func GetFollowCount(uid uint64) (int64, error) {
|
|
total, err := coll(nil).Count(bson.M{"uid": uid})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsFollowEachOther", table, "Count", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return 0, err
|
|
}
|
|
return total, nil
|
|
}
|
|
|
|
// GetFansCount 获取粉丝总数
|
|
func GetFansCount(uid uint64) (int64, error) {
|
|
total, err := coll(nil).Count(bson.M{"followUID": uid})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetFansCount", table, "Count", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return 0, err
|
|
}
|
|
return total, nil
|
|
}
|
|
|
|
// GetFollowList 获取关注列表
|
|
func GetFollowList(uid uint64, page int, size int, isShort bool) ([]uint64, map[uint64]FollowModel, bool, error) {
|
|
hasNext := false
|
|
m := make(map[uint64]FollowModel)
|
|
cond := bson.M{"uid": uid}
|
|
sort := bson.D{{Key: "createdAt", Value: -1}}
|
|
opts := options.FindOptions{}
|
|
opts.SetSort(sort).SetSkip(int64((page - 1) * size)).SetLimit(int64(size + 1))
|
|
|
|
if isShort {
|
|
cond["newsType"] = "SHORT"
|
|
}
|
|
|
|
var data []*FollowModel
|
|
err := coll(nil).Find(&data, cond, &opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetFollowList", table, "Find", err),
|
|
log.Any("uid", uid), log.Any("page", page), log.Any("size", size),
|
|
)
|
|
return nil, m, false, err
|
|
}
|
|
if len(data) > size {
|
|
hasNext = true
|
|
data = data[:size]
|
|
}
|
|
var uids []uint64
|
|
for _, d := range data {
|
|
if d == nil {
|
|
continue
|
|
}
|
|
uids = append(uids, d.FollowUID)
|
|
m[d.FollowUID] = *d
|
|
}
|
|
return uids, m, hasNext, nil
|
|
}
|
|
|
|
// GetFansList 获取粉丝列表
|
|
func GetFansList(uid uint64, page int, size int) ([]uint64, map[uint64]FollowModel, bool, error) {
|
|
hasNext := false
|
|
m := make(map[uint64]FollowModel)
|
|
cond := bson.M{"followUID": uid}
|
|
sort := bson.D{{Key: "createdAt", Value: -1}}
|
|
opts := options.FindOptions{}
|
|
opts.SetSort(sort).SetSkip(int64((page - 1) * size)).SetLimit(int64(size + 1))
|
|
var data []*FollowModel
|
|
err := coll(nil).Find(&data, cond, &opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetFansList", table, "Find", err),
|
|
log.Any("uid", uid), log.Any("page", page), log.Any("size", size),
|
|
)
|
|
return nil, m, hasNext, err
|
|
}
|
|
if len(data) > size {
|
|
hasNext = true
|
|
data = data[:size]
|
|
}
|
|
var uids []uint64
|
|
for _, d := range data {
|
|
if d == nil {
|
|
continue
|
|
}
|
|
uids = append(uids, d.UID)
|
|
m[d.UID] = *d
|
|
}
|
|
return uids, m, hasNext, nil
|
|
}
|
|
|
|
// GetAllFansUid 获取所有粉丝用户id
|
|
func GetAllFansUid(uid uint64) ([]uint64, error) {
|
|
var data []*FollowModel
|
|
cond := bson.M{"followUID": uid}
|
|
sort := bson.D{{Key: "createdAt", Value: -1}}
|
|
opts := options.FindOptions{}
|
|
opts.SetSort(sort)
|
|
err := coll(nil).Find(&data, cond, &opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetAllFansUid", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return nil, err
|
|
}
|
|
var uids []uint64
|
|
for _, d := range data {
|
|
uids = append(uids, d.UID)
|
|
}
|
|
return uids, nil
|
|
}
|
|
|
|
// GetTotalFollowList 获取所有关注用户
|
|
func GetTotalFollowList(uid uint64) ([]uint64, error) {
|
|
var data []*FollowModel
|
|
cond := bson.M{"uid": uid}
|
|
sort := bson.D{{Key: "createdAt", Value: -1}}
|
|
opts := options.FindOptions{}
|
|
opts.SetSort(sort).SetLimit(5)
|
|
err := coll(nil).Find(&data, cond, &opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetTotalFollowList", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return nil, err
|
|
}
|
|
var uids []uint64
|
|
for _, d := range data {
|
|
uids = append(uids, d.FollowUID)
|
|
}
|
|
return uids, nil
|
|
}
|
|
|
|
// GetTotalFollowListLimit 获取所有关注用户
|
|
func GetTotalFollowListLimit(uid uint64, limit int64) ([]uint64, error) {
|
|
var data []*FollowModel
|
|
cond := bson.M{"uid": uid}
|
|
sort := bson.D{{Key: "createdAt", Value: -1}}
|
|
opts := options.FindOptions{}
|
|
opts.SetSort(sort).SetLimit(limit)
|
|
err := coll(nil).Find(&data, cond, &opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetTotalFollowListLimit", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
)
|
|
return nil, err
|
|
}
|
|
var uids []uint64
|
|
for _, d := range data {
|
|
uids = append(uids, d.FollowUID)
|
|
}
|
|
return uids, nil
|
|
}
|
|
|
|
// WeekFollowLeaderboard 周关注榜单
|
|
func WeekFollowLeaderboard(bind interface{}, filter bson.M, limit int) error {
|
|
opt := options.Aggregate().SetAllowDiskUse(true)
|
|
pip := []bson.M{
|
|
{"$match": filter}, // 过滤条件 由外部决定
|
|
{"$group": bson.M{"_id": "$followUID", "count": bson.M{"$sum": 1}}}, // 统计用户被关注
|
|
{"$sort": bson.M{"count": -1}}, // 按照作品数排序
|
|
{"$limit": limit}, // 限制返回条数
|
|
}
|
|
return coll(nil).Aggregate(bind, pip, opt)
|
|
}
|