Merge branch 'main' of github.com:openimsdk/open-im-server into v3.8-js-sdk-only

internal/api/conversation.go

@@ -62,3 +62,11 @@ func (o *ConversationApi) GetIncrementalConversation(c *gin.Context) {
 func (o *ConversationApi) GetOwnerConversation(c *gin.Context) {
 	a2r.Call(conversation.ConversationClient.GetOwnerConversation, o.Client, c)
 }
+
+func (o *ConversationApi) GetNotNotifyConversationIDs(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.GetNotNotifyConversationIDs, o.Client, c)
+}
+
+func (o *ConversationApi) GetPinnedConversationIDs(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.GetPinnedConversationIDs, o.Client, c)
+}

internal/api/friend.go

@@ -72,6 +72,10 @@ func (o *FriendApi) GetPaginationBlacks(c *gin.Context) {
 	a2r.Call(relation.FriendClient.GetPaginationBlacks, o.Client, c)
 }
 
+func (o *FriendApi) GetSpecifiedBlacks(c *gin.Context) {
+	a2r.Call(relation.FriendClient.GetSpecifiedBlacks, o.Client, c)
+}
+
 func (o *FriendApi) RemoveBlack(c *gin.Context) {
 	a2r.Call(relation.FriendClient.RemoveBlack, o.Client, c)
 }

internal/api/group.go

@@ -67,6 +67,10 @@ func (o *GroupApi) GetGroupUsersReqApplicationList(c *gin.Context) {
 	a2r.Call(group.GroupClient.GetGroupUsersReqApplicationList, o.Client, c)
 }
 
