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

internal/api/conversation.go

@@ -62,10 +62,6 @@ func (o *Conversation) ModifyConversationField(c *gin.Context) {
 	a2r.Call(conversation.ConversationClient.ModifyConversationField, o.client, c)
 }
 
-func (o *Conversation) GetConversationsHasReadAndMaxSeq(c *gin.Context) {
-	a2r.Call(conversation.ConversationClient.GetConversationsHasReadAndMaxSeq, o.client, c)
-}
-
 func (o *Conversation) SetConversations(c *gin.Context) {
 	a2r.Call(conversation.ConversationClient.SetConversations, o.client, c)
 }

internal/api/msg.go

@@ -131,6 +131,10 @@ func (m *Message) MarkMsgsAsRead(c *gin.Context) {
 	a2r.Call(msg.MsgClient.MarkMsgsAsRead, m.client, c)
 }
 
+func (m *Message) GetConversationsHasReadAndMaxSeq(c *gin.Context) {
+	a2r.Call(msg.MsgClient.GetConversationsHasReadAndMaxSeq, m.client, c)
+}
+
 func (m *Message) ClearConversationsMsg(c *gin.Context) {
 	a2r.Call(msg.MsgClient.ClearConversationsMsg, m.client, c)
 }

internal/api/route.go

@@ -141,6 +141,7 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		msgGroup.POST("/pull_msg_by_seq", m.PullMsgBySeqs)
 		msgGroup.POST("/revoke_msg", m.RevokeMsg)
 		msgGroup.POST("/mark_msgs_as_read", m.MarkMsgsAsRead)
+		msgGroup.POST("/get_conversations_has_read_and_max_seq", m.GetConversationsHasReadAndMaxSeq)
 
 		msgGroup.POST("/clear_conversation_msg", m.ClearConversationsMsg)
 		msgGroup.POST("/user_clear_all_msg", m.UserClearAllMsg)
@@ -168,7 +169,6 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		conversationGroup.POST("/batch_set_conversation", c.BatchSetConversations)
 		conversationGroup.POST("/set_recv_msg_opt", c.SetRecvMsgOpt)
 		conversationGroup.POST("/modify_conversation_field", c.ModifyConversationField)
-		conversationGroup.POST("/get_conversations_has_read_and_max_seq", c.GetConversationsHasReadAndMaxSeq)
 		conversationGroup.POST("/set_conversations", c.SetConversations)
 	}
 	return r

internal/rpc/conversation/conversaion.go

@@ -13,7 +13,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
@@ -300,25 +299,6 @@ func (c *conversationServer) GetConversationIDs(ctx context.Context, req *pbConv
 	return &pbConversation.GetConversationIDsResp{ConversationIDs: conversationIDs}, nil
 }
 
-func (c *conversationServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *pbConversation.GetConversationsHasReadAndMaxSeqReq) (*pbConversation.GetConversationsHasReadAndMaxSeqResp, error) {
-	conversations, err := c.conversationDatabase.GetUserAllHasReadSeqs(ctx, req.UserID)
-	if err != nil {
-		return nil, err
-	}
-	maxSeqs, err := c.msgRpcClient.GetMaxSeq(ctx, &sdkws.GetMaxSeqReq{UserID: req.UserID})
-	if err != nil {
-		return nil, err
-	}
-	resp := &pbConversation.GetConversationsHasReadAndMaxSeqResp{Seqs: make(map[string]*pbConversation.Seqs)}
-	for conversationID, seq := range conversations {
-		resp.Seqs[conversationID] = &pbConversation.Seqs{
-			HasReadSeq: seq,
-			MaxSeq:     maxSeqs.MaxSeqs[conversationID],
-		}
-	}
-	return resp, nil
-}
-
 func (c *conversationServer) GetUserConversationIDsHash(ctx context.Context, req *pbConversation.GetUserConversationIDsHashReq) (*pbConversation.GetUserConversationIDsHashResp, error) {
 	hash, err := c.conversationDatabase.GetUserConversationIDsHash(ctx, req.OwnerUserID)
 	if err != nil {

internal/rpc/group/cache.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
+	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+)
+
+func (s *groupServer) GetGroupInfoCache(ctx context.Context, req *pbGroup.GetGroupInfoCacheReq) (resp *pbGroup.GetGroupInfoCacheResp, err error) {
+	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
+	if err != nil {
+		return nil, err
+	}
+	resp = &pbGroup.GetGroupInfoCacheResp{GroupInfo: convert.Db2PbGroupInfo(group, "", 0)}
+	return resp, nil
+}
+
+func (s *groupServer) GetGroupMemberCache(ctx context.Context, req *pbGroup.GetGroupMemberCacheReq) (resp *pbGroup.GetGroupMemberCacheResp, err error) {
+	members, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.GroupMemberID)
+	if err != nil {
+		return nil, err
+	}
+	resp = &pbGroup.GetGroupMemberCacheResp{Member: convert.Db2PbGroupMember(members)}
+	return resp, nil
+}

