Merge remote-tracking branch 'origin/errcode' into errcode

pkg/common/db/cache/group.go

@@ -22,11 +22,7 @@ type GroupCache struct {
 }
 
 func NewGroupCache(rdb redis.UniversalClient, db mysql.GroupModelInterface, opts rockscache.Options) *GroupCache {
-	rcClient := &rockscache.Client{
-		Options: rockscache.Options{},
-	}
-	redisClient := NewRedisClient(rdb)
-	return &GroupCache{rcClient: rcClient, expireTime: GroupExpireTime, db: db, redisClient: redisClient}
+	return &GroupCache{rcClient: rockscache.NewClient(rdb, opts), expireTime: GroupExpireTime, db: db, redisClient: NewRedisClient(rdb)}
 }
 
 func (g *GroupCache) getRedisClient() *RedisClient {

pkg/common/db/model/black.go

@@ -0,0 +1,52 @@
+package model
+
+import (
+	"Open_IM/pkg/common/db/cache"
+	"Open_IM/pkg/common/db/mysql"
+	"context"
+	"errors"
+	"gorm.io/gorm"
+)
+
+type BlackModel struct {
+	db    *mysql.Black
+	cache *cache.GroupCache
+}
+
+func (b *BlackModel) Create(ctx context.Context, blacks []*mysql.Black) (err error) {
+	return b.db.Create(ctx, blacks)
+}
+
+func (b *BlackModel) Delete(ctx context.Context, blacks []*mysql.Black) (err error) {
+	return b.db.Delete(ctx, blacks)
+}
+
+func (b *BlackModel) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
+	return b.db.UpdateByMap(ctx, ownerUserID, blockUserID, args)
+}
+
+func (b *BlackModel) Update(ctx context.Context, blacks []*mysql.Black) (err error) {
+	return b.db.Update(ctx, blacks)
+}
+
+func (b *BlackModel) Find(ctx context.Context, blacks []*mysql.Black) (blackList []*mysql.Black, err error) {
+	return b.db.Find(ctx, blacks)
+}
+
+func (b *BlackModel) Take(ctx context.Context, ownerUserID, blockUserID string) (black *mysql.Black, err error) {
+	return b.db.Take(ctx, ownerUserID, blockUserID)
+}
+
+func (b *BlackModel) FindByOwnerUserID(ctx context.Context, ownerUserID string) (blackList []*mysql.Black, err error) {
+	return b.db.FindByOwnerUserID(ctx, ownerUserID)
+}
+
+func (b *BlackModel) IsExist(ctx context.Context, ownerUserID, blockUserID string) (bool, error) {
+	if _, err := b.Take(ctx, ownerUserID, blockUserID); err == nil {
+		return true, nil
+	} else if errors.Is(err, gorm.ErrRecordNotFound) {
+		return false, nil
+	} else {
+		return false, err
+	}
+}

pkg/common/db/model/friend.go

@@ -0,0 +1,60 @@
+package model
+
+import (
+	"Open_IM/pkg/common/db/cache"
+	"Open_IM/pkg/common/db/mysql"
+	"context"
+	"errors"
+	"gorm.io/gorm"
+)
+
+type FriendModel struct {
+	db    *mysql.Friend
+	cache *cache.GroupCache
+}
+
+func (f *FriendModel) Create(ctx context.Context, friends []*mysql.Friend) (err error) {
+	return f.db.Create(ctx, friends)
+}
+
+func (f *FriendModel) Delete(ctx context.Context, ownerUserID string, friendUserIDs string) (err error) {
+	return f.db.Delete(ctx, ownerUserID, friendUserIDs)
+}
+
+func (f *FriendModel) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
+	return f.db.UpdateByMap(ctx, ownerUserID, args)
+}
+
+func (f *FriendModel) Update(ctx context.Context, friends []*mysql.Friend) (err error) {
+	return f.db.Update(ctx, friends)
+}
+
+func (f *FriendModel) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) (err error) {
+	return f.db.UpdateRemark(ctx, ownerUserID, friendUserID, remark)
+}
+
+func (f *FriendModel) FindOwnerUserID(ctx context.Context, ownerUserID string) (friends []*mysql.Friend, err error) {
+	return f.db.FindOwnerUserID(ctx, ownerUserID)
+}
+
+func (f *FriendModel) FindFriendUserID(ctx context.Context, friendUserID string) (friends []*mysql.Friend, err error) {
+	return f.db.FindFriendUserID(ctx, friendUserID)
+}
+
+func (f *FriendModel) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *mysql.Friend, err error) {
+	return f.db.Take(ctx, ownerUserID, friendUserID)
+}
+
+func (f *FriendModel) FindUserState(ctx context.Context, userID1, userID2 string) (friends []*mysql.Friend, err error) {
+	return f.db.FindUserState(ctx, userID1, userID2)
+}
+
+func (f *FriendModel) IsExist(ctx context.Context, ownerUserID, friendUserID string) (bool, error) {
+	if _, err := f.Take(ctx, ownerUserID, friendUserID); err == nil {
+		return true, nil
+	} else if errors.Is(err, gorm.ErrRecordNotFound) {
+		return false, nil
+	} else {
+		return false, err
+	}
+}