+func (o *GroupApi) GetSpecifiedUserGroupRequestInfo(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetSpecifiedUserGroupRequestInfo, o.Client, c)
+}
+
 func (o *GroupApi) GetGroupsInfo(c *gin.Context) {
 	a2r.Call(group.GroupClient.GetGroupsInfo, o.Client, c)
 	//a2r.Call(group.GroupClient.GetGroupsInfo, o.Client, c, a2r.NewNilReplaceOption(group.GroupClient.GetGroupsInfo))

internal/api/jssdk/jssdk.go

@@ -0,0 +1,204 @@
+package jssdk
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/openimsdk/protocol/conversation"
+	"github.com/openimsdk/protocol/msg"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/a2r"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/datautil"
+	"sort"
+)
+
+const (
+	maxGetActiveConversation     = 500
+	defaultGetActiveConversation = 100
+)
+
+func NewJSSdkApi(msg msg.MsgClient, conv conversation.ConversationClient) *JSSdk {
+	return &JSSdk{
+		msg:  msg,
+		conv: conv,
+	}
+}
+
+type JSSdk struct {
+	msg  msg.MsgClient
+	conv conversation.ConversationClient
+}
+
+func (x *JSSdk) GetActiveConversations(c *gin.Context) {
+	call(c, x.getActiveConversations)
+}
+
+func (x *JSSdk) GetConversations(c *gin.Context) {
+	call(c, x.getConversations)
+}
+
+func (x *JSSdk) getActiveConversations(ctx *gin.Context) (*ConversationsResp, error) {
+	req, err := a2r.ParseRequest[ActiveConversationsReq](ctx)
+	if err != nil {
+		return nil, err
+	}
+	if req.Count <= 0 || req.Count > maxGetActiveConversation {
+		req.Count = defaultGetActiveConversation
+	}
+	opUserID := mcontext.GetOpUserID(ctx)
+	conversationIDs, err := field(ctx, x.conv.GetConversationIDs,
+		&conversation.GetConversationIDsReq{UserID: opUserID}, (*conversation.GetConversationIDsResp).GetConversationIDs)
+	if err != nil {
+		return nil, err
+	}
+	if len(conversationIDs) == 0 {
+		return &ConversationsResp{}, nil
+	}
+	readSeq, err := field(ctx, x.msg.GetHasReadSeqs,
+		&msg.GetHasReadSeqsReq{UserID: opUserID, ConversationIDs: conversationIDs}, (*msg.SeqsInfoResp).GetMaxSeqs)
+	if err != nil {
+		return nil, err
+	}
+	activeConversation, err := field(ctx, x.msg.GetActiveConversation,
+		&msg.GetActiveConversationReq{ConversationIDs: conversationIDs}, (*msg.GetActiveConversationResp).GetConversations)
+	if err != nil {
+		return nil, err
+	}
+	if len(activeConversation) == 0 {
+		return &ConversationsResp{}, nil
+	}
+	sortConversations := sortActiveConversations{
+		Conversation: activeConversation,
+	}
+	if len(activeConversation) > 1 {
+		pinnedConversationIDs, err := field(ctx, x.conv.GetPinnedConversationIDs,
+			&conversation.GetPinnedConversationIDsReq{UserID: opUserID}, (*conversation.GetPinnedConversationIDsResp).GetConversationIDs)
+		if err != nil {
+			return nil, err
+		}
+		sortConversations.PinnedConversationIDs = datautil.SliceSet(pinnedConversationIDs)
+	}
+	sort.Sort(&sortConversations)
+	sortList := sortConversations.Top(req.Count)
+	conversations, err := field(ctx, x.conv.GetConversations,
+		&conversation.GetConversationsReq{
+			OwnerUserID: opUserID,
+			ConversationIDs: datautil.Slice(sortList, func(c *msg.ActiveConversation) string {
+				return c.ConversationID
+			})}, (*conversation.GetConversationsResp).GetConversations)
+	if err != nil {
+		return nil, err
+	}
+	msgs, err := field(ctx, x.msg.GetSeqMessage,
+		&msg.GetSeqMessageReq{
+			UserID: opUserID,
+			Conversations: datautil.Slice(sortList, func(c *msg.ActiveConversation) *msg.ConversationSeqs {
+				return &msg.ConversationSeqs{
+					ConversationID: c.ConversationID,
+					Seqs:           []int64{c.MaxSeq},
+				}
+			}),
+		}, (*msg.GetSeqMessageResp).GetMsgs)
+	if err != nil {
+		return nil, err
+	}
+	conversationMap := datautil.SliceToMap(conversations, func(c *conversation.Conversation) string {
+		return c.ConversationID
+	})
+	resp := make([]ConversationMsg, 0, len(sortList))
+	for _, c := range sortList {
+		conv, ok := conversationMap[c.ConversationID]
+		if !ok {
+			continue
+		}
+		var lastMsg *sdkws.MsgData
+		if msgList, ok := msgs[c.ConversationID]; ok && len(msgList.Msgs) > 0 {
+			lastMsg = msgList.Msgs[0]
+		}
+		resp = append(resp, ConversationMsg{
+			Conversation: conv,
+			LastMsg:      lastMsg,
+			MaxSeq:       c.MaxSeq,
+			ReadSeq:      readSeq[c.ConversationID],
+		})
+	}
+	var unreadCount int64
+	for _, c := range activeConversation {
+		count := c.MaxSeq - readSeq[c.ConversationID]
+		if count > 0 {
+			unreadCount += count
+		}
+	}
+	return &ConversationsResp{
+		Conversations: resp,
+		UnreadCount:   unreadCount,
+	}, nil
+}
+
+func (x *JSSdk) getConversations(ctx *gin.Context) (*ConversationsResp, error) {
+	req, err := a2r.ParseRequest[conversation.GetConversationsReq](ctx)
+	if err != nil {
+		return nil, err
+	}
+	req.OwnerUserID = mcontext.GetOpUserID(ctx)
+	conversations, err := field(ctx, x.conv.GetConversations, req, (*conversation.GetConversationsResp).GetConversations)
+	if err != nil {
+		return nil, err
+	}
+	if len(conversations) == 0 {
+		return &ConversationsResp{}, nil
+	}
+	req.ConversationIDs = datautil.Slice(conversations, func(c *conversation.Conversation) string {
+		return c.ConversationID
+	})
+	maxSeqs, err := field(ctx, x.msg.GetMaxSeqs,
+		&msg.GetMaxSeqsReq{ConversationIDs: req.ConversationIDs}, (*msg.SeqsInfoResp).GetMaxSeqs)
+	if err != nil {
+		return nil, err
+	}
+	readSeqs, err := field(ctx, x.msg.GetHasReadSeqs,
+		&msg.GetHasReadSeqsReq{UserID: req.OwnerUserID, ConversationIDs: req.ConversationIDs}, (*msg.SeqsInfoResp).GetMaxSeqs)
+	if err != nil {
+		return nil, err
+	}
+	conversationSeqs := make([]*msg.ConversationSeqs, 0, len(conversations))
+	for _, c := range conversations {
+		if seq := maxSeqs[c.ConversationID]; seq > 0 {
+			conversationSeqs = append(conversationSeqs, &msg.ConversationSeqs{
+				ConversationID: c.ConversationID,
+				Seqs:           []int64{seq},
+			})
+		}
+	}
+	var msgs map[string]*sdkws.PullMsgs
+	if len(conversationSeqs) > 0 {
+		msgs, err = field(ctx, x.msg.GetSeqMessage,
+			&msg.GetSeqMessageReq{UserID: req.OwnerUserID, Conversations: conversationSeqs}, (*msg.GetSeqMessageResp).GetMsgs)
+		if err != nil {
+			return nil, err
+		}
+	}
+	resp := make([]ConversationMsg, 0, len(conversations))
+	for _, c := range conversations {
+		var lastMsg *sdkws.MsgData
+		if msgList, ok := msgs[c.ConversationID]; ok && len(msgList.Msgs) > 0 {
+			lastMsg = msgList.Msgs[0]
+		}
+		resp = append(resp, ConversationMsg{
+			Conversation: c,
+			LastMsg:      lastMsg,
+			MaxSeq:       maxSeqs[c.ConversationID],
+			ReadSeq:      readSeqs[c.ConversationID],
+		})
+	}
+	var unreadCount int64
+	for conversationID, maxSeq := range maxSeqs {
+		count := maxSeq - readSeqs[conversationID]
+		if count > 0 {
+			unreadCount += count
+		}
+	}
+	return &ConversationsResp{
+		Conversations: resp,
+		UnreadCount:   unreadCount,
+	}, nil
+}

internal/api/jssdk/sort.go

