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

pkg/common/constant/constant.go

@@ -1,21 +1,6 @@
 package constant
 
 const (
-
-	//group admin
-	//	OrdinaryMember = 0
-	//	GroupOwner     = 1
-	//	Administrator  = 2
-	//group application
-	//	Application      = 0
-	//	AgreeApplication = 1
-
-	//friend related
-	BlackListFlag         = 1
-	ApplicationFriendFlag = 0
-	FriendFlag            = 1
-	RefuseFriendFlag      = -1
-
 	//Websocket Protocol
 	WSGetNewestSeq        = 1001
 	WSPullMsgBySeqList    = 1002

pkg/common/constant/err_info.go

@@ -1,10 +1,7 @@
 package constant
 
 import (
-	sdkws "Open_IM/pkg/proto/sdk_ws"
-	"context"
 	"encoding/json"
-	"fmt"
 	"github.com/pkg/errors"
 	"gorm.io/gorm"
 	"strings"
@@ -67,28 +64,3 @@ func ToAPIErrWithErr(err error) *ErrInfo {
 	}
 	return toDetail(err, ErrDefaultOther)
 }
-
-func SetErrorForResp(err error, commonResp *sdkws.CommonResp) {
-	errInfo := ToAPIErrWithErr(err)
-	commonResp.ErrCode = errInfo.ErrCode
-	commonResp.ErrMsg = errInfo.ErrMsg
-	commonResp.DetailErrMsg = err.Error()
-}
-
-func CommonResp2Err(resp *sdkws.CommonResp) error {
-	if resp.ErrCode != NoError {
-		return errors.New(fmt.Sprintf("call rpc error, errCode is %d, errMsg is %s, detailErrMsg is %s", resp.ErrCode, resp.ErrMsg, resp.DetailErrMsg))
-	}
-	return nil
-}
-
-func Error2CommResp(ctx context.Context, info *ErrInfo, detailErrMsg string) *sdkws.CommonResp {
-	err := &sdkws.CommonResp{
-		ErrCode: info.ErrCode,
-		ErrMsg:  info.ErrMsg,
-	}
-	if detailErrMsg != "" {
-		err.DetailErrMsg = detailErrMsg
-	}
-	return err
-}

pkg/common/db/cache/group.go

@@ -1,36 +1,92 @@
 package cache
 
 import (
+	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/relation"
+	"Open_IM/pkg/common/db/unrelation"
 	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/utils"
 	"context"
 	"encoding/json"
 	"github.com/dtm-labs/rockscache"
 	"github.com/go-redis/redis/v8"
+	"math/big"
+	"sort"
+	"strconv"
+	"sync"
 	"time"
 )
 
-const GroupExpireTime = time.Second * 60 * 60 * 12
-const groupInfoCacheKey = "GROUP_INFO_CACHE:"
+const (
+	groupExpireTime      = time.Second * 60 * 60 * 12
+	groupInfoKey         = "GROUP_INFO:"
+	groupMemberIDsKey    = "GROUP_MEMBER_IDS:"
+	groupMembersHashKey  = "GROUP_MEMBERS_HASH:"
+	groupMemberInfoKey   = "GROUP_MEMBER_INFO:"
+	joinedSuperGroupsKey = "JOIN_SUPER_GROUPS:"
+	joinedGroupsKey      = "JOIN_GROUPS_KEY:"
+	groupMemberNumKey    = "GROUP_MEMBER_NUM_CACHE:"
+)
 
 type GroupCache struct {
 	group        *relation.Group
 	groupMember  *relation.GroupMember
 	groupRequest *relation.GroupRequest
+	mongoDB      *unrelation.SuperGroupMgoDB
 	expireTime   time.Duration
 	redisClient  *RedisClient
 	rcClient     *rockscache.Client
+
+	//local cache
+	cacheGroupMtx           sync.RWMutex
+	cacheGroupMemberUserIDs map[string]*GroupMemberIDsHash
 }
 
-func NewGroupCache(rdb redis.UniversalClient, groupDB *relation.Group, groupMemberDB *relation.GroupMember, groupRequestDB *relation.GroupRequest, opts rockscache.Options) *GroupCache {
-	return &GroupCache{rcClient: rockscache.NewClient(rdb, opts), expireTime: GroupExpireTime, group: groupDB, groupMember: groupMemberDB, groupRequest: groupRequestDB, redisClient: NewRedisClient(rdb)}
+type GroupMemberIDsHash struct {
+	MemberListHash uint64
+	UserIDs        []string
+}
+
+func NewGroupCache(rdb redis.UniversalClient, groupDB *relation.Group, groupMemberDB *relation.GroupMember, groupRequestDB *relation.GroupRequest, mongoClient *unrelation.SuperGroupMgoDB, opts rockscache.Options) *GroupCache {
+	return &GroupCache{rcClient: rockscache.NewClient(rdb, opts), expireTime: groupExpireTime,
+		group: groupDB, groupMember: groupMemberDB, groupRequest: groupRequestDB, redisClient: NewRedisClient(rdb),
+		mongoDB: mongoClient, cacheGroupMemberUserIDs: make(map[string]*GroupMemberIDsHash, 0),
+	}
 }
 
 func (g *GroupCache) getRedisClient() *RedisClient {
 	return g.redisClient
 }
 
+func (g *GroupCache) getGroupInfoKey(groupID string) string {
+	return groupInfoKey + groupID
+}
+
+func (g *GroupCache) getJoinedSuperGroupsIDKey(userID string) string {
+	return joinedSuperGroupsKey + userID
+}
+
+func (g *GroupCache) getJoinedGroupsKey(userID string) string {
+	return joinedGroupsKey + userID
+}
+
+func (g *GroupCache) getGroupMembersHashKey(groupID string) string {
+	return groupMembersHashKey + groupID
+}
+
+func (g *GroupCache) getGroupMemberIDsKey(groupID string) string {
+	return groupMemberIDsKey + groupID
+}
+
+func (g *GroupCache) getGroupMemberInfoKey(groupID, userID string) string {
+	return groupMemberInfoKey + groupID + "-" + userID
+}
+
+func (g *GroupCache) getGroupMemberNumKey(groupID string) string {
+	return groupMemberNumKey + groupID
+}
+
+/// groupInfo
 func (g *GroupCache) GetGroupsInfo(ctx context.Context, groupIDs []string) (groups []*relation.Group, err error) {
 	for _, groupID := range groupIDs {
 		group, err := g.GetGroupInfo(ctx, groupID)
@@ -58,9 +114,9 @@ func (g *GroupCache) GetGroupInfo(ctx context.Context, groupID string) (group *r
 	defer func() {
 		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
 	}()
-	groupStr, err := g.rcClient.Fetch(g.getGroupInfoCacheKey(groupID), g.expireTime, getGroup)
+	groupStr, err := g.rcClient.Fetch(g.getGroupInfoKey(groupID), g.expireTime, getGroup)
 	if err != nil {
-		return nil, utils.Wrap(err, "")
+		return nil, err
 	}
 	err = json.Unmarshal([]byte(groupStr), group)
 	return group, utils.Wrap(err, "")
@@ -70,7 +126,7 @@ func (g *GroupCache) DelGroupInfo(ctx context.Context, groupID string) (err erro
 	defer func() {
 		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
 	}()
-	return g.rcClient.TagAsDeleted(g.getGroupInfoCacheKey(groupID))
+	return g.rcClient.TagAsDeleted(g.getGroupInfoKey(groupID))
 }
 
 func (g *GroupCache) DelGroupsInfo(ctx context.Context, groupIDs []string) error {
@@ -82,21 +138,247 @@ func (g *GroupCache) DelGroupsInfo(ctx context.Context, groupIDs []string) error
 	return nil
 }
 
-func (g *GroupCache) getGroupInfoCacheKey(groupID string) string {
-	return groupInfoCacheKey + groupID
-}
-
-func (g *GroupCache) DelJoinedSuperGroupIDs(ctx context.Context, userIDs []string) (err error) {
+// userJoinSuperGroup
+func (g *GroupCache) BatchDelJoinedSuperGroupIDs(ctx context.Context, userIDs []string) (err error) {
 	for _, userID := range userIDs {
-		if err := g.rcClient.TagAsDeleted(joinedSuperGroupListCache + userID); err != nil {
+		if err := g.DelJoinedSuperGroupIDs(ctx, userID); err != nil {
 			return err
 		}
 	}
+	return nil
 }
 
-func (g *GroupCache) DelJoinedSuperGroupID(ctx context.Context, userID string) (err error) {
+func (g *GroupCache) DelJoinedSuperGroupIDs(ctx context.Context, userID string) (err error) {
 	defer func() {
 		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
 	}()
-	return g.rcClient.TagAsDeleted(joinedSuperGroupListCache + userID)
+	return g.rcClient.TagAsDeleted(g.getJoinedSuperGroupsIDKey(userID))
+}
+
+func (g *GroupCache) GetJoinedSuperGroupIDs(ctx context.Context, userID string) (joinedSuperGroupIDs []string, err error) {
+	getJoinedSuperGroupIDList := func() (string, error) {
+		userToSuperGroup, err := g.mongoDB.GetSuperGroupByUserID(ctx, userID)
+		if err != nil {
+			return "", err
+		}
+		bytes, err := json.Marshal(userToSuperGroup.GroupIDList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedSuperGroupIDs", joinedSuperGroupIDs)
+	}()
+	joinedSuperGroupListStr, err := g.rcClient.Fetch(g.getJoinedSuperGroupsIDKey(userID), time.Second*30*60, getJoinedSuperGroupIDList)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal([]byte(joinedSuperGroupListStr), &joinedSuperGroupIDs)
+	return joinedSuperGroupIDs, utils.Wrap(err, "")
+}
+
+// groupMembersHash
+func (g *GroupCache) GetGroupMembersHash(ctx context.Context, groupID string) (hashCodeUint64 uint64, err error) {
+	generateHash := func() (string, error) {
+		groupInfo, err := g.GetGroupInfo(ctx, groupID)
+		if err != nil {
+			return "", err
+		}
+		if groupInfo.Status == constant.GroupStatusDismissed {
+			return "0", nil
+		}
+		groupMemberIDList, err := g.GetGroupMemberIDs(ctx, groupID)
+		if err != nil {
+			return "", err
+		}
+		sort.Strings(groupMemberIDList)
+		var all string
+		for _, v := range groupMemberIDList {
+			all += v
+		}
+		bi := big.NewInt(0)
+		bi.SetString(utils.Md5(all)[0:8], 16)
+		return strconv.Itoa(int(bi.Uint64())), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "hashCodeUint64", hashCodeUint64)
+	}()
+	hashCodeStr, err := g.rcClient.Fetch(g.getGroupMembersHashKey(groupID), time.Second*30*60, generateHash)
+	if err != nil {
+		return 0, utils.Wrap(err, "fetch failed")
+	}
+	hashCode, err := strconv.Atoi(hashCodeStr)
+	return uint64(hashCode), err
+}
+
+func (g *GroupCache) DelGroupMembersHash(ctx context.Context, groupID string) (err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+	}()
+	return g.rcClient.TagAsDeleted(g.getGroupMembersHashKey(groupID))
+}
+
+// groupMemberIDs
+// from redis
+func (g *GroupCache) GetGroupMemberIDs(ctx context.Context, groupID string) (groupMemberIDs []string, err error) {
+	f := func() (string, error) {
+		groupInfo, err := g.GetGroupInfo(ctx, groupID)
+		if err != nil {
+			return "", err
+		}
+		var groupMemberIDList []string
+		if groupInfo.GroupType == constant.SuperGroup {
+			superGroup, err := g.mongoDB.GetSuperGroup(ctx, groupID)
+			if err != nil {
+				return "", err
+			}
+			groupMemberIDList = superGroup.MemberIDList
+		} else {
+			groupMemberIDList, err = relation.GetGroupMemberIDListByGroupID(groupID)
+			if err != nil {
+				return "", err
+			}
+		}
+		bytes, err := json.Marshal(groupMemberIDList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMemberIDList", groupMemberIDs)
+	}()
+	groupIDListStr, err := g.rcClient.Fetch(g.getGroupMemberIDsKey(groupID), time.Second*30*60, f)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal([]byte(groupIDListStr), &groupMemberIDs)
+	return groupMemberIDs, nil
+}
+
+func (g *GroupCache) DelGroupMemberIDs(ctx context.Context, groupID string) (err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+	}()
+	return g.rcClient.TagAsDeleted(g.getGroupMemberIDsKey(groupID))
+}
+
+// from local map
+func (g *GroupCache) LocalGetGroupMemberIDs(ctx context.Context, groupID string) (groupMemberIDs []string, err error) {
+	remoteHash, err := g.GetGroupMembersHash(ctx, groupID)
+	if err != nil {
+		g.cacheGroupMtx.Lock()
+		defer g.cacheGroupMtx.Unlock()
+		delete(g.cacheGroupMemberUserIDs, groupID)
+		return nil, err
+	}
+	g.cacheGroupMtx.Lock()
+	defer g.cacheGroupMtx.Unlock()
+	if remoteHash == 0 {
+		delete(g.cacheGroupMemberUserIDs, groupID)
+		return []string{}, nil
+	}
+	localCache, ok := g.cacheGroupMemberUserIDs[groupID]
+	if ok && localCache.MemberListHash == remoteHash {
+		return localCache.UserIDs, nil
+	}
+	groupMemberIDsRemote, err := g.GetGroupMemberIDs(ctx, groupID)
+	if err != nil {
+		return nil, err
+	}
+	g.cacheGroupMemberUserIDs[groupID] = &GroupMemberIDsHash{
+		MemberListHash: remoteHash,
+		UserIDs:        groupMemberIDsRemote,
+	}
+	return groupMemberIDsRemote, nil
+}
+
+// JoinedGroups
+func (g *GroupCache) GetJoinedGroupIDs(ctx context.Context, userID string) (joinedGroupIDs []string, err error) {
+	getJoinedGroupIDList := func() (string, error) {
+		joinedGroupList, err := relation.GetJoinedGroupIDListByUserID(userID)
+		if err != nil {
+			return "", err
+		}
+		bytes, err := json.Marshal(joinedGroupList)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedGroupIDs", joinedGroupIDs)
+	}()
+	joinedGroupIDListStr, err := g.rcClient.Fetch(g.getJoinedGroupsKey(userID), time.Second*30*60, getJoinedGroupIDList)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal([]byte(joinedGroupIDListStr), &joinedGroupIDs)
+	return joinedGroupIDs, utils.Wrap(err, "")
+}
+
+func (g *GroupCache) DelJoinedGroupIDs(ctx context.Context, userID string) (err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+	}()
+	return g.rcClient.TagAsDeleted(g.getJoinedGroupsKey(userID))
+}
+
+// GetGroupMemberInfo
+func (g *GroupCache) GetGroupMemberInfo(ctx context.Context, groupID, userID string) (groupMember *relation.GroupMember, err error) {
+	getGroupMemberInfo := func() (string, error) {
+		groupMemberInfo, err := relation.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
+		if err != nil {
+			return "", err
+		}
+		bytes, err := json.Marshal(groupMemberInfo)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
+	}()
+	groupMemberInfoStr, err := g.rcClient.Fetch(g.getGroupMemberInfoKey(groupID, userID), time.Second*30*60, getGroupMemberInfo)
+	if err != nil {
+		return nil, err
+	}
+	groupMember = &relation.GroupMember{}
+	err = json.Unmarshal([]byte(groupMemberInfoStr), groupMember)
+	return groupMember, utils.Wrap(err, "")
+}
+
+func (g *GroupCache) DelGroupMemberInfo(ctx context.Context, groupID, userID string) (err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID)
+	}()
+	return g.rcClient.TagAsDeleted(g.getGroupMemberInfoKey(groupID, userID))
+}
+
+// groupMemberNum
+func (g *GroupCache) GetGroupMemberNum(ctx context.Context, groupID string) (num int, err error) {
+	getGroupMemberNum := func() (string, error) {
+		num, err := relation.GetGroupMemberNumByGroupID(groupID)
+		if err != nil {
+			return "", err
+		}
+		return strconv.Itoa(int(num)), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "num", num)
+	}()
+	groupMember, err := g.rcClient.Fetch(g.getGroupMemberNumKey(groupID), time.Second*30*60, getGroupMemberNum)
+	if err != nil {
+		return 0, err
+	}
+	return strconv.Atoi(groupMember)
+}
+
+func (g *GroupCache) DelGroupMemberNum(ctx context.Context, groupID string) (err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+	}()
+	return g.rcClient.TagAsDeleted(g.getGroupMemberNumKey(groupID))
 }

pkg/common/db/cache/rockscache.go

@@ -4,6 +4,7 @@ import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/mongo"
 	"Open_IM/pkg/common/db/mysql"
+	"Open_IM/pkg/common/db/relation"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/utils"
@@ -19,31 +20,32 @@ import (
 )
 
 const (
-	userInfoCache       = "USER_INFO_CACHE:"
+	//userInfoCache       = "USER_INFO_CACHE:"
 	friendRelationCache = "FRIEND_RELATION_CACHE:"
 	blackListCache      = "BLACK_LIST_CACHE:"
-	groupCache          = "GROUP_CACHE:"
+	//groupCache          = "GROUP_CACHE:"
 	//groupInfoCache            = "GROUP_INFO_CACHE:"
-	groupOwnerIDCache         = "GROUP_OWNER_ID:"
-	joinedGroupListCache      = "JOINED_GROUP_LIST_CACHE:"
-	groupMemberInfoCache      = "GROUP_MEMBER_INFO_CACHE:"
-	groupAllMemberInfoCache   = "GROUP_ALL_MEMBER_INFO_CACHE:"
-	allFriendInfoCache        = "ALL_FRIEND_INFO_CACHE:"
-	joinedSuperGroupListCache = "JOINED_SUPER_GROUP_LIST_CACHE:"
-	groupMemberListHashCache  = "GROUP_MEMBER_LIST_HASH_CACHE:"
-	groupMemberNumCache       = "GROUP_MEMBER_NUM_CACHE:"
-	conversationCache         = "CONVERSATION_CACHE:"
-	conversationIDListCache   = "CONVERSATION_ID_LIST_CACHE:"
-	extendMsgSetCache         = "EXTEND_MSG_SET_CACHE:"
-	extendMsgCache            = "EXTEND_MSG_CACHE:"
+	//groupOwnerIDCache         = "GROUP_OWNER_ID:"
+	//joinedGroupListCache      = "JOINED_GROUP_LIST_CACHE:"
+	//groupMemberInfoCache      = "GROUP_MEMBER_INFO_CACHE:"
+	//groupAllMemberInfoCache   = "GROUP_ALL_MEMBER_INFO_CACHE:"
+	allFriendInfoCache = "ALL_FRIEND_INFO_CACHE:"
+	//joinedSuperGroupListCache = "JOINED_SUPER_GROUP_LIST_CACHE:"
+	//groupMemberListHashCache  = "GROUP_MEMBER_LIST_HASH_CACHE:"
+	//groupMemberNumCache       = "GROUP_MEMBER_NUM_CACHE:"
+	conversationCache       = "CONVERSATION_CACHE:"
+	conversationIDListCache = "CONVERSATION_ID_LIST_CACHE:"
+
+	extendMsgSetCache = "EXTEND_MSG_SET_CACHE:"
+	extendMsgCache    = "EXTEND_MSG_CACHE:"
 )
 
 const scanCount = 3000
 const RandomExpireAdjustment = 0.2
 
 func (rc *RcClient) DelKeys() {
-	for _, key := range []string{groupCache, friendRelationCache, blackListCache, userInfoCache, groupInfoCacheKey, groupOwnerIDCache, joinedGroupListCache,
-		groupMemberInfoCache, groupAllMemberInfoCache, allFriendInfoCache} {
+	for _, key := range []string{"GROUP_CACHE:", "FRIEND_RELATION_CACHE", "BLACK_LIST_CACHE:", "USER_INFO_CACHE:", "GROUP_INFO_CACHE", groupOwnerIDCache, joinedGroupListCache,
+		groupMemberInfoCache, groupAllMemberInfoCache, "ALL_FRIEND_INFO_CACHE:"} {
 		fName := utils.GetSelfFuncName()
 		var cursor uint64
 		var n int

pkg/common/db/cache/user.go

@@ -0,0 +1,90 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/db/relation"
+	"Open_IM/pkg/common/tracelog"
+	"Open_IM/pkg/utils"
+	"context"
+	"encoding/json"
+	"github.com/dtm-labs/rockscache"
+	"github.com/go-redis/redis/v8"
+	"time"
+)
+
+const (
+	UserExpireTime = time.Second * 60 * 60 * 12
+	userInfoKey    = "USER_INFO:"
+)
+
+type UserCache struct {
+	userDB *relation.User
+
+	expireTime  time.Duration
+	redisClient *RedisClient
+	rcClient    *rockscache.Client
+}
+
+func NewUserCache(rdb redis.UniversalClient, userDB *relation.User, options rockscache.Options) *UserCache {
+	return &UserCache{
+		userDB:      userDB,
+		expireTime:  UserExpireTime,
+		redisClient: NewRedisClient(rdb),
+		rcClient:    rockscache.NewClient(rdb, options),
+	}
+}
+
+func (u *UserCache) getUserInfoKey(userID string) string {
+	return userInfoKey + userID
+}
+
+func (u *UserCache) GetUserInfo(ctx context.Context, userID string) (userInfo *relation.User, err error) {
+	getUserInfo := func() (string, error) {
+		userInfo, err := u.userDB.Take(ctx, userID)
+		if err != nil {
+			return "", err
+		}
+		bytes, err := json.Marshal(userInfo)
+		if err != nil {
+			return "", utils.Wrap(err, "")
+		}
+		return string(bytes), nil
+	}
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "userInfo", *userInfo)
+	}()
+	userInfoStr, err := u.rcClient.Fetch(u.getUserInfoKey(userID), time.Second*30*60, getUserInfo)
+	if err != nil {
+		return nil, err
+	}
+	userInfo = &relation.User{}
+	err = json.Unmarshal([]byte(userInfoStr), userInfo)
+	return userInfo, utils.Wrap(err, "")
+}
+
+func (u *UserCache) GetUsersInfo(ctx context.Context, userIDs []string) ([]*relation.User, error) {
+	var users []*relation.User
+	for _, userID := range userIDs {
+		user, err := GetUserInfoFromCache(ctx, userID)
+		if err != nil {
+			return nil, err
+		}
+		users = append(users, user)
+	}
+	return users, nil
+}
+
+func (u *UserCache) DelUserInfo(ctx context.Context, userID string) (err error) {
+	defer func() {
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+	}()
+	return u.rcClient.TagAsDeleted(u.getUserInfoKey(userID) + userID)
+}
+
+func (u *UserCache) DelUsersInfo(ctx context.Context, userIDs []string) (err error) {
+	for _, userID := range userIDs {
+		if err := u.DelUserInfo(ctx, userID); err != nil {
+			return err
+		}
+	}
+	return nil
+}

pkg/common/db/controller/auth.go

@@ -0,0 +1,9 @@
+package controller
+
+import "context"
+
+type AuthInterface interface {
+	GetTokens(ctx context.Context, userID, platform string) (map[string]int, error)
+	DeleteToken(ctx context.Context, userID, platform string) error
+	CreateToken(ctx context.Context, userID string, platformID int, ttl int64) (string, error)
+}

pkg/common/db/controller/black.go

@@ -3,6 +3,7 @@ package controller
 import (
 	"Open_IM/pkg/common/db/relation"
 	"context"
+	"errors"
 	"gorm.io/gorm"
 )
 
@@ -12,9 +13,9 @@ type BlackInterface interface {
 	// Delete 删除黑名单
 	Delete(ctx context.Context, blacks []*relation.Black) (err error)
 	// FindOwnerBlacks 获取黑名单列表
-	FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blackList []*relation.Black, err error)
+	FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*relation.Black, total int64, err error)
 	// CheckIn 检查user2是否在user1的黑名单列表中(inUser1Blacks==true) 检查user1是否在user2的黑名单列表中(inUser2Blacks==true)
-	CheckIn(ctx context.Context, ownerUserID, blackUserID string) (inUser1Blacks bool, inUser2Blacks bool, err error)
+	CheckIn(ctx context.Context, userID1, userID2 string) (inUser1Blacks bool, inUser2Blacks bool, err error)
 }
 
 type BlackController struct {
@@ -27,18 +28,22 @@ func NewBlackController(db *gorm.DB) *BlackController {
 
 // Create 增加黑名单
 func (b *BlackController) Create(ctx context.Context, blacks []*relation.Black) (err error) {
+	return b.database.Create(ctx, blacks)
 }
 
 // Delete 删除黑名单
 func (b *BlackController) Delete(ctx context.Context, blacks []*relation.Black) (err error) {
+	return b.database.Delete(ctx, blacks)
 }
 
 // FindOwnerBlacks 获取黑名单列表
-func (b *BlackController) FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blackList []*relation.Black, err error) {
+func (b *BlackController) FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blackList []*relation.Black, total int64, err error) {
+	return b.database.FindOwnerBlacks(ctx, ownerUserID, pageNumber, showNumber)
 }
 
 // CheckIn 检查user2是否在user1的黑名单列表中(inUser1Blacks==true) 检查user1是否在user2的黑名单列表中(inUser2Blacks==true)
-func (b *BlackController) CheckIn(ctx context.Context, ownerUserID, blackUserID string) (inUser1Blacks bool, inUser2Blacks bool, err error) {
+func (b *BlackController) CheckIn(ctx context.Context, userID1, userID2 string) (inUser1Blacks bool, inUser2Blacks bool, err error) {
+	return b.database.CheckIn(ctx, userID1, userID2)
 }
 
 type BlackDatabaseInterface interface {
@@ -47,10 +52,9 @@ type BlackDatabaseInterface interface {
 	// Delete 删除黑名单
 	Delete(ctx context.Context, blacks []*relation.Black) (err error)
 	// FindOwnerBlacks 获取黑名单列表
-	FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blackList []*relation.Black, err error)
+	FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*relation.Black, total int64, err error)
 	// CheckIn 检查user2是否在user1的黑名单列表中(inUser1Blacks==true) 检查user1是否在user2的黑名单列表中(inUser2Blacks==true)
-	CheckIn(ctx context.Context, ownerUserID, blackUserID string) (inUser1Blacks bool, inUser2Blacks bool, err error)
-}
+	CheckIn(ctx context.Context, userID1, userID2 string) (inUser1Blacks bool, inUser2Blacks bool, err error)
 }
 
 type BlackDatabase struct {
@@ -67,16 +71,40 @@ func NewBlackDatabase(db *gorm.DB) *BlackDatabase {
 
 // Create 增加黑名单
 func (b *BlackDatabase) Create(ctx context.Context, blacks []*relation.Black) (err error) {
+	return b.sqlDB.Create(ctx, blacks)
 }
 
 // Delete 删除黑名单
 func (b *BlackDatabase) Delete(ctx context.Context, blacks []*relation.Black) (err error) {
+	return b.sqlDB.Delete(ctx, blacks)
 }
 
 // FindOwnerBlacks 获取黑名单列表
-func (b *BlackDatabase) FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blackList []*relation.Black, err error) {
+func (b *BlackDatabase) FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*relation.Black, total int64, err error) {
+	return b.sqlDB.FindOwnerBlacks(ctx, ownerUserID, pageNumber, showNumber)
 }
 
 // CheckIn 检查user2是否在user1的黑名单列表中(inUser1Blacks==true) 检查user1是否在user2的黑名单列表中(inUser2Blacks==true)
-func (b *BlackDatabase) CheckIn(ctx context.Context, ownerUserID, blackUserID string) (inUser1Blacks bool, inUser2Blacks bool, err error) {
+func (b *BlackDatabase) CheckIn(ctx context.Context, userID1, userID2 string) (inUser1Blacks bool, inUser2Blacks bool, err error) {
+	_, err = b.sqlDB.Take(ctx, userID1, userID2)
+	if err != nil {
+		if errors.Unwrap(err) != gorm.ErrRecordNotFound {
+			return
+		}
+		inUser1Blacks = false
+	} else {
+		inUser1Blacks = true
+	}
+
+	inUser2Blacks = true
+	_, err = b.sqlDB.Take(ctx, userID2, userID1)
+	if err != nil {
+		if errors.Unwrap(err) != gorm.ErrRecordNotFound {
+			return
+		}
+		inUser2Blacks = false
+	} else {
+		inUser2Blacks = true
+	}
+	return
 }

pkg/common/db/controller/chatlog.go

@@ -0,0 +1,49 @@
+package controller
+
+import (
+	"Open_IM/pkg/common/db/relation"
+	pbMsg "Open_IM/pkg/proto/msg"
+	"gorm.io/gorm"
+)
+
+type ChatLogInterface interface {
+	CreateChatLog(msg pbMsg.MsgDataToMQ) error
+	GetChatLog(chatLog *relation.ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []relation.ChatLog, error)
+}
+
+func NewChatLogController(db *gorm.DB) ChatLogInterface {
+	return &ChatLogController{database: NewChatLogDataBase(db)}
+}
+
+type ChatLogController struct {
+	database ChatLogDataBaseInterface
+}
+
+func (c *ChatLogController) CreateChatLog(msg pbMsg.MsgDataToMQ) error {
+	return c.database.CreateChatLog(msg)
+}
+
+func (c *ChatLogController) GetChatLog(chatLog *relation.ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []relation.ChatLog, error) {
+	return c.database.GetChatLog(chatLog, pageNumber, showNumber, contentTypeList)
+}
+
+type ChatLogDataBaseInterface interface {
+	CreateChatLog(msg pbMsg.MsgDataToMQ) error
+	GetChatLog(chatLog *relation.ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []relation.ChatLog, error)
+}
+
+type ChatLogDataBase struct {
+	chatLogDB *relation.ChatLog
+}
+
+func NewChatLogDataBase(db *gorm.DB) ChatLogDataBaseInterface {
+	return &ChatLogDataBase{chatLogDB: relation.NewChatLog(db)}
+}
+
+func (c *ChatLogDataBase) CreateChatLog(msg pbMsg.MsgDataToMQ) error {
+	return c.chatLogDB.Create(msg)
+}
+
+func (c *ChatLogDataBase) GetChatLog(chatLog *relation.ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []relation.ChatLog, error) {
+	return c.chatLogDB.GetChatLog(chatLog, pageNumber, showNumber, contentTypeList)
+}

pkg/common/db/controller/group.go

@@ -134,8 +134,8 @@ func (g *GroupController) AddUserToSuperGroup(ctx context.Context, groupID strin
 	panic("implement me")
 }
 
-func NewGroupController(db *gorm.DB, rdb redis.UniversalClient, mgoDB *mongo.Client) GroupInterface {
-	groupController := &GroupController{database: newGroupDatabase(db, rdb, mgoDB)}
+func NewGroupController(db *gorm.DB, rdb redis.UniversalClient, mgoClient *mongo.Client) GroupInterface {
+	groupController := &GroupController{database: newGroupDatabase(db, rdb, mgoClient)}
 	return groupController
 }
 
@@ -182,23 +182,24 @@ type GroupDataBase struct {
 	mongoDB *unrelation.SuperGroupMgoDB
 }
 
-func newGroupDatabase(db *gorm.DB, rdb redis.UniversalClient, mgoDB *mongo.Client) GroupDataBaseInterface {
+func newGroupDatabase(db *gorm.DB, rdb redis.UniversalClient, mgoClient *mongo.Client) GroupDataBaseInterface {
 	groupDB := relation.NewGroupDB(db)
 	groupMemberDB := relation.NewGroupMemberDB(db)
 	groupRequestDB := relation.NewGroupRequest(db)
 	newDB := db
+	superGroupMgoDB := unrelation.NewSuperGroupMgoDB(mgoClient)
 	database := &GroupDataBase{
 		groupDB:        groupDB,
 		groupMemberDB:  groupMemberDB,
 		groupRequestDB: groupRequestDB,
 		db:             newDB,
-		cache: cache.NewGroupCache(rdb, groupDB, groupMemberDB, groupRequestDB, rockscache.Options{
+		cache: cache.NewGroupCache(rdb, groupDB, groupMemberDB, groupRequestDB, superGroupMgoDB, rockscache.Options{
 			RandomExpireAdjustment: 0.2,
 			DisableCacheRead:       false,
 			DisableCacheDelete:     false,
 			StrongConsistency:      true,
 		}),
-		mongoDB: unrelation.NewSuperGroupMgoDB(mgoDB),
+		mongoDB: superGroupMgoDB,
 	}
 	return database
 }
@@ -272,7 +273,7 @@ func (g *GroupDataBase) CreateSuperGroup(ctx context.Context, groupID string, in
 		return err
 	}
 
-	if err = g.cache.DelJoinedSuperGroupIDs(ctx, initMemberIDList); err != nil {
+	if err = g.cache.BatchDelJoinedSuperGroupIDs(ctx, initMemberIDList); err != nil {
 		_ = sess.AbortTransaction(ctx)
 		return err
 	}

pkg/common/db/controller/user.go

@@ -7,14 +7,16 @@ import (
 )
 
 type UserInterface interface {
+	//获取指定用户的信息 如果有记录未找到 也返回错误
 	Find(ctx context.Context, userIDs []string) (users []*relation.User, err error)
 	Create(ctx context.Context, users []*relation.User) error
-	Take(ctx context.Context, userID string) (user *relation.User, err error)
 	Update(ctx context.Context, users []*relation.User) (err error)
 	UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error)
 	GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
 	GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
 	Get(ctx context.Context, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
+	//userIDs是否存在 只要有一个存在就为true
+	IsExist(ctx context.Context, userIDs []string) (exist bool, err error)
 }
 
 type UserController struct {

pkg/common/db/relation/black.go

@@ -71,44 +71,14 @@ func (b *Black) Take(ctx context.Context, ownerUserID, blockUserID string) (blac
 	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) {
+func (b *Black) FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*Black, total int64, err error) {
 	defer func() {
-		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blackList", blackList)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blacks", blacks)
 	}()
-	return blackList, utils.Wrap(GroupMemberDB.Where("owner_user_id = ?", ownerUserID).Find(&blackList).Error, "")
-}
-
-func InsertInToUserBlackList(ctx context.Context, black Black) (err error) {
-	defer tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "black", black)
-	black.CreateTime = time.Now()
-	err = BlackDB.Create(black).Error
-	return err
-}
-
-func CheckBlack(ownerUserID, blockUserID string) error {
-	var black Black
-	return BlackDB.Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Find(&black).Error
-}
-
-func RemoveBlackList(ownerUserID, blockUserID string) error {
-	err := BlackDB.Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Delete(Black{}).Error
-	return utils.Wrap(err, "RemoveBlackList failed")
-}
-
-func GetBlackListByUserID(ownerUserID string) ([]Black, error) {
-	var blackListUsersInfo []Black
-	err := BlackDB.Where("owner_user_id=?", ownerUserID).Find(&blackListUsersInfo).Error
+	err = b.DB.Model(b).Count(&total).Error
 	if err != nil {
-		return nil, err
+		return nil, 0, utils.Wrap(err, "")
 	}
-	return blackListUsersInfo, nil
-}
-
-func GetBlackIDListByUserID(ownerUserID string) ([]string, error) {
-	var blackIDList []string
-	err := b.db.Where("owner_user_id=?", ownerUserID).Pluck("block_user_id", &blackIDList).Error
-	if err != nil {
-		return nil, err
-	}
-	return blackIDList, nil
+	err = utils.Wrap(b.DB.Limit(int(showNumber)).Offset(int(pageNumber*showNumber)).Find(&blacks).Error, "")
+	return
 }

pkg/common/db/relation/chat_log_model.go

@@ -2,7 +2,6 @@ package relation
 
 import (
 	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
 	pbMsg "Open_IM/pkg/proto/msg"
 	server_api_params "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
@@ -37,7 +36,11 @@ func (ChatLog) TableName() string {
 	return "chat_logs"
 }
 
-func InsertMessageToChatLog(msg pbMsg.MsgDataToMQ) error {
+func NewChatLog(db *gorm.DB) *ChatLog {
+	return &ChatLog{DB: db}
+}
+
+func (c *ChatLog) Create(msg pbMsg.MsgDataToMQ) error {
 	chatLog := new(ChatLog)
 	copier.Copy(chatLog, msg.MsgData)
 	switch msg.MsgData.SessionType {
@@ -61,12 +64,11 @@ func InsertMessageToChatLog(msg pbMsg.MsgDataToMQ) error {
 	}
 	chatLog.CreateTime = utils.UnixMillSecondToTime(msg.MsgData.CreateTime)
 	chatLog.SendTime = utils.UnixMillSecondToTime(msg.MsgData.SendTime)
-	log.NewDebug("test", "this is ", chatLog)
-	return db.DB.MysqlDB.DefaultGormDB().Table("chat_logs").Create(chatLog).Error
+	return c.DB.Create(chatLog).Error
 }
 
-func GetChatLog(chatLog *ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []ChatLog, error) {
-	mdb := ChatLogDB.Table("chat_logs")
+func (c *ChatLog) GetChatLog(chatLog *ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []ChatLog, error) {
+	mdb := c.DB.Model(chatLog)
 	if chatLog.SendTime.Unix() > 0 {
 		mdb = mdb.Where("send_time > ? and send_time < ?", chatLog.SendTime, chatLog.SendTime.AddDate(0, 0, 1))
 	}

pkg/common/db/relation/file_model.go

@@ -1,50 +0,0 @@
-package relation
-
-import (
-	"gorm.io/gorm"
-	"time"
-)
-
-var AppDB *gorm.DB
-
-type AppVersion struct {
-	Version     string `gorm:"column:version;size:64" json:"version"`
-	Type        int    `gorm:"column:type;primary_key" json:"type"`
-	UpdateTime  int    `gorm:"column:update_time" json:"update_time"`
-	ForceUpdate bool   `gorm:"column:force_update" json:"force_update"`
-	FileName    string `gorm:"column:file_name" json:"file_name"`
-	YamlName    string `gorm:"column:yaml_name" json:"yaml_name"`
-	UpdateLog   string `gorm:"column:update_log" json:"update_log"`
-}
-
-func (AppVersion) TableName() string {
-	return "app_version"
-}
-
-func UpdateAppVersion(appType int, version string, forceUpdate bool, fileName, yamlName, updateLog string) error {
-	updateTime := int(time.Now().Unix())
-	app := AppVersion{
-		Version:     version,
-		Type:        appType,
-		UpdateTime:  updateTime,
-		FileName:    fileName,
-		YamlName:    yamlName,
-		ForceUpdate: forceUpdate,
-		UpdateLog:   updateLog,
-	}
-	result := AppDB.Model(AppVersion{}).Where("type = ?", appType).Updates(map[string]interface{}{"force_update": forceUpdate,
-		"version": version, "update_time": int(time.Now().Unix()), "file_name": fileName, "yaml_name": yamlName, "type": appType, "update_log": updateLog})
-	if result.Error != nil {
-		return result.Error
-	}
-	if result.RowsAffected == 0 {
-		err := AppDB.Create(&app).Error
-		return err
-	}
-	return nil
-}
-
-func GetNewestVersion(appType int) (*AppVersion, error) {
-	app := AppVersion{}
-	return &app, AppDB.Model(AppVersion{}).First(&app, appType).Error
-}

pkg/common/db/relation/friend_model_k.go

@@ -26,7 +26,7 @@ type FriendUser struct {
 
 func NewFriendDB(db *gorm.DB) *Friend {
 	var friend Friend
-	friend.DB = initModel(db, friend)
+	friend.DB = db
 	return &friend
 }
 

pkg/common/db/relation/user_model_k.go

@@ -84,7 +84,7 @@ func (u *User) GetByName(ctx context.Context, userName string, showNumber, pageN
 
 func (u *User) GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*User, count int64, err error) {
 	defer func() {
-		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userName", userName, "showNumber", showNumber, "pageNumber", pageNumber, "users", users)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "content", content, "showNumber", showNumber, "pageNumber", pageNumber, "users", users)
 	}()
 	db := u.DB.Where(" name like ? or user_id = ? ", fmt.Sprintf("%%%s%%", content), content)
 	if err := db.Count(&count).Error; err != nil {

pkg/common/db/unrelation/super_group.go

@@ -108,8 +108,8 @@ func (db *SuperGroupMgoDB) RemoverUserFromSuperGroup(ctx context.Context, groupI
 
 func (db *SuperGroupMgoDB) GetSuperGroupByUserID(ctx context.Context, userID string) (*UserToSuperGroup, error) {
 	var user UserToSuperGroup
-	_ = db.userToSuperGroupCollection.FindOne(ctx, bson.M{"user_id": userID}).Decode(&user)
-	return &user, nil
+	err := db.userToSuperGroupCollection.FindOne(ctx, bson.M{"user_id": userID}).Decode(&user)
+	return &user, utils.Wrap(err, "")
 }
 
 func (db *SuperGroupMgoDB) DeleteSuperGroup(ctx context.Context, groupID string) error {

pkg/common/middleware/gin.go

@@ -1,10 +1,6 @@
 package middleware
 
 import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/token_verify"
-	"Open_IM/pkg/utils"
 	"bytes"
 	"encoding/json"
 	"github.com/gin-gonic/gin"
@@ -12,27 +8,6 @@ import (
 	"net/http"
 )
 
-func JWTAuth() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		ok, userID, errInfo := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), "")
-		// log.NewInfo("0", utils.GetSelfFuncName(), "userID: ", userID)
-		c.Set("userID", userID)
-		if !ok {
-			log.NewError("", "GetUserIDFromToken false ", c.Request.Header.Get("token"))
-			c.Abort()
-			c.JSON(http.StatusOK, gin.H{"errCode": 400, "errMsg": errInfo})
-			return
-		} else {
-			if !utils.IsContain(userID, config.Config.Manager.AppManagerUid) {
-				c.Abort()
-				c.JSON(http.StatusOK, gin.H{"errCode": 400, "errMsg": "user is not admin"})
-				return
-			}
-			log.NewInfo("0", utils.GetSelfFuncName(), "failed: ", errInfo)
-		}
-	}
-}
-
 func CorsHandler() gin.HandlerFunc {
 	return func(context *gin.Context) {
 		context.Writer.Header().Set("Access-Control-Allow-Origin", "*")

pkg/common/multi_terminal_login/multi_terminal_login.go

@@ -1,73 +0,0 @@
-package multi_terminal_login
-
-//
-//import (
-//	"Open_IM/internal/push/content_struct"
-//	"Open_IM/internal/push/logic"
-//	"Open_IM/pkg/common/config"
-//	"Open_IM/pkg/common/constant"
-//	"Open_IM/pkg/common/db"
-//	pbChat "Open_IM/pkg/proto/msg"
-//	"Open_IM/pkg/utils"
-//)
-//
-//const  DayOfSecond = 24*60*60
-//func MultiTerminalLoginChecker(uid, token string, platformID int32) error {
-//	//	1.check userid and platform class   0 not exists and  1 exists
-//	exists, err := db.DB.ExistsUserIDAndPlatform(uid, constant.PlatformNameToClass(constant.PlatformIDToName(platformID)))
-//	if err != nil {
-//		return err
-//	}
-//	//get config multi login policy
-//	if config.Config.MultiLoginPolicy  {
-//		//OnlyOneTerminalAccess policy need to check all terminal
-//		if constant.PlatformNameToClass(constant.PlatformIDToName(platformID)) == "PC" {
-//			exists, err = db.DB.ExistsUserIDAndPlatform(uid, "Mobile")
-//			if err != nil {
-//				return err
-//			}
-//		} else {
-//			exists, err = db.DB.ExistsUserIDAndPlatform(uid, "PC")
-//			if err != nil {
-//				return err
-//			}
-//		}
-//		if exists == 1 {
-//			err := db.DB.SetUserIDAndPlatform(uid, constant.PlatformNameToClass(constant.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire*DayOfSecond)
-//			if err != nil {
-//				return err
-//			}
-//			PushMessageToTheTerminal(uid, platformID)
-//			return nil
-//		}
-//	} else if config.Config.MultiLoginPolicy.MobileAndPCTerminalAccessButOtherTerminalKickEachOther {
-//		//	common terminal need to kick eich other
-//		if exists == 1 {
-//			err := db.DB.SetUserIDAndPlatform(uid, constant.PlatformNameToClass(constant.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire*DayOfSecond)
-//			if err != nil {
-//				return err
-//			}
-//			PushMessageToTheTerminal(uid, platformID)
-//			return nil
-//		}
-//	}
-//	err = db.DB.SetUserIDAndPlatform(uid, constant.PlatformNameToClass(constant.PlatformIDToName(platformID)), token, config.Config.TokenPolicy.AccessExpire*DayOfSecond)
-//	if err != nil {
-//		return err
-//	}
-//	PushMessageToTheTerminal(uid, platformID)
-//	return nil
-//}
-////
-////func PushMessageToTheTerminal(uid string, platform int32) {
-////
-////	logic.SendMsgByWS(&pbChat.WSToMsgSvrChatMsg{
-////		SendID:      uid,
-////		RecvID:      uid,
-////		Content:     content_struct.NewContentStructString(1, "", "Your account is already logged on other terminal,please confirm"),
-////		SendTime:    utils.GetCurrentTimestampBySecond(),
-////		MsgFrom:     constant.SysMsgType,
-////		ContentType: constant.KickOnlineTip,
-////		PlatformID:  platform,
-////	})
-////}

pkg/common/token_verify/jwt_token.go

@@ -3,25 +3,13 @@ package token_verify
 import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
-	commonDB "Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/utils"
 	"context"
-	"time"
-
-	go_redis "github.com/go-redis/redis/v8"
 	"github.com/golang-jwt/jwt/v4"
+	"time"
 )
 
-//var (
-//	TokenExpired     = errors.New("token is timed out, please log in again")
-//	TokenInvalid     = errors.New("token has been invalidated")
-//	TokenNotValidYet = errors.New("token not active yet")
-//	TokenMalformed   = errors.New("that's not even a token")
-//	TokenUnknown     = errors.New("couldn't handle this token")
-//)
-
 type Claims struct {
 	UID      string
 	Platform string //login platform
@@ -41,57 +29,6 @@ func BuildClaims(uid, platform string, ttl int64) Claims {
 		}}
 }
 
-func DeleteToken(userID string, platformID int) error {
-	m, err := commonDB.DB.GetTokenMapByUidPid(userID, constant.PlatformIDToName(platformID))
-	if err != nil && err != go_redis.Nil {
-		return utils.Wrap(err, "")
-	}
-	var deleteTokenKey []string
-	for k, v := range m {
-		_, err = GetClaimFromToken(k)
-		if err != nil || v != constant.NormalToken {
-			deleteTokenKey = append(deleteTokenKey, k)
-		}
-	}
-	if len(deleteTokenKey) != 0 {
-		err = commonDB.DB.DeleteTokenByUidPid(userID, platformID, deleteTokenKey)
-		return utils.Wrap(err, "")
-	}
-	return nil
-}
-
-func CreateToken(userID string, platformID int) (string, int64, error) {
-	claims := BuildClaims(userID, constant.PlatformIDToName(platformID), config.Config.TokenPolicy.AccessExpire)
-	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-	tokenString, err := token.SignedString([]byte(config.Config.TokenPolicy.AccessSecret))
-	if err != nil {
-		return "", 0, err
-	}
-	//remove Invalid token
-	m, err := commonDB.DB.GetTokenMapByUidPid(userID, constant.PlatformIDToName(platformID))
-	if err != nil && err != go_redis.Nil {
-		return "", 0, err
-	}
-	var deleteTokenKey []string
-	for k, v := range m {
-		_, err = GetClaimFromToken(k)
-		if err != nil || v != constant.NormalToken {
-			deleteTokenKey = append(deleteTokenKey, k)
-		}
-	}
-	if len(deleteTokenKey) != 0 {
-		err = commonDB.DB.DeleteTokenByUidPid(userID, platformID, deleteTokenKey)
-		if err != nil {
-			return "", 0, err
-		}
-	}
-	err = commonDB.DB.AddTokenFlag(userID, platformID, tokenString, constant.NormalToken)
-	if err != nil {
-		return "", 0, err
-	}
-	return tokenString, claims.ExpiresAt.Time.Unix(), err
-}
-
 func secret() jwt.Keyfunc {
 	return func(token *jwt.Token) (interface{}, error) {
 		return []byte(config.Config.TokenPolicy.AccessSecret), nil
@@ -122,44 +59,8 @@ func GetClaimFromToken(tokensString string) (*Claims, error) {
 	}
 }
 
-func IsAppManagerAccess(token string, OpUserID string) bool {
-	claims, err := ParseToken(token, "")
-	if err != nil {
-		return false
-	}
-	if utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) && claims.UID == OpUserID {
-		return true
-	}
-	return false
-}
-
-func IsManagerUserID(OpUserID string) bool {
-	if utils.IsContain(OpUserID, config.Config.Manager.AppManagerUid) {
-		return true
-	} else {
-		return false
-	}
-}
-
-func CheckManagerUserID(ctx context.Context, userID string) error {
-	if utils.IsContain(userID, config.Config.Manager.AppManagerUid) {
-		return nil
-	}
-	return constant.ErrNoPermission.Wrap()
-}
-
-func CheckAccess(ctx context.Context, OpUserID string, OwnerUserID string) bool {
-	if utils.IsContain(OpUserID, config.Config.Manager.AppManagerUid) {
-		return true
-	}
-	if OpUserID == OwnerUserID {
-		return true
-	}
-	return false
-}
-
 func CheckAccessV3(ctx context.Context, ownerUserID string) (err error) {
-	opUserID := utils.OpUserID(ctx)
+	opUserID := tracelog.GetOpUserID(ctx)
 	defer func() {
 		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "OpUserID", opUserID, "ownerUserID", ownerUserID)
 	}()
@@ -172,144 +73,13 @@ func CheckAccessV3(ctx context.Context, ownerUserID string) (err error) {
 	return constant.ErrIdentity.Wrap(utils.GetSelfFuncName())
 }
 
-func IsAppManagerUid(ctx context.Context) bool {
-	return utils.IsContain(utils.OpUserID(ctx), config.Config.Manager.AppManagerUid)
-}
-
 func CheckAdmin(ctx context.Context) error {
-	if utils.IsContain(utils.OpUserID(ctx), config.Config.Manager.AppManagerUid) {
+	if utils.IsContain(tracelog.GetOpUserID(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 {
-		log.Error(operationID, "ParseToken failed, ", err.Error(), token)
-		return false, "", err.Error()
-	}
-	log.Debug(operationID, "token claims.ExpiresAt.Second() ", claims.ExpiresAt.Unix())
-	return true, claims.UID, ""
-}
-
-func ParseUserIDFromToken(token string, operationID string) (string, error) {
-	claims, err := ParseToken(token, operationID)
-	if err != nil {
-		log.Error(operationID, "ParseToken failed, ", err.Error(), token)
-		return "", err
-	}
-	log.Debug(operationID, "token claims.ExpiresAt.Second() ", claims.ExpiresAt.Unix())
-	return claims.UID, nil
-}
-
-func GetUserIDFromTokenExpireTime(token string, operationID string) (bool, string, string, int64) {
-	claims, err := ParseToken(token, operationID)
-	if err != nil {
-		log.Error(operationID, "ParseToken failed, ", err.Error(), token)
-		return false, "", err.Error(), 0
-	}
-	return true, claims.UID, "", claims.ExpiresAt.Unix()
-}
-
-func ParseTokenGetUserID(token string, operationID string) (error, string) {
-	claims, err := ParseToken(token, operationID)
-	if err != nil {
-		return utils.Wrap(err, ""), ""
-	}
-	return nil, claims.UID
-}
-
-func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
-	claims, err = GetClaimFromToken(tokensString)
-	if err != nil {
-		return nil, utils.Wrap(err, "")
-	}
-
-	m, err := commonDB.DB.GetTokenMapByUidPid(claims.UID, claims.Platform)
-	if err != nil {
-		log.NewError(operationID, "get token from redis err", err.Error(), claims.UID, claims.Platform)
-		return nil, utils.Wrap(constant.ErrTokenNotExist, "get token from redis err")
-	}
-	if m == nil {
-		log.NewError(operationID, "get token from redis err, not in redis ", "m is nil ", claims.UID, claims.Platform)
-		return nil, utils.Wrap(constant.ErrTokenNotExist, "get token from redis err")
-	}
-	if v, ok := m[tokensString]; ok {
-		switch v {
-		case constant.NormalToken:
-			log.NewDebug(operationID, "this is normal return ", *claims)
-			return claims, nil
-		case constant.KickedToken:
-			log.Error(operationID, "this token has been kicked by other same terminal ", constant.ErrTokenKicked)
-			return nil, utils.Wrap(constant.ErrTokenKicked, "this token has been kicked by other same terminal ")
-		default:
-			return nil, utils.Wrap(constant.ErrTokenUnknown, "")
-		}
-	}
-	log.NewError(operationID, "redis token map not find ", constant.ErrTokenNotExist, tokensString)
-	return nil, utils.Wrap(constant.ErrTokenNotExist, "redis token map not find")
-}
-
-//func MakeTheTokenInvalid(currentClaims *Claims, platformClass string) (bool, error) {
-//	storedRedisTokenInterface, err := db.DB.GetPlatformToken(currentClaims.UID, platformClass)
-//	if err != nil {
-//		return false, err
-//	}
-//	storedRedisPlatformClaims, err := ParseRedisInterfaceToken(storedRedisTokenInterface)
-//	if err != nil {
-//		return false, err
-//	}
-//	//if issue time less than redis token then make this token invalid
-//	if currentClaims.IssuedAt.Time.Unix() < storedRedisPlatformClaims.IssuedAt.Time.Unix() {
-//		return true, constant.TokenInvalid
-//	}
-//	return false, nil
-//}
-
 func ParseRedisInterfaceToken(redisToken interface{}) (*Claims, error) {
 	return GetClaimFromToken(string(redisToken.([]uint8)))
 }
-
-// Validation token, false means failure, true means successful verification
-func VerifyToken(token, uid string) (bool, error) {
-	claims, err := ParseToken(token, "")
-	if err != nil {
-		return false, utils.Wrap(err, "ParseToken failed")
-	}
-	if claims.UID != uid {
-		return false, constant.ErrTokenUnknown
-	}
-
-	log.NewDebug("", claims.UID, claims.Platform)
-	return true, nil
-}
-
-func WsVerifyToken(token, uid string, platformID string, operationID string) (bool, error, string) {
-	argMsg := "args: token: " + token + " operationID: " + operationID + " userID: " + uid + " platformID: " + constant.PlatformIDToName(utils.StringToInt(platformID))
-	claims, err := ParseToken(token, operationID)
-	if err != nil {
-		//if errors.Is(err, constant.ErrTokenUnknown) {
-		//	errMsg := "ParseToken failed ErrTokenUnknown " + err.Error()
-		//	log.Error(operationID, errMsg)
-		//}
-		//e := errors.Unwrap(err)
-		//if errors.Is(e, constant.ErrTokenUnknown) {
-		//	errMsg := "ParseToken failed ErrTokenUnknown " + e.Error()
-		//	log.Error(operationID, errMsg)
-		//}
-
-		errMsg := "parse token err " + err.Error() + argMsg
-		return false, utils.Wrap(err, errMsg), errMsg
-	}
-	if claims.UID != uid {
-		errMsg := " uid is not same to token uid " + argMsg + " claims.UID: " + claims.UID
-		return false, utils.Wrap(constant.ErrTokenDifferentUserID, errMsg), errMsg
-	}
-	if claims.Platform != constant.PlatformIDToName(utils.StringToInt(platformID)) {
-		errMsg := " platform is not same to token platform " + argMsg + " claims platformID: " + claims.Platform
-		return false, utils.Wrap(constant.ErrTokenDifferentPlatformID, errMsg), errMsg
-	}
-	log.NewDebug(operationID, utils.GetSelfFuncName(), " check ok ", claims.UID, uid, claims.Platform)
-	return true, nil, ""
-}