pkg/common/db/model/friend_request.go

@@ -0,0 +1,44 @@
+package model
+
+import (
+	"Open_IM/pkg/common/db/cache"
+	"Open_IM/pkg/common/db/mysql"
+	"context"
+)
+
+type FriendRequestModel struct {
+	db    *mysql.FriendRequest
+	cache *cache.GroupCache
+}
+
+func (f *FriendRequestModel) Create(ctx context.Context, friends []*mysql.FriendRequest) (err error) {
+	return f.db.Create(ctx, friends)
+}
+
+func (f *FriendRequestModel) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
+	return f.db.Delete(ctx, fromUserID, toUserID)
+}
+
+func (f *FriendRequestModel) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
+	return f.db.UpdateByMap(ctx, ownerUserID, args)
+}
+
+func (f *FriendRequestModel) Update(ctx context.Context, friends []*mysql.FriendRequest) (err error) {
+	return f.db.Update(ctx, friends)
+}
+
+func (f *FriendRequestModel) Find(ctx context.Context, ownerUserID string) (friends []*mysql.FriendRequest, err error) {
+	return f.db.Find(ctx, ownerUserID)
+}
+
+func (f *FriendRequestModel) Take(ctx context.Context, fromUserID, toUserID string) (friend *mysql.FriendRequest, err error) {
+	return f.db.Take(ctx, fromUserID, toUserID)
+}
+
+func (f *FriendRequestModel) FindToUserID(ctx context.Context, toUserID string) (friends []*mysql.FriendRequest, err error) {
+	return f.db.FindToUserID(ctx, toUserID)
+}
+
+func (f *FriendRequestModel) FindFromUserID(ctx context.Context, fromUserID string) (friends []*mysql.FriendRequest, err error) {
+	return f.db.FindFromUserID(ctx, fromUserID)
+}

pkg/common/db/model/group.go

@@ -32,6 +32,8 @@ func NewGroupModel(db mysql.GroupModelInterface, rdb redis.UniversalClient, mdb
 		DisableCacheRead:  false,
 		StrongConsistency: true,
 	})
+	sg := mdb.Database().Collection()
+	sg.Find()
 	groupModel.mongo = mongoDB.NewMongoClient(mdb)
 	return &groupModel
 }