internal/rpc/group/group.go

@@ -445,7 +445,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
-		return convert.Db2PbGroupMembersCMSResp(e)
+		return convert.Db2PbGroupMember(e)
 	})
 	return resp, nil
 }
@@ -471,7 +471,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
-		return convert.Db2PbGroupMembersCMSResp(e)
+		return convert.Db2PbGroupMember(e)
 	})
 	log.ZDebug(ctx, "GetGroupMemberList", "resp", resp, "length", len(resp.Members))
 	return resp, nil
@@ -572,7 +572,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 			tips.Group.OwnerUserID = owner[0].UserID
 		}
 		if opMember, ok := memberMap[opUserID]; ok {
-			tips.OpUser = convert.Db2PbGroupMembersCMSResp(opMember)
+			tips.OpUser = convert.Db2PbGroupMember(opMember)
 		} else {
 			tips.OpUser = &sdkws.GroupMemberFullInfo{
 				GroupID: group.GroupID,
@@ -580,7 +580,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 			}
 		}
 		for _, userID := range req.KickedUserIDs {
-			tips.KickedUserList = append(tips.KickedUserList, convert.Db2PbGroupMembersCMSResp(memberMap[userID]))
+			tips.KickedUserList = append(tips.KickedUserList, convert.Db2PbGroupMember(memberMap[userID]))
 		}
 		s.Notification.MemberKickedNotification(ctx, tips)
 	}
@@ -612,7 +612,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
-		return convert.Db2PbGroupMembersCMSResp(e)
+		return convert.Db2PbGroupMember(e)
 	})
 	return resp, nil
 }
@@ -724,7 +724,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 		return nil, err
 	}
 	if groupRequest.HandleResult != 0 {
-		return nil, errs.ErrArgs.Wrap("group request already processed")
+		return nil, errs.ErrGroupRequestHandled.Wrap("group request already processed")
 	}
 	var inGroup bool
 	_, err = s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID)
@@ -733,17 +733,16 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 	} else if !s.IsNotFound(err) {
 		return nil, err
 	}
-	user, err := s.User.GetPublicUserInfo(ctx, req.FromUserID)
-	if err != nil {
+	if _, err := s.User.GetPublicUserInfo(ctx, req.FromUserID); err != nil {
 		return nil, err
 	}
 	var member *relationTb.GroupMemberModel
 	if (!inGroup) && req.HandleResult == constant.GroupResponseAgree {
 		member = &relationTb.GroupMemberModel{
 			GroupID:        req.GroupID,
-			UserID:         user.UserID,
-			Nickname:       user.Nickname,
-			FaceURL:        user.FaceURL,
+			UserID:         req.FromUserID,
+			Nickname:       "",
+			FaceURL:        "",
 			RoleLevel:      constant.GroupOrdinaryUsers,
 			JoinTime:       time.Now(),
 			JoinSource:     groupRequest.JoinSource,
@@ -1059,7 +1058,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
-		return convert.Db2PbGroupMembersCMSResp(e)
+		return convert.Db2PbGroupMember(e)
 	})
 	return resp, nil
 }
@@ -1449,7 +1448,7 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.Ge
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
-		return convert.Db2PbGroupMembersCMSResp(e)
+		return convert.Db2PbGroupMember(e)
 	})
 	return resp, nil
 }
@@ -1482,7 +1481,7 @@ func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbGroup.
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
-		return convert.Db2PbGroupMembersCMSResp(e)
+		return convert.Db2PbGroupMember(e)
 	})
 	return resp, nil
 }

internal/rpc/msg/as_read.go

@@ -9,6 +9,29 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 )
 
