305 lines
8.1 KiB
Go
305 lines
8.1 KiB
Go
package likemod
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"91porn-server/common/constant"
|
|
"91porn-server/common/db"
|
|
"91porn-server/common/log"
|
|
"91porn-server/models"
|
|
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
)
|
|
|
|
var mdb *db.MongoDB
|
|
|
|
const table = models.Like
|
|
|
|
func coll(t *db.MongoTool) *db.MongoTool {
|
|
if t == nil {
|
|
return mdb.Coll(table)
|
|
}
|
|
return t.Coll(table)
|
|
}
|
|
|
|
func initIndex() {
|
|
many := []mongo.IndexModel{ //batch set indexes //value is the type 1 or -1
|
|
{
|
|
Keys: bson.D{{"userID", 1}, {"type", 1}, {"objID", 1}},
|
|
Options: options.Index().SetUnique(true),
|
|
},
|
|
{
|
|
Keys: bson.D{{"type", 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{"objID", 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{"likedUserID", 1}, {"createdAt", -1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{"createdAt", 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{"createdAt", -1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{"uniq", 1}},
|
|
Options: options.Index().SetUnique(true),
|
|
},
|
|
}
|
|
_, err := coll(nil).CreateIndex(many)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
|
|
}
|
|
}
|
|
|
|
// ThumbsUp 点赞
|
|
func InsertOne(l *Like) (err error) {
|
|
l.Uniq = Unique(l.UserID, l.Type, l.ObjID)
|
|
l.CreatedAt = time.Now()
|
|
_, err = coll(nil).InsertOne(l)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "InsertOne", table, "InsertOne", err))
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// InsertMany 批量点赞
|
|
func InsertManyBulk(docs []*Like) (insertCount int64, err error) {
|
|
opts := options.BulkWriteOptions{}
|
|
opts.SetOrdered(false)
|
|
models := make([]mongo.WriteModel, 0)
|
|
for _, v := range docs {
|
|
models = append(models, mongo.NewInsertOneModel().SetDocument(v))
|
|
}
|
|
res, err := coll(nil).Bulk(models, &opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "InsertManyBulk", table, "Bulk", err))
|
|
return
|
|
}
|
|
insertCount = res.InsertedCount
|
|
return
|
|
}
|
|
|
|
// ThumbsDown 取消点赞
|
|
func DeleteOne(uid uint64, lType string, objID primitive.ObjectID) (err error) {
|
|
_, err = coll(nil).DeleteOne(bson.M{"userID": uid, "type": lType, "objID": objID})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "DeleteOne", table, "DeleteOne", err),
|
|
log.Any("uid", uid),
|
|
log.Any("lType", lType),
|
|
log.Any("objID", objID),
|
|
)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// ThumbsDownBatch 批量取消点赞
|
|
func DeleteMany(uid uint64, lType string, objID []primitive.ObjectID) (err error) {
|
|
_, err = coll(nil).DeleteMany(bson.M{"userID": uid, "type": lType, "objID": bson.M{"$in": objID}})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "DeleteMany", table, "DeleteOne", err),
|
|
log.Any("uid", uid),
|
|
log.Any("lType", lType),
|
|
log.Any("objID", objID),
|
|
)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// FindLiked 获取单条点赞记录 验证是否已经点过赞
|
|
func FindOneByUIDAndObjID(uid uint64, objID primitive.ObjectID) (data Like, err error) {
|
|
err = coll(nil).FindOne(&data, bson.M{"userID": uid, "objID": objID})
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindOneByUIDAndObjID", table, "FindOne", err),
|
|
log.Any("uid", uid),
|
|
log.Any("objID", objID),
|
|
)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// FindLiked 根据对象id获取点赞信息
|
|
func FindLikesByObjIDS(lType string, uid uint64, CIDs []primitive.ObjectID) (data []Like, err error) {
|
|
query := bson.M{"userID": uid, "type": lType, "objID": bson.M{"$in": CIDs}}
|
|
err = coll(nil).Find(&data, query)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindLikesByObjIDS", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
log.Any("lType", lType),
|
|
log.Any("CIDs", CIDs),
|
|
)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// FindLiked 根据对象id获取点赞信息
|
|
func FindLikesByTypeAndUID(lType string, uid uint64, pageNumber int, pageSize int) (data []LikeOIDRes, hasNext bool, err error) {
|
|
query := bson.M{"userID": uid, "type": lType}
|
|
skip := int64(pageSize * (pageNumber - 1))
|
|
limit := int64(pageSize + 1)
|
|
opts := options.FindOptions{
|
|
Skip: &skip,
|
|
Limit: &limit,
|
|
Sort: bson.D{{"createdAt", -1}},
|
|
Projection: bson.M{"_id": 0, "objID": 1},
|
|
}
|
|
err = coll(nil).Find(&data, query, &opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindLikesByTypeAndUID", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
log.Any("lType", lType),
|
|
)
|
|
return
|
|
}
|
|
if len(data) > pageSize {
|
|
hasNext = true
|
|
data = data[:pageSize]
|
|
}
|
|
return
|
|
}
|
|
|
|
// 从给定的uniq列表中获取like状态映射:uniq->Statue
|
|
// uniq通过uniq()获取
|
|
func LikeStatueMap(uniqList []string) (map[string]bool, error) {
|
|
filter := bson.M{
|
|
"uniq": bson.M{"$in": uniqList},
|
|
}
|
|
existLikeList := make([]Like, 0, len(uniqList))
|
|
err := coll(nil).Find(&existLikeList, filter)
|
|
if err != nil {
|
|
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
|
|
}
|
|
|
|
// LLCount 喜欢总数
|
|
func FindLikeIDSByTypeAndUID(lType string, uid uint64) (like []*SimpleRes, err error) {
|
|
opts := options.Find()
|
|
opts.SetProjection(bson.M{"objID": 1})
|
|
err = coll(nil).Find(&like, bson.M{"userID": uid, "type": lType}, opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindLikeIDSByTypeAndUID", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
log.Any("lType", lType),
|
|
)
|
|
}
|
|
return
|
|
}
|
|
|
|
// IsLikeVideos 是否点赞批量查询
|
|
func IsLikeVideos(uid uint64, videoIDs []primitive.ObjectID) (map[primitive.ObjectID]bool, error) {
|
|
m := make(map[primitive.ObjectID]bool)
|
|
videoIDs = uniqueVideoIDs(videoIDs)
|
|
if len(videoIDs) == 0 {
|
|
return m, nil
|
|
}
|
|
|
|
var infos []Like
|
|
cond := likeVideoStatusFilter(uid, videoIDs)
|
|
opts := options.Find().SetProjection(bson.M{"_id": 0, "objID": 1})
|
|
err := coll(nil).Find(&infos, cond, opts)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsLikeVideos", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
log.Any("videoIDs", videoIDs),
|
|
)
|
|
return m, err
|
|
}
|
|
for _, i := range infos {
|
|
m[i.ObjID] = true
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func likeVideoStatusFilter(uid uint64, videoIDs []primitive.ObjectID) bson.M {
|
|
return bson.M{
|
|
"userID": uid,
|
|
"type": bson.M{"$in": []string{
|
|
constant.LikeTypeSP,
|
|
constant.LikeTypeShort,
|
|
constant.LikeTypeCover,
|
|
constant.LikeTypePic,
|
|
constant.LikeTypeSEED_LINK,
|
|
constant.LikeTypeAiPlaza,
|
|
}},
|
|
"objID": bson.M{"$in": videoIDs},
|
|
}
|
|
}
|
|
|
|
func uniqueVideoIDs(ids []primitive.ObjectID) []primitive.ObjectID {
|
|
if len(ids) < 2 {
|
|
return ids
|
|
}
|
|
seen := make(map[primitive.ObjectID]struct{}, len(ids))
|
|
unique := make([]primitive.ObjectID, 0, len(ids))
|
|
for _, id := range ids {
|
|
if _, ok := seen[id]; ok {
|
|
continue
|
|
}
|
|
seen[id] = struct{}{}
|
|
unique = append(unique, id)
|
|
}
|
|
return unique
|
|
}
|
|
|
|
func ListByLikedUserID(uid uint64, skip, limit int64) ([]Like, error) {
|
|
likedUserID := LikedUserIDMatch{&uid}
|
|
sort := bson.D{{"createdAt", -1}}
|
|
return List(sort, skip, limit, likedUserID.New())
|
|
}
|
|
|
|
func GetImageLikeList(uid uint64, skip, limit int64) (out []*Like, err error) {
|
|
filter := bson.M{"userID": uid, "type": "image"}
|
|
if err = coll(nil).Find(&out, filter, options.Find().SetSkip(skip).SetLimit(limit).SetSort(bson.M{"createdAt": -1})); err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetImageLikeList", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
log.Any("skip", skip),
|
|
log.Any("limit", limit),
|
|
)
|
|
return nil, err
|
|
}
|
|
return
|
|
}
|
|
|
|
// IsLikeByType 是否点赞批量查询
|
|
func IsLikeByType(uid uint64, typ []string, IDS []primitive.ObjectID) (map[primitive.ObjectID]bool, error) {
|
|
m := make(map[primitive.ObjectID]bool)
|
|
var infos []Like
|
|
cond := bson.M{"userID": uid, "type": bson.M{"$in": typ}, "objID": bson.M{"$in": IDS}}
|
|
err := coll(nil).Find(&infos, cond)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsLikeByType", table, "Find", err),
|
|
log.Any("uid", uid),
|
|
log.Any("IDS", IDS),
|
|
)
|
|
return m, err
|
|
}
|
|
for _, i := range infos {
|
|
m[i.ObjID] = true
|
|
}
|
|
return m, nil
|
|
}
|