@@ -60,3 +62,20 @@ func (g *GroupModel) Delete(ctx context.Context, groupIDs []string) error {
 func (g *GroupModel) Take(ctx context.Context, groupID string) (group *mysql.Group, err error) {
 	return g.cache.GetGroupInfoFromCache(ctx, groupID)
 }
+
+func (g *GroupModel) Update(ctx context.Context, groups []*mysql.Group) error {
+	err := g.db.DB.Transaction(func(tx *gorm.DB) error {
+		if err := g.db.Update(ctx, groups, tx); err != nil {
+			return err
+		}
+		var groupIDs []string
+		for _, group := range groups {
+			groupIDs = append(groupIDs, group.GroupID)
+		}
+		if err := g.cache.DelGroupsInfoFromCache(ctx, groupIDs); err != nil {
+			return err
+		}
+		return nil
+	})
+	return err
+}

pkg/common/db/mongoDB/super_group.go

@@ -1,5 +1,11 @@
 package mongoDB
 
+import (
+	"Open_IM/pkg/utils"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
 type SuperGroup struct {
 	GroupID      string   `bson:"group_id" json:"groupID"`
 	MemberIDList []string `bson:"member_id_list" json:"memberIDList"`
@@ -9,3 +15,167 @@ type UserToSuperGroup struct {
 	UserID      string   `bson:"user_id" json:"userID"`
 	GroupIDList []string `bson:"group_id_list" json:"groupIDList"`
 }
+
+func New
+
+func (d *db.DataBases) CreateSuperGroup(groupID string, initMemberIDList []string, memberNumCount int) error {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cSuperGroup)
+	session, err := d.mongoClient.StartSession()
+	if err != nil {
+		return utils.Wrap(err, "start session failed")
+	}
+	defer session.EndSession(ctx)
+	sCtx := mongo.NewSessionContext(ctx, session)
+	superGroup := SuperGroup{
+		GroupID:      groupID,
+		MemberIDList: initMemberIDList,
+	}
+	_, err = c.InsertOne(sCtx, superGroup)
+	if err != nil {
+		_ = session.AbortTransaction(ctx)
+		return utils.Wrap(err, "transaction failed")
+	}
+	var users []UserToSuperGroup
+	for _, v := range initMemberIDList {
+		users = append(users, UserToSuperGroup{
+			UserID: v,
+		})
+	}
+	upsert := true
+	opts := &options.UpdateOptions{
+		Upsert: &upsert,
+	}
+	c = d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cUserToSuperGroup)
+	//_, err = c.UpdateMany(sCtx, bson.M{"user_id": bson.M{"$in": initMemberIDList}}, bson.M{"$addToSet": bson.M{"group_id_list": groupID}}, opts)
+	//if err != nil {
+	//	session.AbortTransaction(ctx)
+	//	return utils.Wrap(err, "transaction failed")
+	//}
+	for _, userID := range initMemberIDList {
+		_, err = c.UpdateOne(sCtx, bson.M{"user_id": userID}, bson.M{"$addToSet": bson.M{"group_id_list": groupID}}, opts)
+		if err != nil {
+			_ = session.AbortTransaction(ctx)
+			return utils.Wrap(err, "transaction failed")
+		}
+
+	}
+	return err
+}
+
+func (d *db.DataBases) GetSuperGroup(groupID string) (SuperGroup, error) {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cSuperGroup)
+	superGroup := SuperGroup{}
+	err := c.FindOne(ctx, bson.M{"group_id": groupID}).Decode(&superGroup)
+	return superGroup, err
+}
+
+func (d *db.DataBases) AddUserToSuperGroup(groupID string, userIDList []string) error {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cSuperGroup)
+	session, err := d.mongoClient.StartSession()
+	if err != nil {
+		return utils.Wrap(err, "start session failed")
+	}
+	defer session.EndSession(ctx)
+	sCtx := mongo.NewSessionContext(ctx, session)
+	if err != nil {
+		return utils.Wrap(err, "start transaction failed")
+	}
+	_, err = c.UpdateOne(sCtx, bson.M{"group_id": groupID}, bson.M{"$addToSet": bson.M{"member_id_list": bson.M{"$each": userIDList}}})
+	if err != nil {
+		_ = session.AbortTransaction(ctx)
+		return utils.Wrap(err, "transaction failed")
+	}
+	c = d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cUserToSuperGroup)
+	var users []UserToSuperGroup
+	for _, v := range userIDList {
+		users = append(users, UserToSuperGroup{
+			UserID: v,
+		})
+	}
+	upsert := true
+	opts := &options.UpdateOptions{
+		Upsert: &upsert,
+	}
+	for _, userID := range userIDList {
+		_, err = c.UpdateOne(sCtx, bson.M{"user_id": userID}, bson.M{"$addToSet": bson.M{"group_id_list": groupID}}, opts)
+		if err != nil {
+			_ = session.AbortTransaction(ctx)
+			return utils.Wrap(err, "transaction failed")
+		}
+	}
+	_ = session.CommitTransaction(ctx)
+	return err
+}
+
+func (d *db.DataBases) RemoverUserFromSuperGroup(groupID string, userIDList []string) error {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cSuperGroup)
+	session, err := d.mongoClient.StartSession()
+	if err != nil {
+		return utils.Wrap(err, "start session failed")
+	}
+	defer session.EndSession(ctx)
+	sCtx := mongo.NewSessionContext(ctx, session)
+	_, err = c.UpdateOne(ctx, bson.M{"group_id": groupID}, bson.M{"$pull": bson.M{"member_id_list": bson.M{"$in": userIDList}}})
+	if err != nil {
+		_ = session.AbortTransaction(ctx)
+		return utils.Wrap(err, "transaction failed")
+	}
+	err = d.RemoveGroupFromUser(ctx, sCtx, groupID, userIDList)
+	if err != nil {
+		_ = session.AbortTransaction(ctx)
+		return utils.Wrap(err, "transaction failed")
+	}
+	_ = session.CommitTransaction(ctx)
+	return err
+}
+
+func (d *db.DataBases) GetSuperGroupByUserID(userID string) (UserToSuperGroup, error) {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cUserToSuperGroup)
+	var user UserToSuperGroup
+	_ = c.FindOne(ctx, bson.M{"user_id": userID}).Decode(&user)
+	return user, nil
+}
+
+func (d *db.DataBases) DeleteSuperGroup(groupID string) error {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cSuperGroup)
+	session, err := d.mongoClient.StartSession()
+	if err != nil {
+		return utils.Wrap(err, "start session failed")
+	}
+	defer session.EndSession(ctx)
+	sCtx := mongo.NewSessionContext(ctx, session)
+	superGroup := &SuperGroup{}
+	result := c.FindOneAndDelete(sCtx, bson.M{"group_id": groupID})
+	err = result.Decode(superGroup)
+	if err != nil {
+		session.AbortTransaction(ctx)
+		return utils.Wrap(err, "transaction failed")
+	}
+	if err = d.RemoveGroupFromUser(ctx, sCtx, groupID, superGroup.MemberIDList); err != nil {
+		session.AbortTransaction(ctx)
+		return utils.Wrap(err, "transaction failed")
+	}
+	session.CommitTransaction(ctx)
+	return nil
+}
+
+func (d *db.DataBases) RemoveGroupFromUser(ctx, sCtx context.Context, groupID string, userIDList []string) error {
+	var users []UserToSuperGroup
+	for _, v := range userIDList {
+		users = append(users, UserToSuperGroup{
+			UserID: v,
+		})
+	}
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cUserToSuperGroup)
+	_, err := c.UpdateOne(sCtx, bson.M{"user_id": bson.M{"$in": userIDList}}, bson.M{"$pull": bson.M{"group_id_list": groupID}})
+	if err != nil {
+		return utils.Wrap(err, "UpdateOne transaction failed")
+	}
+	return err
+}