+func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *msg.GetConversationsHasReadAndMaxSeqReq) (*msg.GetConversationsHasReadAndMaxSeqResp, error) {
+	conversationIDs, err := m.ConversationLocalCache.GetConversationIDs(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	hasReadSeqs, err := m.MsgDatabase.GetHasReadSeqs(ctx, req.UserID, conversationIDs)
+	if err != nil {
+		return nil, err
+	}
+	maxSeqs, err := m.MsgDatabase.GetMaxSeqs(ctx, conversationIDs)
+	if err != nil {
+		return nil, err
+	}
+	resp := &msg.GetConversationsHasReadAndMaxSeqResp{Seqs: make(map[string]*msg.Seqs)}
+	for conversarionID, maxSeq := range maxSeqs {
+		resp.Seqs[conversarionID] = &msg.Seqs{
+			HasReadSeq: hasReadSeqs[conversarionID],
+			MaxSeq:     maxSeq,
+		}
+	}
+	return resp, nil
+}
+
 func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadReq) (resp *msg.MarkMsgsAsReadResp, err error) {
 	if len(req.Seqs) < 1 {
 		return nil, errs.ErrArgs.Wrap("seqs must not be empty")
@@ -21,21 +44,23 @@ func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadR
 	if err != nil {
 		return
 	}
-	err = m.Conversation.SetHasReadSeq(ctx, req.UserID, req.ConversationID, conversations[0].ConversationType, req.Seqs[len(req.Seqs)-1])
+	hasReadSeq := req.Seqs[len(req.Seqs)-1]
+	err = m.MsgDatabase.SetHasReadSeq(ctx, req.UserID, req.ConversationID, hasReadSeq)
 	if err != nil {
 		return
 	}
-	if err = m.sendMarkAsReadNotification(ctx, req.ConversationID, conversations[0].ConversationType, req.UserID, m.conversationAndGetRecvID(conversations[0], req.UserID), req.Seqs); err != nil {
+	if err = m.sendMarkAsReadNotification(ctx, req.ConversationID, conversations[0].ConversationType, req.UserID, m.conversationAndGetRecvID(conversations[0], req.UserID), req.Seqs, hasReadSeq); err != nil {
 		return
 	}
 	return &msg.MarkMsgsAsReadResp{}, nil
 }
 
-func (m *msgServer) sendMarkAsReadNotification(ctx context.Context, conversationID string, sesstionType int32, sendID, recvID string, seqs []int64) error {
+func (m *msgServer) sendMarkAsReadNotification(ctx context.Context, conversationID string, sesstionType int32, sendID, recvID string, seqs []int64, hasReadSeq int64) error {
 	tips := &sdkws.MarkAsReadTips{
 		MarkAsReadUserID: sendID,
 		ConversationID:   conversationID,
 		Seqs:             seqs,
+		HasReadSeq:       hasReadSeq,
 	}
 	m.notificationSender.NotificationWithSesstionType(ctx, sendID, recvID, constant.HasReadReceipt, sesstionType, tips)
 	return nil

internal/rpc/msg/send.go

@@ -36,7 +36,7 @@ func (m *msgServer) SendMsg(ctx context.Context, req *pbMsg.SendMsgReq) (resp *p
 func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *pbMsg.SendMsgReq) (resp *pbMsg.SendMsgResp, err error) {
 	resp = &pbMsg.SendMsgResp{}
 	promePkg.Inc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
-	if _, err = m.messageVerification(ctx, req); err != nil {
+	if err = m.messageVerification(ctx, req); err != nil {
 		promePkg.Inc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
 		return nil, err
 	}
@@ -70,8 +70,7 @@ func (m *msgServer) sendMsgNotification(ctx context.Context, req *pbMsg.SendMsgR
 
 func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *pbMsg.SendMsgReq) (resp *pbMsg.SendMsgResp, err error) {
 	promePkg.Inc(promePkg.SingleChatMsgRecvSuccessCounter)
-	_, err = m.messageVerification(ctx, req)
-	if err != nil {
+	if err := m.messageVerification(ctx, req); err != nil {
 		return nil, err
 	}
 	var isSend bool = true

internal/rpc/msg/server.go

@@ -103,14 +103,6 @@ func (m *msgServer) initPrometheus() {
 	prome.NewWorkSuperGroupChatMsgProcessFailedCounter()
 }
 
-func (m *msgServer) getConversationAndGetRecvID(ctx context.Context, userID, conversationID string) (recvID string, err error) {
-	conversations, err := m.Conversation.GetConversationsByConversationID(ctx, []string{conversationID})
-	if err != nil {
-		return
-	}
-	return m.conversationAndGetRecvID(conversations[0], userID), nil
-}
-
 func (m *msgServer) conversationAndGetRecvID(conversation *conversation.Conversation, userID string) (recvID string) {
 	if conversation.ConversationType == constant.SingleChatType || conversation.ConversationType == constant.NotificationChatType {
 		if userID == conversation.OwnerUserID {

internal/rpc/msg/verify.go

@@ -35,112 +35,75 @@ type MessageRevoked struct {
 	Seq                         uint32 `json:"seq"`
 }
 
-func (m *msgServer) userIsMuteAndIsAdminInGroup(ctx context.Context, groupID, userID string) (isMute bool, err error) {
-	groupMemberInfo, err := m.Group.GetGroupMemberInfo(ctx, groupID, userID)
-	if err != nil {
-		return false, err
-	}
-	if groupMemberInfo.MuteEndTime >= time.Now().Unix() {
-		return true, nil
-	}
-	return false, nil
-}
-
-// 如果禁言了，再看下是否群管理员
-func (m *msgServer) groupIsMuted(ctx context.Context, groupID string, userID string) (bool, bool, error) {
-	groupInfo, err := m.Group.GetGroupInfo(ctx, groupID)
-	if err != nil {
-		return false, false, err
-	}
-
-	if groupInfo.Status == constant.GroupStatusMuted {
-		groupMemberInfo, err := m.Group.GetGroupMemberInfo(ctx, groupID, userID)
-		if err != nil {
-			return false, false, err
-		}
-		return true, groupMemberInfo.RoleLevel > constant.GroupOrdinaryUsers, nil
-	}
-	return false, false, nil
-}
-
-func (m *msgServer) GetGroupMemberIDs(ctx context.Context, groupID string) (groupMemberIDs []string, err error) {
-	return m.GroupLocalCache.GetGroupMemberIDs(ctx, groupID)
-}
-
-func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgReq) ([]string, error) {
+func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgReq) error {
 	switch data.MsgData.SessionType {
 	case constant.SingleChatType:
 		if utils.IsContain(data.MsgData.SendID, config.Config.Manager.AppManagerUid) {
-			return nil, nil
+			return nil
 		}
 		if data.MsgData.ContentType <= constant.NotificationEnd && data.MsgData.ContentType >= constant.NotificationBegin {
-			return nil, nil
+			return nil
 		}
 		black, err := m.black.IsBlocked(ctx, data.MsgData.SendID, data.MsgData.RecvID)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		if black {
-			return nil, errs.ErrBlockedByPeer.Wrap()
+			return errs.ErrBlockedByPeer.Wrap()
 		}
 		if *config.Config.MessageVerify.FriendVerify {
 			friend, err := m.friend.IsFriend(ctx, data.MsgData.SendID, data.MsgData.RecvID)
 			if err != nil {
-				return nil, err
+				return err
 			}
 			if !friend {
-				return nil, errs.ErrNotPeersFriend.Wrap()
+				return errs.ErrNotPeersFriend.Wrap()
 			}
-			return nil, nil
+			return nil
 		}
-		return nil, nil
+		return nil
 	case constant.SuperGroupChatType:
-		groupInfo, err := m.Group.GetGroupInfo(ctx, data.MsgData.GroupID)
+		groupInfo, err := m.Group.GetGroupInfoCache(ctx, data.MsgData.GroupID)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		if groupInfo.Status == constant.GroupStatusDismissed && data.MsgData.ContentType != constant.GroupDismissedNotification {
-			return nil, errs.ErrDismissedAlready.Wrap()
+			return errs.ErrDismissedAlready.Wrap()
 		}
 		if groupInfo.GroupType == constant.SuperGroup {
-			return nil, nil
-		}
-		userIDList, err := m.GetGroupMemberIDs(ctx, data.MsgData.GroupID)
-		if err != nil {
-			return nil, err
+			return nil
 		}
 		if utils.IsContain(data.MsgData.SendID, config.Config.Manager.AppManagerUid) {
-			return nil, nil
+			return nil
 		}
 		if data.MsgData.ContentType <= constant.NotificationEnd && data.MsgData.ContentType >= constant.NotificationBegin {
-			return userIDList, nil
+			return nil
 		} else {
-			if !utils.IsContain(data.MsgData.SendID, userIDList) {
-				return nil, errs.ErrNotInGroupYet.Wrap()
+			memberIDs, err := m.GroupLocalCache.GetGroupMemberIDs(ctx, data.MsgData.GroupID)
+			if err != nil {
+				return err
+			}
+			if !utils.IsContain(data.MsgData.SendID, memberIDs) {
+				return errs.ErrNotInGroupYet.Wrap()
 			}
 		}
-		isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID)
+		groupMemberInfo, err := m.Group.GetGroupMemberCache(ctx, data.MsgData.GroupID, data.MsgData.SendID)
 		if err != nil {
-			return nil, err
+			return err
 		}
-		if isMute {
-			return nil, errs.ErrMutedInGroup.Wrap()
+		if groupMemberInfo.RoleLevel > constant.GroupOrdinaryUsers {
+			return nil
+		} else {
+			if groupMemberInfo.MuteEndTime >= time.Now().Unix() {
+				return errs.ErrMutedInGroup.Wrap()
+			}
+			if groupInfo.Status == constant.GroupStatusMuted {
+				return errs.ErrMutedGroup.Wrap()
+			}
 		}
-
-		isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID)
-		if err != nil {
-			return nil, err
-		}
-		if isAdmin {
-			return userIDList, nil
-		}
-		if isMute {
-			return nil, errs.ErrMutedGroup.Wrap()
-		}
-		return userIDList, nil
-
+		return nil
 	default:
-		return nil, nil
+		return nil
 	}
 }
 func (m *msgServer) encapsulateMsgData(msg *sdkws.MsgData) {