239 lines
6.9 KiB
Go
239 lines
6.9 KiB
Go
package modulevidmod
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"91porn-server/common"
|
|
"91porn-server/common/db"
|
|
"91porn-server/models"
|
|
"91porn-server/models/commod"
|
|
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
)
|
|
|
|
var mdb *db.MongoDB
|
|
|
|
const table = models.SectionVideo
|
|
|
|
// InitIndex 设置index
|
|
func initIndex() {
|
|
many := []mongo.IndexModel{
|
|
{
|
|
Keys: bson.D{{Key: "sectionID", Value: 1}, {Key: "videoID", Value: 1}},
|
|
Options: options.Index().SetUnique(true),
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "sectionID", Value: 1}, {Key: "sortCode", Value: -1}, {Key: "videoReviewedAt", Value: -1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "sectionID", Value: 1}, {Key: "newsType", Value: 1}, {Key: "sortCode", Value: -1}, {Key: "videoReviewedAt", Value: -1}},
|
|
},
|
|
// 改类型的时候，需要根据videoID变更newsType
|
|
{
|
|
Keys: bson.D{{Key: "videoID", Value: 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{{Key: "sectionID", Value: 1}, {Key: "createdAt", Value: -1}},
|
|
},
|
|
}
|
|
if _, err := coll(nil).CreateIndex(many); err != nil {
|
|
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
|
|
}
|
|
}
|
|
|
|
func coll(t *db.MongoTool) *db.MongoTool {
|
|
if t == nil {
|
|
return mdb.Coll(table)
|
|
}
|
|
return t.Coll(table)
|
|
}
|
|
|
|
// InsertOne 插入一条数据
|
|
func InsertOne(p *SectionVideo) error {
|
|
p.CreatedAt = time.Now()
|
|
_, err := coll(nil).InsertOne(p)
|
|
return err
|
|
}
|
|
|
|
func UpdateNewsTypeByVideoID(videoID primitive.ObjectID, newsType string) (err error) {
|
|
filter := bson.M{"videoID": videoID}
|
|
_, err = coll(nil).UpdateOne(filter, bson.M{"$set": bson.M{"newsType": newsType}})
|
|
return err
|
|
}
|
|
|
|
// UpdateOne 更新一条数据
|
|
func UpdateOne(set *EditSelector) error {
|
|
set.UpdatedAt = time.Now()
|
|
var filter primitive.M
|
|
if set.ID != nil && !set.ID.IsZero() {
|
|
filter = bson.M{"_id": set.ID}
|
|
} else if set.SectionID != nil && !set.SectionID.IsZero() && set.VideoID != nil && !set.VideoID.IsZero() {
|
|
filter = bson.M{"sectionID": set.SectionID, "videoID": set.VideoID}
|
|
}
|
|
_, err := coll(nil).UpdateOne(filter, bson.M{"$set": set})
|
|
return err
|
|
}
|
|
|
|
// DeleteOne 删除一条数据
|
|
func DeleteOne(id primitive.ObjectID) (err error) {
|
|
_, err = coll(nil).DeleteById(id)
|
|
return
|
|
}
|
|
|
|
// BatchDeleteVideo 批量删除专题下视频
|
|
func BatchDeleteVideo(ctx context.Context, sectionID primitive.ObjectID, vids []primitive.ObjectID) error {
|
|
_, err := coll(nil).DeleteMany(bson.M{"sectionID": sectionID, "videoID": bson.M{"$in": vids}})
|
|
return err
|
|
}
|
|
|
|
// DeleteManyVideo 批量删除专题下视频
|
|
func DeleteManyVideo(ids []primitive.ObjectID) error {
|
|
_, err := coll(nil).DeleteMany(bson.M{"_id": bson.M{"$in": ids}})
|
|
return err
|
|
}
|
|
|
|
// DeleteManyByVids 批量删除专题下视频,根据视频ID
|
|
func DeleteManyByVids(vids []primitive.ObjectID) error {
|
|
_, err := coll(nil).DeleteMany(bson.M{"videoID": bson.M{"$in": vids}})
|
|
return err
|
|
}
|
|
|
|
// Search 根据条件检索
|
|
func Search(q *QuerySelector, page commod.Page) (videos []SectionVideo, hasNext bool, total int64, err error) {
|
|
filter, err := common.ToBsonM(q)
|
|
if err != nil {
|
|
return
|
|
}
|
|
skip := int64(page.Skip())
|
|
limit := int64(page.Limit() + 1)
|
|
opts := options.FindOptions{
|
|
Skip: &skip,
|
|
Limit: &limit,
|
|
Sort: page.GetSort(),
|
|
}
|
|
if err = coll(nil).Find(&videos, filter, &opts); err != nil {
|
|
return
|
|
}
|
|
total, err = coll(nil).Count(filter)
|
|
if uint64(len(videos)) > page.Limit() {
|
|
hasNext = true
|
|
videos = videos[:page.Limit()]
|
|
}
|
|
return
|
|
}
|
|
|
|
// Find 查询所有
|
|
func Find(filter primitive.M, opts ...*options.FindOptions) ([]SectionVideo, error) {
|
|
var videos []SectionVideo
|
|
return videos, coll(nil).Find(&videos, filter, opts...)
|
|
}
|
|
|
|
func GetBySectionIDWithPage(sectionID primitive.ObjectID, page commod.Page) (videoIDs []primitive.ObjectID, hasNext bool, err error) {
|
|
projection := bson.D{
|
|
{Key: "_id", Value: 0},
|
|
{Key: "videoID", Value: 1},
|
|
}
|
|
opts := options.FindOptions{}
|
|
size := page.Limit()
|
|
opts.SetProjection(projection).SetSort(page.GetSort()).SetSkip(int64(page.Skip())).SetLimit(int64(size + 1))
|
|
var p []struct {
|
|
VideoID primitive.ObjectID `bson:"videoID"`
|
|
}
|
|
if err = coll(nil).Find(&p, bson.M{"sectionID": sectionID}, &opts); err != nil {
|
|
return
|
|
}
|
|
if uint64(len(p)) > size {
|
|
hasNext = true
|
|
p = p[:size]
|
|
}
|
|
videoIDs = make([]primitive.ObjectID, len(p))
|
|
for i, v := range p {
|
|
videoIDs[i] = v.VideoID
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetSectionVideosBySectionID 根据专题获取视频列表
|
|
func GetSectionVideosBySectionID(sectionID primitive.ObjectID) (list []SectionVideo, err error) {
|
|
err = coll(nil).Find(&list, bson.M{"sectionID": sectionID}, options.Find().SetSort(bson.D{{Key: "sortCode", Value: -1}, {Key: "videoReviewedAt", Value: -1}}))
|
|
return
|
|
}
|
|
|
|
// SectionVideosBySectionID 根据专题获取视频列表
|
|
func SectionVideosBySectionID(sectionID primitive.ObjectID, opts *options.FindOptions) ([]SectionVideo, error) {
|
|
var out []SectionVideo
|
|
return out, coll(nil).Find(&out, bson.M{"sectionID": sectionID}, opts)
|
|
}
|
|
|
|
func GetVideosBySectionIDs(sectionIDs []primitive.ObjectID) (list []SectionVideo, err error) {
|
|
err = coll(nil).Find(&list, bson.M{"sectionID": bson.M{"$in": sectionIDs}})
|
|
return
|
|
}
|
|
|
|
// GetSectionVideosBySectionIDSort 根据专题获取视频列表
|
|
func GetSectionVideosBySectionIDSort(sectionID primitive.ObjectID, limit int64) (list []SectionVideo, err error) {
|
|
err = coll(nil).Find(&list, bson.M{"sectionID": sectionID}, options.Find().SetSort(bson.D{{Key: "SortCode", Value: -1}}).SetLimit(limit))
|
|
return
|
|
}
|
|
|
|
func GetBySectionIDAndVids(sectionID primitive.ObjectID, vids []primitive.ObjectID) (videos []SectionVideo, err error) {
|
|
filter := bson.M{"videoID": bson.M{"$in": vids}}
|
|
if !sectionID.IsZero() {
|
|
filter["sectionID"] = sectionID
|
|
}
|
|
err = coll(nil).Find(&videos, filter)
|
|
return
|
|
}
|
|
|
|
func GetBySectionID(sectionID primitive.ObjectID, isSorted bool) (videoIDs []primitive.ObjectID, err error) {
|
|
projection := bson.D{
|
|
{Key: "_id", Value: 0},
|
|
{Key: "videoID", Value: 1},
|
|
}
|
|
opts := options.FindOptions{}
|
|
opts.SetProjection(projection)
|
|
var p []struct {
|
|
VideoID primitive.ObjectID `bson:"videoID"`
|
|
}
|
|
filter := bson.M{"sectionID": sectionID}
|
|
if isSorted {
|
|
filter["sortCode"] = bson.M{"$gt": 0}
|
|
opts.SetSort(bson.D{{Key: "sortCode", Value: -1}, {Key: "videoReviewedAt", Value: -1}})
|
|
}
|
|
if err = coll(nil).Find(&p, filter, &opts); err != nil {
|
|
return
|
|
}
|
|
videoIDs = make([]primitive.ObjectID, len(p))
|
|
for i, v := range p {
|
|
videoIDs[i] = v.VideoID
|
|
}
|
|
return
|
|
}
|
|
|
|
func InsertMany(records []SectionVideo) error {
|
|
opts := options.InsertMany().SetOrdered(false)
|
|
_, err := coll(nil).InsertMany(records, opts)
|
|
if !db.IsMongoDupKey(err) {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GetSectionsByVideoId(id primitive.ObjectID) ([]SectionVideo, error) {
|
|
if id.IsZero() {
|
|
return nil, nil
|
|
}
|
|
var svs []SectionVideo
|
|
return svs, coll(nil).Find(&svs, bson.M{"videoID": id})
|
|
}
|
|
|
|
func GetSectionsByVideoIds(ids []primitive.ObjectID) ([]SectionVideo, error) {
|
|
var svs []SectionVideo
|
|
return svs, coll(nil).Find(&svs, bson.M{"videoID": bson.M{"$in": ids}})
|
|
}
|