pkg/common/db/mysql/black.go

@@ -52,7 +52,7 @@ func (b *Black) Update(ctx context.Context, blacks []*Black) (err error) {
 	return utils.Wrap(b.DB.Updates(&blacks).Error, "")
 }
 
-func (b *Black) Find(ctx context.Context, blacks []Black) (blackList []*Black, err error) {
+func (b *Black) Find(ctx context.Context, blacks []*Black) (blackList []*Black, err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks, "blackList", blackList)
 	}()
@@ -63,12 +63,12 @@ func (b *Black) Find(ctx context.Context, blacks []Black) (blackList []*Black, e
 	return blackList, utils.Wrap(GroupMemberDB.Where("(owner_user_id, block_user_id) in ?", where).Find(&blackList).Error, "")
 }
 
-func (b *Black) Take(ctx context.Context, blackID string) (black *Black, err error) {
+func (b *Black) Take(ctx context.Context, ownerUserID, blockUserID string) (black *Black, err error) {
 	black = &Black{}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blackID", blackID, "black", *black)
+		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "black", *black)
 	}()
-	return black, utils.Wrap(b.DB.Where("black_id = ?", blackID).Take(black).Error, "")
+	return black, utils.Wrap(b.DB.Where("owner_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Take(black).Error, "")
 }
 
 func (b *Black) FindByOwnerUserID(ctx context.Context, ownerUserID string) (blackList []*Black, err error) {

pkg/common/db/mysql/friend_model_k.go

@@ -61,13 +61,20 @@ func (f *Friend) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, re
 	return utils.Wrap(f.DB.Model(f).Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "")
 }
 
-func (f *Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) {
+func (f *Friend) FindOwnerUserID(ctx context.Context, ownerUserID string) (friends []*Friend, err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
 	}()
 	return friends, utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
 }
 
+func (f *Friend) FindFriendUserID(ctx context.Context, friendUserID string) (friends []*Friend, err error) {
+	defer func() {
+		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friendUserID", friendUserID, "friends", friends)
+	}()
+	return friends, utils.Wrap(f.DB.Where("friend_user_id = ?", friendUserID).Find(&friends).Error, "")
+}
+
 func (f *Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err error) {
 	friend = &Friend{}
 	defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "friend", friend)

pkg/common/db/mysql/friend_request_model.go

@@ -33,16 +33,14 @@ func (f *FriendRequest) Create(ctx context.Context, friends []*FriendRequest) (e
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
 	}()
-	err = utils.Wrap(f.DB.Create(&friends).Error, "")
-	return err
+	return utils.Wrap(f.DB.Create(&friends).Error, "")
 }
 
 func (f *FriendRequest) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID)
 	}()