@@ -0,0 +1,33 @@
+package jssdk
+
+import "github.com/openimsdk/protocol/msg"
+
+type sortActiveConversations struct {
+	Conversation          []*msg.ActiveConversation
+	PinnedConversationIDs map[string]struct{}
+}
+
+func (s sortActiveConversations) Top(limit int) []*msg.ActiveConversation {
+	if limit > 0 && len(s.Conversation) > limit {
+		return s.Conversation[:limit]
+	}
+	return s.Conversation
+}
+
+func (s sortActiveConversations) Len() int {
+	return len(s.Conversation)
+}
+
+func (s sortActiveConversations) Less(i, j int) bool {
+	iv, jv := s.Conversation[i], s.Conversation[j]
+	_, ip := s.PinnedConversationIDs[iv.ConversationID]
+	_, jp := s.PinnedConversationIDs[jv.ConversationID]
+	if ip != jp {
+		return ip
+	}
+	return iv.LastTime > jv.LastTime
+}
+
+func (s sortActiveConversations) Swap(i, j int) {
+	s.Conversation[i], s.Conversation[j] = s.Conversation[j], s.Conversation[i]
+}

internal/api/jssdk/stu.go

@@ -0,0 +1,22 @@
+package jssdk
+
+import (
+	"github.com/openimsdk/protocol/conversation"
+	"github.com/openimsdk/protocol/sdkws"
+)
+
+type ActiveConversationsReq struct {
+	Count int `json:"count"`
+}
+
+type ConversationMsg struct {
+	Conversation *conversation.Conversation `json:"conversation"`
+	LastMsg      *sdkws.MsgData             `json:"lastMsg"`
+	MaxSeq       int64                      `json:"maxSeq"`
+	ReadSeq      int64                      `json:"readSeq"`
+}
+
+type ConversationsResp struct {
+	UnreadCount   int64             `json:"unreadCount"`
+	Conversations []ConversationMsg `json:"conversations"`
+}

internal/api/jssdk/tools.go

@@ -0,0 +1,26 @@
+package jssdk
+
+import (
+	"context"
+	"github.com/gin-gonic/gin"
+	"github.com/openimsdk/tools/apiresp"
+	"google.golang.org/grpc"
+)
+
+func field[A, B, C any](ctx context.Context, fn func(ctx context.Context, req *A, opts ...grpc.CallOption) (*B, error), req *A, get func(*B) C) (C, error) {
+	resp, err := fn(ctx, req)
+	if err != nil {
+		var c C
+		return c, err
+	}
+	return get(resp), nil
+}
+
+func call[R any](c *gin.Context, fn func(ctx *gin.Context) (R, error)) {
+	resp, err := fn(c)
+	if err != nil {
+		apiresp.GinError(c, err)
+		return
+	}
+	apiresp.GinSuccess(c, resp)
+}

internal/api/jssdk_test.go

@@ -0,0 +1,37 @@
+package api
+
+import (
+	"github.com/openimsdk/protocol/msg"
+	"sort"
+	"testing"
+)
+
+func TestName(t *testing.T) {
+	val := sortActiveConversations{
+		Conversation: []*msg.ActiveConversation{
+			{
+				ConversationID: "100",
+				LastTime:       100,
+			},
+			{
+				ConversationID: "200",
+				LastTime:       200,
+			},
+			{
+				ConversationID: "300",
+				LastTime:       300,
+			},
+			{
+				ConversationID: "400",
+				LastTime:       400,
+			},
+		},
+		//PinnedConversationIDs: map[string]struct{}{
+		//	"100": {},
+		//	"300": {},
+		//},
+	}
+	sort.Sort(&val)
+	t.Log(val)
+
+}

internal/api/router.go

@@ -2,6 +2,8 @@ package api
 
 import (
 	"fmt"
+	"github.com/openimsdk/open-im-server/v3/internal/api/jssdk"
+
 	"github.com/gin-contrib/gzip"
 
 	"github.com/gin-gonic/gin"
@@ -74,6 +76,7 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 	r.Use(prommetricsGin(), gin.Recovery(), mw.CorsHandler(), mw.GinParseOperationID(), GinParseToken(authRpc))
 	u := NewUserApi(*userRpc)
 	m := NewMessageApi(messageRpc, userRpc, config.Share.IMAdminUserID)
+	j := jssdk.NewJSSdkApi(messageRpc.Client, conversationRpc.Client)
 	userRouterGroup := r.Group("/user")
 	{
 		userRouterGroup.POST("/user_register", u.UserRegister)
@@ -115,6 +118,7 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		friendRouterGroup.POST("/set_friend_remark", f.SetFriendRemark)
 		friendRouterGroup.POST("/add_black", f.AddBlack)
 		friendRouterGroup.POST("/get_black_list", f.GetPaginationBlacks)
+		friendRouterGroup.POST("/get_specified_blacks", f.GetSpecifiedBlacks)
 		friendRouterGroup.POST("/remove_black", f.RemoveBlack)
 		friendRouterGroup.POST("/get_incremental_blacks", f.GetIncrementalBlacks)
 		friendRouterGroup.POST("/import_friend", f.ImportFriends)
@@ -138,6 +142,7 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		groupRouterGroup.POST("/get_recv_group_applicationList", g.GetRecvGroupApplicationList)
 		groupRouterGroup.POST("/get_user_req_group_applicationList", g.GetUserReqGroupApplicationList)
 		groupRouterGroup.POST("/get_group_users_req_application_list", g.GetGroupUsersReqApplicationList)
+		groupRouterGroup.POST("/get_specified_user_group_request_info", g.GetSpecifiedUserGroupRequestInfo)
 		groupRouterGroup.POST("/get_groups_info", g.GetGroupsInfo)
 		groupRouterGroup.POST("/kick_group", g.KickGroupMember)
 		groupRouterGroup.POST("/get_group_members_info", g.GetGroupMembersInfo)
@@ -230,6 +235,8 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		conversationGroup.POST("/get_full_conversation_ids", c.GetFullOwnerConversationIDs)
 		conversationGroup.POST("/get_incremental_conversations", c.GetIncrementalConversation)
 		conversationGroup.POST("/get_owner_conversation", c.GetOwnerConversation)
+		conversationGroup.POST("/get_not_notify_conversation_ids", c.GetNotNotifyConversationIDs)
+		conversationGroup.POST("/get_pinned_conversation_ids", c.GetPinnedConversationIDs)
 	}
 
 	statisticsGroup := r.Group("/statistics")
@@ -239,6 +246,11 @@ func newGinRouter(disCov discovery.SvcDiscoveryRegistry, config *Config) *gin.En
 		statisticsGroup.POST("/group/create", g.GroupCreateCount)
 		statisticsGroup.POST("/group/active", m.GetActiveGroup)
 	}
