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.
110 lines
2.8 KiB
110 lines
2.8 KiB
package mgo
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
|
|
"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
|
|
"github.com/openimsdk/tools/errs"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
)
|
|
|
|
func NewGroupMuteMongo(db *mongo.Database) (database.GroupMute, error) {
|
|
coll := db.Collection(database.GroupMuteName)
|
|
_, err := coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{
|
|
Keys: bson.D{
|
|
{Key: "owner_user_id", Value: 1},
|
|
{Key: "group_id", Value: 1},
|
|
},
|
|
Options: options.Index().SetUnique(true),
|
|
})
|
|
if err != nil {
|
|
return nil, errs.Wrap(err)
|
|
}
|
|
return &GroupMuteMgo{coll: coll}, nil
|
|
}
|
|
|
|
type GroupMuteMgo struct {
|
|
coll *mongo.Collection
|
|
}
|
|
|
|
func (g *GroupMuteMgo) Upsert(ctx context.Context, mute *model.GroupMute) error {
|
|
if mute.CreateTime.IsZero() {
|
|
mute.CreateTime = time.Now()
|
|
}
|
|
filter := bson.M{
|
|
"owner_user_id": mute.OwnerUserID,
|
|
"group_id": mute.GroupID,
|
|
}
|
|
update := bson.M{
|
|
"$set": bson.M{
|
|
"mute_end_time": mute.MuteEndTime,
|
|
"mute_duration": mute.MuteDuration,
|
|
},
|
|
"$setOnInsert": bson.M{
|
|
"owner_user_id": mute.OwnerUserID,
|
|
"group_id": mute.GroupID,
|
|
"create_time": mute.CreateTime,
|
|
},
|
|
}
|
|
_, err := g.coll.UpdateOne(ctx, filter, update, options.Update().SetUpsert(true))
|
|
return errs.Wrap(err)
|
|
}
|
|
|
|
func (g *GroupMuteMgo) Delete(ctx context.Context, ownerUserID, groupID string) error {
|
|
_, err := g.coll.DeleteOne(ctx, bson.M{
|
|
"owner_user_id": ownerUserID,
|
|
"group_id": groupID,
|
|
})
|
|
return errs.Wrap(err)
|
|
}
|
|
|
|
func (g *GroupMuteMgo) ListActiveMutedUserIDs(ctx context.Context, groupID string, candidateUserIDs []string) ([]string, error) {
|
|
if len(candidateUserIDs) == 0 {
|
|
return nil, nil
|
|
}
|
|
now := time.Now().Unix()
|
|
filter := bson.M{
|
|
"group_id": groupID,
|
|
"owner_user_id": bson.M{"$in": candidateUserIDs},
|
|
"$or": bson.A{
|
|
bson.M{"mute_end_time": 0},
|
|
bson.M{"mute_end_time": bson.M{"$gt": now}},
|
|
},
|
|
}
|
|
cur, err := g.coll.Find(ctx, filter, options.Find().SetProjection(bson.M{"owner_user_id": 1, "_id": 0}))
|
|
if err != nil {
|
|
return nil, errs.Wrap(err)
|
|
}
|
|
defer cur.Close(ctx)
|
|
var out []string
|
|
for cur.Next(ctx) {
|
|
var doc struct {
|
|
OwnerUserID string `bson:"owner_user_id"`
|
|
}
|
|
if err := cur.Decode(&doc); err != nil {
|
|
return nil, errs.Wrap(err)
|
|
}
|
|
out = append(out, doc.OwnerUserID)
|
|
}
|
|
return out, cur.Err()
|
|
}
|
|
|
|
func (g *GroupMuteMgo) Get(ctx context.Context, ownerUserID, groupID string) (*model.GroupMute, error) {
|
|
var out model.GroupMute
|
|
err := g.coll.FindOne(ctx, bson.M{
|
|
"owner_user_id": ownerUserID,
|
|
"group_id": groupID,
|
|
}).Decode(&out)
|
|
if err != nil {
|
|
if err == mongo.ErrNoDocuments {
|
|
return nil, nil
|
|
}
|
|
return nil, errs.Wrap(err)
|
|
}
|
|
return &out, nil
|
|
}
|