-	err = utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Delete(&FriendRequest{}).Error, "")
-	return err
+	return utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Delete(&FriendRequest{}).Error, "")
 }
 
 func (f *FriendRequest) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
@@ -63,15 +61,13 @@ func (f *FriendRequest) Find(ctx context.Context, ownerUserID string) (friends [
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
 	}()
-	err = utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
-	return friends, err
+	return friends, utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
 }
 
 func (f *FriendRequest) Take(ctx context.Context, fromUserID, toUserID string) (friend *FriendRequest, err error) {
 	friend = &FriendRequest{}
 	defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID, "friend", friend)
-	err = utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id", fromUserID, toUserID).Take(friend).Error, "")
-	return friend, err
+	return friend, utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id", fromUserID, toUserID).Take(friend).Error, "")
 }
 
 func (f *FriendRequest) FindToUserID(ctx context.Context, toUserID string) (friends []*FriendRequest, err error) {

pkg/common/db/mysql/group_model_k.go

@@ -9,12 +9,15 @@ import (
 )
 
 type GroupModelInterface interface {
+	//mysql
 	Create(ctx context.Context, groups []*Group) (err error)
 	Delete(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (err error)
 	UpdateByMap(ctx context.Context, groupID string, args map[string]interface{}) (err error)
 	Update(ctx context.Context, groups []*Group) (err error)
 	Find(ctx context.Context, groupIDs []string) (groups []*Group, err error)
 	Take(ctx context.Context, groupID string) (group *Group, err error)
+
+	//mongo
 }
 
 type Group struct {
@@ -65,11 +68,11 @@ func (*Group) UpdateByMap(ctx context.Context, groupID string, args map[string]i
 	return utils.Wrap(GroupDB.Where("group_id = ?", groupID).Updates(args).Error, "")
 }
 
-func (*Group) Update(ctx context.Context, groups []*Group) (err error) {
+func (g *Group) Update(ctx context.Context, groups []*Group, tx ...*gorm.DB) (err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
 	}()
-	return utils.Wrap(GroupDB.Updates(&groups).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx...).Updates(&groups).Error, "")
 }
 
 func (*Group) Find(ctx context.Context, groupIDs []string) (groups []*Group, err error) {

pkg/common/token_verify/jwt_token.go

@@ -173,6 +173,13 @@ func CheckAccessV3(ctx context.Context, OwnerUserID string) (err error) {
 	return constant.ErrIdentity.Wrap(utils.GetSelfFuncName())
 }
 
+func CheckAdmin(ctx context.Context) error {
+	if utils.IsContain(tools.OpUserID(ctx), config.Config.Manager.AppManagerUid) {
+		return nil
+	}
+	return constant.ErrIdentity.Wrap()
+}
+
 func GetUserIDFromToken(token string, operationID string) (bool, string, string) {
 	claims, err := ParseToken(token, operationID)
 	if err != nil {