+
+	jssdk := r.Group("/jssdk")
+	jssdk.POST("/get_conversations", j.GetConversations)
+	jssdk.POST("/get_active_conversations", j.GetActiveConversations)
+
 	return r
 }
 
@@ -275,7 +287,6 @@ func GinParseToken(authRPC *rpcclient.Auth) gin.HandlerFunc {
 
 // Whitelist api not parse token
 var Whitelist = []string{
-	"/user/user_register",
 	"/auth/user_token",
 	"/auth/parse_token",
 }

internal/msggateway/ws_server.go

@@ -321,7 +321,7 @@ func (ws *WsServer) KickUserConn(client *Client) error {
 }
 
 func (ws *WsServer) multiTerminalLoginChecker(clientOK bool, oldClients []*Client, newClient *Client) {
-	switch ws.msgGatewayConfig.MsgGateway.MultiLoginPolicy {
+	switch ws.msgGatewayConfig.Share.MultiLoginPolicy {
 	case constant.DefalutNotKick:
 	case constant.PCAndOther:
 		if constant.PlatformIDToClass(newClient.PlatformID) == constant.TerminalPC {

internal/push/offlinepush/fcm/push.go

@@ -22,8 +22,8 @@ import (
 	"path/filepath"
 	"strings"
 
-	firebase "firebase.google.com/go"
-	"firebase.google.com/go/messaging"
+	firebase "firebase.google.com/go/v4"
+	"firebase.google.com/go/v4/messaging"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/protocol/constant"
@@ -99,7 +99,7 @@ func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string,
 		apns := &messaging.APNSConfig{Payload: &messaging.APNSPayload{Aps: &messaging.Aps{Sound: opts.IOSPushSound}}}
 		messageCount := len(messages)
 		if messageCount >= SinglePushCountLimit {
-			response, err := f.fcmMsgCli.SendAll(ctx, messages)
+			response, err := f.fcmMsgCli.SendEach(ctx, messages)
 			if err != nil {
 				Fail = Fail + messageCount
 				// Record push error
@@ -154,7 +154,7 @@ func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string,
 	}
 	messageCount := len(messages)
 	if messageCount > 0 {
-		response, err := f.fcmMsgCli.SendAll(ctx, messages)
+		response, err := f.fcmMsgCli.SendEach(ctx, messages)
 		if err != nil {
 			Fail = Fail + messageCount
 		} else {

internal/rpc/auth/auth.go

@@ -64,6 +64,7 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 			redis2.NewTokenCacheModel(rdb, config.RpcConfig.TokenPolicy.Expire),
 			config.Share.Secret,
 			config.RpcConfig.TokenPolicy.Expire,
+			config.Share.MultiLoginPolicy,
 		),
 		config: config,
 	})

internal/rpc/conversation/conversation.go

@@ -710,3 +710,19 @@ func (c *conversationServer) GetConversationsNeedDestructMsgs(ctx context.Contex
 
 	return &pbconversation.GetConversationsNeedDestructMsgsResp{Conversations: convert.ConversationsDB2Pb(temp)}, nil
 }
+
+func (c *conversationServer) GetNotNotifyConversationIDs(ctx context.Context, req *pbconversation.GetNotNotifyConversationIDsReq) (*pbconversation.GetNotNotifyConversationIDsResp, error) {
+	conversationIDs, err := c.conversationDatabase.GetNotNotifyConversationIDs(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	return &pbconversation.GetNotNotifyConversationIDsResp{ConversationIDs: conversationIDs}, nil
+}
+
+func (c *conversationServer) GetPinnedConversationIDs(ctx context.Context, req *pbconversation.GetPinnedConversationIDsReq) (*pbconversation.GetPinnedConversationIDsResp, error) {
+	conversationIDs, err := c.conversationDatabase.GetPinnedConversationIDs(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	return &pbconversation.GetPinnedConversationIDsResp{ConversationIDs: conversationIDs}, nil
+}

internal/rpc/group/callback.go

@@ -218,6 +218,7 @@ func (s *groupServer) webhookAfterKickGroupMember(ctx context.Context, after *co
 		CallbackCommand: callbackstruct.CallbackAfterKickGroupCommand,
 		GroupID:         req.GroupID,
 		KickedUserIDs:   req.KickedUserIDs,
+		Reason:          req.Reason,
 	}
 	s.webhookClient.AsyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, &callbackstruct.CallbackKillGroupMemberResp{}, after)
 }

internal/rpc/group/group.go

@@ -167,11 +167,11 @@ func (g *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
 	return nil
 }
 
-func (g *groupServer) GetPublicUserInfoMap(ctx context.Context, userIDs []string, complete bool) (map[string]*sdkws.PublicUserInfo, error) {
+func (g *groupServer) GetPublicUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.PublicUserInfo, error) {
 	if len(userIDs) == 0 {
 		return map[string]*sdkws.PublicUserInfo{}, nil
 	}
-	users, err := g.user.GetPublicUserInfos(ctx, userIDs, complete)
+	users, err := g.user.GetPublicUserInfos(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -696,7 +696,7 @@ func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.
 		userIDs = append(userIDs, gr.UserID)
 	}
 	userIDs = datautil.Distinct(userIDs)
-	userMap, err := g.user.GetPublicUserInfoMap(ctx, userIDs, true)
+	userMap, err := g.user.GetPublicUserInfoMap(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1685,36 +1685,51 @@ func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *
 	if err != nil {
 		return nil, err
 	}
+
 	if len(requests) == 0 {
 		return &pbgroup.GetGroupUsersReqApplicationListResp{}, nil
 	}
+
 	groupIDs := datautil.Distinct(datautil.Slice(requests, func(e *model.GroupRequest) string {
 		return e.GroupID
 	}))
+
 	groups, err := g.db.FindGroup(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
+
 	groupMap := datautil.SliceToMap(groups, func(e *model.Group) string {
 		return e.GroupID
 	})
+
 	if ids := datautil.Single(groupIDs, datautil.Keys(groupMap)); len(ids) > 0 {
 		return nil, servererrs.ErrGroupIDNotFound.WrapMsg(strings.Join(ids, ","))
 	}
+
+	userMap, err := g.user.GetPublicUserInfoMap(ctx, req.UserIDs)
+	if err != nil {
+		return nil, err
+	}
+
 	owners, err := g.db.FindGroupsOwner(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
+
 	if err := g.PopulateGroupMember(ctx, owners...); err != nil {
 		return nil, err
 	}
+
 	ownerMap := datautil.SliceToMap(owners, func(e *model.GroupMember) string {
 		return e.GroupID
 	})
+
 	groupMemberNum, err := g.db.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
+
 	return &pbgroup.GetGroupUsersReqApplicationListResp{
 		Total: int64(len(requests)),
 		GroupRequests: datautil.Slice(requests, func(e *model.GroupRequest) *sdkws.GroupRequest {
@@ -1722,7 +1737,71 @@ func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *
 			if owner, ok := ownerMap[e.GroupID]; ok {
 				ownerUserID = owner.UserID
 			}
-			return convert.Db2PbGroupRequest(e, nil, convert.Db2PbGroupInfo(groupMap[e.GroupID], ownerUserID, groupMemberNum[e.GroupID]))
+
+			var userInfo *sdkws.PublicUserInfo
+			if user, ok := userMap[e.UserID]; !ok {
+				userInfo = user
+			}
+
+			return convert.Db2PbGroupRequest(e, userInfo, convert.Db2PbGroupInfo(groupMap[e.GroupID], ownerUserID, groupMemberNum[e.GroupID]))
 		}),
 	}, nil
 }
+
+func (g *groupServer) GetSpecifiedUserGroupRequestInfo(ctx context.Context, req *pbgroup.GetSpecifiedUserGroupRequestInfoReq) (*pbgroup.GetSpecifiedUserGroupRequestInfoResp, error) {
+	opUserID := mcontext.GetOpUserID(ctx)
+
+	owners, err := g.db.FindGroupsOwner(ctx, []string{req.GroupID})
+	if err != nil {
+		return nil, err
+	}
+
+	if req.UserID != opUserID {
+		req.UserID = mcontext.GetOpUserID(ctx)
+		adminIDs, err := g.db.GetGroupRoleLevelMemberIDs(ctx, req.GroupID, constant.GroupAdmin)
+		if err != nil {
+			return nil, err
+		}
+
+		adminIDs = append(adminIDs, owners[0].UserID)
+
+		if !datautil.Contain(req.UserID, adminIDs...) {
+			return nil, errs.ErrNoPermission.WrapMsg("opUser no permission")
+		}
+	}
+	requests, err := g.db.FindGroupRequests(ctx, req.GroupID, []string{req.UserID})
+	if err != nil {
+		return nil, err
+	}
+
+	if len(requests) == 0 {
+		return &pbgroup.GetSpecifiedUserGroupRequestInfoResp{}, nil
+	}
+
+	groups, err := g.db.FindGroup(ctx, []string{req.GroupID})
+	if err != nil {
+		return nil, err
+	}
+
+	userInfos, err := g.user.GetPublicUserInfos(ctx, []string{req.UserID})
+	if err != nil {
+		return nil, err
+	}
+
+	groupMemberNum, err := g.db.MapGroupMemberNum(ctx, []string{req.GroupID})
+	if err != nil {
+		return nil, err
+	}
+
+	resp := &pbgroup.GetSpecifiedUserGroupRequestInfoResp{
+		GroupRequests: make([]*sdkws.GroupRequest, 0, len(requests)),
+	}
+
+	for _, request := range requests {
+		resp.GroupRequests = append(resp.GroupRequests, convert.Db2PbGroupRequest(request, userInfos[0], convert.Db2PbGroupInfo(groups[0], owners[0].UserID, groupMemberNum[groups[0].GroupID])))
+	}
+
+	resp.Total = uint32(len(requests))
+
+	return resp, nil
+}

internal/rpc/msg/as_read.go

@@ -55,7 +55,7 @@ func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *m
 			conversationMaxSeqMap[conversation.ConversationID] = conversation.MaxSeq
 		}
 	}
-	maxSeqs, err := m.MsgDatabase.GetMaxSeqs(ctx, conversationIDs)
+	maxSeqs, err := m.MsgDatabase.GetMaxSeqsWithTime(ctx, conversationIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -63,7 +63,8 @@ func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *m
 	for conversationID, maxSeq := range maxSeqs {
 		resp.Seqs[conversationID] = &msg.Seqs{
 			HasReadSeq: hasReadSeqs[conversationID],
-			MaxSeq:     maxSeq,
+			MaxSeq:     maxSeq.Seq,
+			MaxSeqTime: maxSeq.Time,
 		}
 		if v, ok := conversationMaxSeqMap[conversationID]; ok {
 			resp.Seqs[conversationID].MaxSeq = v

internal/rpc/msg/seq.go

@@ -16,10 +16,10 @@ package msg
 
 import (
 	"context"
+	pbmsg "github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/tools/errs"
 	"github.com/redis/go-redis/v9"
-
-	pbmsg "github.com/openimsdk/protocol/msg"
+	"sort"
 )
 
 func (m *msgServer) GetConversationMaxSeq(ctx context.Context, req *pbmsg.GetConversationMaxSeqReq) (*pbmsg.GetConversationMaxSeqResp, error) {
@@ -62,3 +62,25 @@ func (m *msgServer) SetUserConversationsMinSeq(ctx context.Context, req *pbmsg.S
 	}
 	return &pbmsg.SetUserConversationsMinSeqResp{}, nil
 }
+
+func (m *msgServer) GetActiveConversation(ctx context.Context, req *pbmsg.GetActiveConversationReq) (*pbmsg.GetActiveConversationResp, error) {
+	res, err := m.MsgDatabase.GetCacheMaxSeqWithTime(ctx, req.ConversationIDs)
+	if err != nil {
+		return nil, err
+	}
+	conversations := make([]*pbmsg.ActiveConversation, 0, len(res))
+	for conversationID, val := range res {
+		conversations = append(conversations, &pbmsg.ActiveConversation{
+			MaxSeq:         val.Seq,
+			LastTime:       val.Time,
+			ConversationID: conversationID,
+		})
+	}
+	if req.Limit > 0 {
+		sort.Sort(activeConversations(conversations))
+		if len(conversations) > int(req.Limit) {
+			conversations = conversations[:req.Limit]
+		}
+	}
+	return &pbmsg.GetActiveConversationResp{Conversations: conversations}, nil
+}

internal/rpc/msg/utils.go

@@ -15,6 +15,7 @@
 package msg
 
 import (
+	"github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/tools/errs"
 	"github.com/redis/go-redis/v9"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -28,3 +29,63 @@ func IsNotFound(err error) bool {
 		return false
 	}
 }
+
+type activeConversations []*msg.ActiveConversation
+
+func (s activeConversations) Len() int {
+	return len(s)
+}
+
+func (s activeConversations) Less(i, j int) bool {
+	return s[i].LastTime > s[j].LastTime
+}
+
+func (s activeConversations) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+//type seqTime struct {
+//	ConversationID string
+//	Seq            int64
+//	Time           int64
+//	Unread         int64
+//	Pinned         bool
+//}
+//
+//func (s seqTime) String() string {
+//	return fmt.Sprintf("<Time_%d,Unread_%d,Pinned_%t>", s.Time, s.Unread, s.Pinned)
+//}
+//
+//type seqTimes []seqTime
+//
+//func (s seqTimes) Len() int {
+//	return len(s)
+//}
+//
+//// Less sticky priority, unread priority, time descending
+//func (s seqTimes) Less(i, j int) bool {
+//	iv, jv := s[i], s[j]
+//	if iv.Pinned && (!jv.Pinned) {
+//		return true
+//	}
+//	if jv.Pinned && (!iv.Pinned) {
+//		return false
+//	}
+//	if iv.Unread > 0 && jv.Unread == 0 {
+//		return true
+//	}
+//	if jv.Unread > 0 && iv.Unread == 0 {
+//		return false
+//	}
+//	return iv.Time > jv.Time
+//}
+//
+//func (s seqTimes) Swap(i, j int) {
+//	s[i], s[j] = s[j], s[i]
+//}
+//
+//type conversationStatus struct {
+//	ConversationID string
+//	Pinned         bool
+//	Recv           bool
+//}

internal/rpc/relation/black.go

@@ -23,13 +23,17 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
 	"github.com/openimsdk/protocol/relation"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/datautil"
 )
 
 func (s *friendServer) GetPaginationBlacks(ctx context.Context, req *relation.GetPaginationBlacksReq) (resp *relation.GetPaginationBlacksResp, err error) {
-	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
+
 	total, blacks, err := s.blackDatabase.FindOwnerBlacks(ctx, req.UserID, req.Pagination)
 	if err != nil {
 		return nil, err
@@ -55,7 +59,7 @@ func (s *friendServer) IsBlack(ctx context.Context, req *relation.IsBlackReq) (*
 }
 
 func (s *friendServer) RemoveBlack(ctx context.Context, req *relation.RemoveBlackReq) (*relation.RemoveBlackResp, error) {
-	if err := s.userRpcClient.Access(ctx, req.OwnerUserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
 
@@ -64,6 +68,7 @@ func (s *friendServer) RemoveBlack(ctx context.Context, req *relation.RemoveBlac
 	}
 
 	s.notificationSender.BlackDeletedNotification(ctx, req)
+	s.webhookAfterRemoveBlack(ctx, &s.config.WebhooksConfig.AfterRemoveBlack, req)
 
 	return &relation.RemoveBlackResp{}, nil
 }
@@ -72,6 +77,11 @@ func (s *friendServer) AddBlack(ctx context.Context, req *relation.AddBlackReq)
 	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
+
+	if err := s.webhookBeforeAddBlack(ctx, &s.config.WebhooksConfig.BeforeAddBlack, req); err != nil {
+		return nil, err
+	}
+
 	_, err := s.userRpcClient.GetUsersInfo(ctx, []string{req.OwnerUserID, req.BlackUserID})
 	if err != nil {
 		return nil, err
@@ -90,3 +100,53 @@ func (s *friendServer) AddBlack(ctx context.Context, req *relation.AddBlackReq)
 	s.notificationSender.BlackAddedNotification(ctx, req)
 	return &relation.AddBlackResp{}, nil
 }
+
+func (s *friendServer) GetSpecifiedBlacks(ctx context.Context, req *relation.GetSpecifiedBlacksReq) (*relation.GetSpecifiedBlacksResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
+
+	if len(req.UserIDList) == 0 {
+		return nil, errs.ErrArgs.WrapMsg("userIDList is empty")
+	}
+
+	if datautil.Duplicate(req.UserIDList) {
+		return nil, errs.ErrArgs.WrapMsg("userIDList repeated")
+	}
+
+	userMap, err := s.userRpcClient.GetPublicUserInfoMap(ctx, req.UserIDList)
+	if err != nil {
+		return nil, err
+	}
+
+	blacks, err := s.blackDatabase.FindBlackInfos(ctx, req.OwnerUserID, req.UserIDList)
+	if err != nil {
+		return nil, err
+	}
+
+	blackMap := datautil.SliceToMap(blacks, func(e *model.Black) string {
+		return e.BlockUserID
+	})
+
+	resp := &relation.GetSpecifiedBlacksResp{
+		Blacks: make([]*sdkws.BlackInfo, 0, len(req.UserIDList)),
+	}
+
+	for _, userID := range req.UserIDList {
+		if black := blackMap[userID]; black != nil {
+			resp.Blacks = append(resp.Blacks,
+				&sdkws.BlackInfo{
+					OwnerUserID:    black.OwnerUserID,
+					CreateTime:     black.CreateTime.UnixMilli(),
+					BlackUserInfo:  userMap[userID],
+					AddSource:      black.AddSource,
+					OperatorUserID: black.OperatorUserID,
+					Ex:             black.Ex,
+				})
+		}
+	}
+
+	resp.Total = int32(len(resp.Blacks))
+
+	return resp, nil
+}

internal/rpc/relation/friend.go

@@ -228,20 +228,23 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *relation.Res
 
 // ok.
 func (s *friendServer) DeleteFriend(ctx context.Context, req *relation.DeleteFriendReq) (resp *relation.DeleteFriendResp, err error) {
-	resp = &relation.DeleteFriendResp{}
-	if err := s.userRpcClient.Access(ctx, req.OwnerUserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
+
 	_, err = s.db.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
 	if err != nil {
 		return nil, err
 	}
+
 	if err := s.db.Delete(ctx, req.OwnerUserID, []string{req.FriendUserID}); err != nil {
 		return nil, err
 	}
+
 	s.notificationSender.FriendDeletedNotification(ctx, req)
 	s.webhookAfterDeleteFriend(ctx, &s.config.WebhooksConfig.AfterDeleteFriend, req)
-	return resp, nil
+
+	return &relation.DeleteFriendResp{}, nil
 }
 
 // ok.
@@ -249,20 +252,24 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *relation.SetFri
 	if err = s.webhookBeforeSetFriendRemark(ctx, &s.config.WebhooksConfig.BeforeSetFriendRemark, req); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
-	resp = &relation.SetFriendRemarkResp{}
-	if err := s.userRpcClient.Access(ctx, req.OwnerUserID); err != nil {
+
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
+
 	_, err = s.db.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
 	if err != nil {
 		return nil, err
 	}
+
 	if err := s.db.UpdateRemark(ctx, req.OwnerUserID, req.FriendUserID, req.Remark); err != nil {
 		return nil, err
 	}
+
 	s.webhookAfterSetFriendRemark(ctx, &s.config.WebhooksConfig.AfterSetFriendRemark, req)
 	s.notificationSender.FriendRemarkSetNotification(ctx, req.OwnerUserID, req.FriendUserID)
-	return resp, nil
+
+	return &relation.SetFriendRemarkResp{}, nil
 }
 
 // ok.
@@ -309,7 +316,7 @@ func (s *friendServer) GetDesignatedFriendsApply(ctx context.Context,
 
 // Get received friend requests (i.e., those initiated by others).
 func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *relation.GetPaginationFriendsApplyToReq) (resp *relation.GetPaginationFriendsApplyToResp, err error) {
-	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
 
@@ -331,18 +338,23 @@ func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *rel
 
 func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *relation.GetPaginationFriendsApplyFromReq) (resp *relation.GetPaginationFriendsApplyFromResp, err error) {
 	resp = &relation.GetPaginationFriendsApplyFromResp{}
-	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
+
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
+
 	total, friendRequests, err := s.db.PageFriendRequestFromMe(ctx, req.UserID, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
+
 	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userRpcClient.GetUsersInfoMap)
 	if err != nil {
 		return nil, err
 	}
+
 	resp.Total = int32(total)
+
 	return resp, nil
 }
 
@@ -357,31 +369,37 @@ func (s *friendServer) IsFriend(ctx context.Context, req *relation.IsFriendReq)
 }
 
 func (s *friendServer) GetPaginationFriends(ctx context.Context, req *relation.GetPaginationFriendsReq) (resp *relation.GetPaginationFriendsResp, err error) {
-	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
+
 	total, friends, err := s.db.PageOwnerFriends(ctx, req.UserID, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
+
 	resp = &relation.GetPaginationFriendsResp{}
 	resp.FriendsInfo, err = convert.FriendsDB2Pb(ctx, friends, s.userRpcClient.GetUsersInfoMap)
 	if err != nil {
 		return nil, err
 	}
+
 	resp.Total = int32(total)
+
 	return resp, nil
 }
 
 func (s *friendServer) GetFriendIDs(ctx context.Context, req *relation.GetFriendIDsReq) (resp *relation.GetFriendIDsResp, err error) {
-	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
+
 	resp = &relation.GetFriendIDsResp{}
 	resp.FriendIDs, err = s.db.FindFriendUserIDs(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
+
 	return resp, nil
 }
 
@@ -389,35 +407,45 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *relatio
 	if len(req.UserIDList) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("userIDList is empty")
 	}
+
 	if datautil.Duplicate(req.UserIDList) {
 		return nil, errs.ErrArgs.WrapMsg("userIDList repeated")
 	}
+
 	userMap, err := s.userRpcClient.GetUsersInfoMap(ctx, req.UserIDList)
 	if err != nil {
 		return nil, err
 	}
+
 	friends, err := s.db.FindFriendsWithError(ctx, req.OwnerUserID, req.UserIDList)
 	if err != nil {
 		return nil, err
 	}
+
 	blacks, err := s.blackDatabase.FindBlackInfos(ctx, req.OwnerUserID, req.UserIDList)
 	if err != nil {
 		return nil, err
 	}
+
 	friendMap := datautil.SliceToMap(friends, func(e *model.Friend) string {
 		return e.FriendUserID
 	})
+
 	blackMap := datautil.SliceToMap(blacks, func(e *model.Black) string {
 		return e.BlockUserID
 	})
+
 	resp := &relation.GetSpecifiedFriendsInfoResp{
 		Infos: make([]*relation.GetSpecifiedFriendsInfoInfo, 0, len(req.UserIDList)),
 	}
+
 	for _, userID := range req.UserIDList {
 		user := userMap[userID]
+
 		if user == nil {
 			continue
 		}
+
 		var friendInfo *sdkws.FriendInfo
 		if friend := friendMap[userID]; friend != nil {
 			friendInfo = &sdkws.FriendInfo{
@@ -430,6 +458,7 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *relatio
 				IsPinned:       friend.IsPinned,
 			}
 		}
+
 		var blackInfo *sdkws.BlackInfo
 		if black := blackMap[userID]; black != nil {
 			blackInfo = &sdkws.BlackInfo{
@@ -440,12 +469,14 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *relatio
 				Ex:             black.Ex,
 			}
 		}
+
 		resp.Infos = append(resp.Infos, &relation.GetSpecifiedFriendsInfoInfo{
 			UserInfo:   user,
 			FriendInfo: friendInfo,
 			BlackInfo:  blackInfo,
 		})
 	}
+
 	return resp, nil
 }