Update version to v3.8.3-patch.9

Co-authored-by: icey-yu <119291641+icey-yu@users.noreply.github.com>

.github/workflows/update-version-file-on-release.yml

@@ -8,19 +8,40 @@ jobs:
   update-version:
     runs-on: ubuntu-latest
     env:
-      TAG_VERSION: ${{ github.event.release.tag_name }} 
+      TAG_VERSION: ${{ github.event.release.tag_name }}
     steps:
       # Step 1: Checkout the original repository's code
       - name: Checkout code
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          # submodules: "recursive"
+
+      - name: Safe submodule initialization
+        run: |
+          echo "Checking for submodules..."
+          if [ -f .gitmodules ]; then
+            if [ -s .gitmodules ]; then
+              echo "Initializing submodules..."
+              if git submodule sync --recursive 2>/dev/null; then
+                git submodule update --init --force --recursive || {
+                  echo "Warning: Some submodules failed to initialize, continuing anyway..."
+                }
+              else
+                echo "Warning: Submodule sync failed, continuing without submodules..."
+              fi
+            else
+              echo ".gitmodules exists but is empty, skipping submodule initialization"
+            fi
+          else
+            echo "No .gitmodules file found, no submodules to initialize"
+          fi
 
       # Step 2: Set up Git with official account
       - name: Set up Git
         run: |
-          git config user.name "github-actions[bot]"
+          git config --global user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
 
       # Step 3: Check and delete existing tag
       - name: Check and delete existing tag
@@ -33,7 +54,8 @@ jobs:
       # Step 4: Update version file
       - name: Update version file
         run: |
-          echo "${{ env.TAG_VERSION }}" > version/version
+          mkdir -p version
+          echo -n "${{ env.TAG_VERSION }}" > version/version
 
       # Step 5: Commit and push changes
       - name: Commit and push changes
@@ -42,43 +64,56 @@ jobs:
         run: |
           git add version/version
           git commit -m "Update version to ${{ env.TAG_VERSION }}"
-          git push origin HEAD:${{ github.ref }}
 
-      # Step 6: Create and push tag
+      # Step 6: Update tag
-      - name: Create and push tag
+      - name: Update tag
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          git tag ${{ env.TAG_VERSION }}
+          git tag -fa ${{ env.TAG_VERSION }} -m "Update version to ${{ env.TAG_VERSION }}"
-          git push origin ${{ env.TAG_VERSION }}
+          git push origin ${{ env.TAG_VERSION }} --force
 
       # Step 7: Find and Publish Draft Release
       - name: Find and Publish Draft Release
-        uses: actions/github-script@v6
+        uses: actions/github-script@v7
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
-            // Get the list of releases
+            const { owner, repo } = context.repo;
-            const releases = await github.rest.repos.listReleases({
+            const tagName = process.env.TAG_VERSION;
-              owner: context.repo.owner,
-              repo: context.repo.repo
-            });
 
-            // Find the draft release where the title and tag_name are the same
+            try {
-            const draftRelease = releases.data.find(release => 
+              let release;
-              release.draft && release.name === release.tag_name
+              try {
-            );
+                const response = await github.rest.repos.getReleaseByTag({
-
+                  owner,
-            if (draftRelease) {
+                  repo,
-              // Publish the draft release using the release_id
+                  tag: tagName
+                });
+                release = response.data;
+              } catch (tagError) {
+                core.info(`Release not found by tag, searching all releases...`);
+                const releases = await github.rest.repos.listReleases({
+                  owner,
+                  repo,
+                  per_page: 100
+                });
+                
+                release = releases.data.find(r => r.draft && r.tag_name === tagName);            
+                if (!release) {
+                  throw new Error(`No release found with tag ${tagName}`);
+                }
+              }
+              
               await github.rest.repos.updateRelease({
-                owner: context.repo.owner,
+                owner,
-                repo: context.repo.repo,
+                repo,
-                release_id: draftRelease.id,  // Use release_id
+                release_id: release.id,
-                draft: false
+                draft: false,
+                prerelease: release.prerelease
               });
-
+              
-              core.info(`Draft Release ${draftRelease.tag_name} published successfully.`);
+              const status = release.draft ? "was draft" : "was already published";
-            } else {
+              core.info(`Release ${tagName} ensured to be published (${status}).`);
-              core.info("No matching draft release found.");
+              
-            }
+            } catch (error) {
+              core.warning(`Could not find or update release for tag ${tagName}: ${error.message}`);
+            }

Dockerfile

@@ -43,7 +43,7 @@ COPY --from=builder $SERVER_DIR/start-config.yml $SERVER_DIR/
 COPY --from=builder $SERVER_DIR/go.mod $SERVER_DIR/
 COPY --from=builder $SERVER_DIR/go.sum $SERVER_DIR/
 
-RUN go get github.com/openimsdk/gomake@v0.0.14-alpha.5
+RUN go get github.com/openimsdk/gomake@v0.0.15-alpha.5
 
 # Set the command to run when the container starts
 ENTRYPOINT ["sh", "-c", "mage start && tail -f /dev/null"]

config/share.yml

@@ -15,4 +15,8 @@ imAdminUserID: [ imAdmin ]
 # 1: For Android, iOS, Windows, Mac, and web platforms, only one instance can be online at a time
 multiLogin:
   policy: 1
-  maxNumOneEnd: 30
+  maxNumOneEnd: 30
+
+rpcMaxBodySize:
+  requestMaxBodySize: 8388608
+  responseMaxBodySize: 8388608

docker-compose.yml

@@ -63,7 +63,12 @@ services:
     restart: always
     sysctls:
       net.core.somaxconn: 1024
-    command: redis-server /usr/local/redis/config/redis.conf --requirepass openIM123 --appendonly yes
+    command: >
+      redis-server
+      --requirepass openIM123
+      --appendonly yes
+      --aof-use-rdb-preamble yes
+      --save ""
     networks:
       - openim
 
@@ -99,15 +104,62 @@ services:
     environment:
       #KAFKA_HEAP_OPTS: "-Xms128m -Xmx256m"
       TZ: Asia/Shanghai
+      # Unique identifier for the Kafka node (required in controller mode)
       KAFKA_CFG_NODE_ID: 0
+      # Defines the roles this Kafka node plays: broker, controller, or both
       KAFKA_CFG_PROCESS_ROLES: controller,broker
+      # Specifies which nodes are controller nodes for quorum voting.
+      # The syntax follows the KRaft mode (no ZooKeeper): node.id@host:port
+      # The controller listener endpoint here is kafka:9093
       KAFKA_CFG_CONTROLLER_QUORUM_VOTERS: 0@kafka:9093
-      KAFKA_CFG_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093,EXTERNAL://:9094
+      # Specifies which listener is used for controller-to-controller communication
-      KAFKA_CFG_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,EXTERNAL://localhost:19094
-      KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,EXTERNAL:PLAINTEXT,PLAINTEXT:PLAINTEXT
       KAFKA_CFG_CONTROLLER_LISTENER_NAMES: CONTROLLER
+      # Default number of partitions for new topics
       KAFKA_NUM_PARTITIONS: 8
+      # Whether to enable automatic topic creation
       KAFKA_CFG_AUTO_CREATE_TOPICS_ENABLE: "true"
+      # Kafka internal listeners; Kafka supports multiple ports with different protocols
+      # Each port is used for a specific purpose: INTERNAL for internal broker communication,
+      # CONTROLLER for controller communication, EXTERNAL for external client connections.
+      # These logical listener names are mapped to actual protocols via KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP
+      # In short, Kafka is listening on three logical ports: 9092 for internal communication,
+      # 9093 for controller traffic, and 9094 for external access.
+      KAFKA_CFG_LISTENERS: "INTERNAL://:9092,CONTROLLER://:9093,EXTERNAL://:9094"
+      # Addresses advertised to clients. INTERNAL://kafka:9092 uses the internal Docker service name 'kafka',
+      # so other containers can access Kafka via kafka:9092.
+      # EXTERNAL://localhost:19094 is the address external clients (e.g., in the LAN) should use to connect.
+      # If Kafka is deployed on a different machine than IM, 'localhost' should be replaced with the LAN IP.
+      KAFKA_CFG_ADVERTISED_LISTENERS: "INTERNAL://kafka:9092,EXTERNAL://localhost:19094"
+      # Maps logical listener names to actual protocols.
+      # Supported protocols include: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL
+      KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP: "CONTROLLER:PLAINTEXT,EXTERNAL:PLAINTEXT,INTERNAL:PLAINTEXT"
+      # Defines which listener is used for inter-broker communication within the Kafka cluster
+      KAFKA_CFG_INTER_BROKER_LISTENER_NAME: "INTERNAL"
+
+
+      # Authentication configuration variables - comment out to disable auth
+      # KAFKA_USERNAME: "openIM"
+      # KAFKA_PASSWORD: "openIM123"
+    command: >
+      /bin/sh -c '
+        if [ -n "$${KAFKA_USERNAME}" ] && [ -n "$${KAFKA_PASSWORD}" ]; then
+          echo "=== Kafka SASL Authentication ENABLED ==="
+          echo "Username: $${KAFKA_USERNAME}"
+          
+          # Set environment variables for SASL authentication
+          export KAFKA_CFG_LISTENERS="SASL_PLAINTEXT://:9092,CONTROLLER://:9093,EXTERNAL://:9094"
+          export KAFKA_CFG_ADVERTISED_LISTENERS="SASL_PLAINTEXT://kafka:9092,EXTERNAL://localhost:19094"
+          export KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP="CONTROLLER:PLAINTEXT,EXTERNAL:SASL_PLAINTEXT,SASL_PLAINTEXT:SASL_PLAINTEXT"
+          export KAFKA_CFG_SASL_ENABLED_MECHANISMS="PLAIN"
+          export KAFKA_CFG_SASL_MECHANISM_INTER_BROKER_PROTOCOL="PLAIN"
+          export KAFKA_CFG_INTER_BROKER_LISTENER_NAME="SASL_PLAINTEXT"
+          export KAFKA_CLIENT_USERS="$${KAFKA_USERNAME}"
+          export KAFKA_CLIENT_PASSWORDS="$${KAFKA_PASSWORD}"
+        fi
+        
+        # Start Kafka with the configured environment
+        exec /opt/bitnami/scripts/kafka/entrypoint.sh /opt/bitnami/scripts/kafka/run.sh
+      '
     networks:
       - openim
 

go.mod

@@ -12,8 +12,8 @@ require (
 	github.com/gorilla/websocket v1.5.1
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/openimsdk/protocol v0.0.72-alpha.78
+	github.com/openimsdk/protocol v0.0.73-alpha.12
-	github.com/openimsdk/tools v0.0.50-alpha.74
+	github.com/openimsdk/tools v0.0.50-alpha.84
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.18.0
 	github.com/stretchr/testify v1.9.0
@@ -35,7 +35,7 @@ require (
 	github.com/hashicorp/golang-lru/v2 v2.0.7
 	github.com/kelindar/bitmap v1.5.2
 	github.com/likexian/gokit v0.25.13
-	github.com/openimsdk/gomake v0.0.14-alpha.5
+	github.com/openimsdk/gomake v0.0.15-alpha.5
 	github.com/redis/go-redis/v9 v9.4.0
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/shirou/gopsutil v3.21.11+incompatible

go.sum

@@ -345,12 +345,12 @@ github.com/onsi/ginkgo/v2 v2.19.0 h1:9Cnnf7UHo57Hy3k6/m5k3dRfGTMXGvxhHFvkDTCTpvA
 github.com/onsi/ginkgo/v2 v2.19.0/go.mod h1:rlwLi9PilAFJ8jCg9UE1QP6VBpd6/xj3SRC0d6TU0To=
 github.com/onsi/gomega v1.25.0 h1:Vw7br2PCDYijJHSfBOWhov+8cAnUf8MfMaIOV323l6Y=
 github.com/onsi/gomega v1.25.0/go.mod h1:r+zV744Re+DiYCIPRlYOTxn0YkOLcAnW8k1xXdMPGhM=
-github.com/openimsdk/gomake v0.0.14-alpha.5 h1:VY9c5x515lTfmdhhPjMvR3BBRrRquAUCFsz7t7vbv7Y=
+github.com/openimsdk/gomake v0.0.15-alpha.5 h1:eEZCEHm+NsmcO3onXZPIUbGFCYPYbsX5beV3ZyOsGhY=
-github.com/openimsdk/gomake v0.0.14-alpha.5/go.mod h1:PndCozNc2IsQIciyn9mvEblYWZwJmAI+06z94EY+csI=
+github.com/openimsdk/gomake v0.0.15-alpha.5/go.mod h1:PndCozNc2IsQIciyn9mvEblYWZwJmAI+06z94EY+csI=
-github.com/openimsdk/protocol v0.0.72-alpha.78 h1:n9HVj5olMPiGLF3Z4apPvvYzn2yOpyrsn2/YiAaIsxw=
+github.com/openimsdk/protocol v0.0.73-alpha.12 h1:2NYawXeHChYUeSme6QJ9pOLh+Empce2WmwEtbP4JvKk=
-github.com/openimsdk/protocol v0.0.72-alpha.78/go.mod h1:WF7EuE55vQvpyUAzDXcqg+B+446xQyEba0X35lTINmw=
+github.com/openimsdk/protocol v0.0.73-alpha.12/go.mod h1:WF7EuE55vQvpyUAzDXcqg+B+446xQyEba0X35lTINmw=
-github.com/openimsdk/tools v0.0.50-alpha.74 h1:yh10SiMiivMEjicEQg+QAsH4pvaO+4noMPdlw+ew0Kc=
+github.com/openimsdk/tools v0.0.50-alpha.84 h1:jN60Ys/0edZjL/TDmm/5VSJFP4pGYRipkWqhILJbq/8=
-github.com/openimsdk/tools v0.0.50-alpha.74/go.mod h1:n2poR3asX1e1XZce4O+MOWAp+X02QJRFvhcLCXZdzRo=
+github.com/openimsdk/tools v0.0.50-alpha.84/go.mod h1:n2poR3asX1e1XZce4O+MOWAp+X02QJRFvhcLCXZdzRo=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=

internal/api/friend.go

@@ -114,3 +114,7 @@ func (o *FriendApi) GetIncrementalBlacks(c *gin.Context) {
 func (o *FriendApi) GetFullFriendUserIDs(c *gin.Context) {
 	a2r.Call(c, relation.FriendClient.GetFullFriendUserIDs, o.Client)
 }
+
+func (o *FriendApi) GetSelfUnhandledApplyCount(c *gin.Context) {
+	a2r.Call(c, relation.FriendClient.GetSelfUnhandledApplyCount, o.Client)
+}

internal/api/group.go

@@ -165,3 +165,7 @@ func (o *GroupApi) GetFullGroupMemberUserIDs(c *gin.Context) {
 func (o *GroupApi) GetFullJoinGroupIDs(c *gin.Context) {
 	a2r.Call(c, group.GroupClient.GetFullJoinGroupIDs, o.Client)
 }
+
+func (o *GroupApi) GetGroupApplicationUnhandledCount(c *gin.Context) {
+	a2r.Call(c, group.GroupClient.GetGroupApplicationUnhandledCount, o.Client)
+}

internal/api/jssdk/jssdk.go

@@ -2,10 +2,14 @@ package jssdk
 
 import (
 	"context"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"sort"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/log"
+
 	"github.com/gin-gonic/gin"
+
 	"github.com/openimsdk/protocol/conversation"
 	"github.com/openimsdk/protocol/jssdk"
 	"github.com/openimsdk/protocol/msg"
@@ -109,10 +113,7 @@ func (x *JSSdk) getActiveConversations(ctx context.Context, req *jssdk.GetActive
 	if len(conversationIDs) == 0 {
 		return &jssdk.GetActiveConversationsResp{}, nil
 	}
-	readSeq, err := x.msgClient.GetHasReadSeqs(ctx, conversationIDs, req.OwnerUserID)
+
-	if err != nil {
-		return nil, err
-	}
 	activeConversation, err := x.msgClient.GetActiveConversation(ctx, conversationIDs)
 	if err != nil {
 		return nil, err
@@ -120,6 +121,10 @@ func (x *JSSdk) getActiveConversations(ctx context.Context, req *jssdk.GetActive
 	if len(activeConversation) == 0 {
 		return &jssdk.GetActiveConversationsResp{}, nil
 	}
+	readSeq, err := x.msgClient.GetHasReadSeqs(ctx, conversationIDs, req.OwnerUserID)
+	if err != nil {
+		return nil, err
+	}
 	sortConversations := sortActiveConversations{
 		Conversation: activeConversation,
 	}
@@ -147,6 +152,7 @@ func (x *JSSdk) getActiveConversations(ctx context.Context, req *jssdk.GetActive
 	if err != nil {
 		return nil, err
 	}
+	x.checkMessagesAndGetLastMessage(ctx, req.OwnerUserID, msgs)
 	conversationMap := datautil.SliceToMap(conversations, func(c *conversation.Conversation) string {
 		return c.ConversationID
 	})
@@ -156,16 +162,15 @@ func (x *JSSdk) getActiveConversations(ctx context.Context, req *jssdk.GetActive
 		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, &jssdk.ConversationMsg{
+				Conversation: conv,
+				LastMsg:      msgList.Msgs[0],
+				MaxSeq:       c.MaxSeq,
+				ReadSeq:      readSeq[c.ConversationID],
+			})
 		}
-		resp = append(resp, &jssdk.ConversationMsg{
+
-			Conversation: conv,
-			LastMsg:      lastMsg,
-			MaxSeq:       c.MaxSeq,
-			ReadSeq:      readSeq[c.ConversationID],
-		})
 	}
 	if err := x.fillConversations(ctx, resp); err != nil {
 		return nil, err
@@ -219,18 +224,18 @@ func (x *JSSdk) getConversations(ctx context.Context, req *jssdk.GetConversation
 			return nil, err
 		}
 	}
+	x.checkMessagesAndGetLastMessage(ctx, req.OwnerUserID, msgs)
 	resp := make([]*jssdk.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, &jssdk.ConversationMsg{
+				Conversation: c,
+				LastMsg:      msgList.Msgs[0],
+				MaxSeq:       maxSeqs[c.ConversationID],
+				ReadSeq:      readSeqs[c.ConversationID],
+			})
 		}
-		resp = append(resp, &jssdk.ConversationMsg{
+
-			Conversation: c,
-			LastMsg:      lastMsg,
-			MaxSeq:       maxSeqs[c.ConversationID],
-			ReadSeq:      readSeqs[c.ConversationID],
-		})
 	}
 	if err := x.fillConversations(ctx, resp); err != nil {
 		return nil, err
@@ -247,3 +252,38 @@ func (x *JSSdk) getConversations(ctx context.Context, req *jssdk.GetConversation
 		UnreadCount:   unreadCount,
 	}, nil
 }
+
+// This function checks whether the latest MaxSeq message is valid.
+// If not, it needs to fetch a valid message again.
+func (x *JSSdk) checkMessagesAndGetLastMessage(ctx context.Context, userID string, messages map[string]*sdkws.PullMsgs) {
+	var conversationIDs []string
+
+	for conversationID, message := range messages {
+		allInValid := true
+		for _, data := range message.Msgs {
+			if data.Status < constant.MsgStatusHasDeleted {
+				allInValid = false
+				break
+			}
+		}
+
+		// when the conversation has been deleted by the user, the length of message.Msgs is empty
+		if allInValid && len(message.Msgs) > 0 {
+			conversationIDs = append(conversationIDs, conversationID)
+		}
+	}
+	if len(conversationIDs) > 0 {
+		resp, err := x.msgClient.GetLastMessage(ctx, &msg.GetLastMessageReq{
+			UserID:          userID,
+			ConversationIDs: conversationIDs,
+		})
+		if err != nil {
+			log.ZError(ctx, "fetchLatestValidMessages", err, "conversationIDs", conversationIDs)
+			return
+		}
+		for conversationID, message := range resp.Msgs {
+			messages[conversationID] = &sdkws.PullMsgs{Msgs: []*sdkws.MsgData{message}}
+		}
+	}
+
+}

internal/api/router.go

@@ -149,6 +149,7 @@ func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, co
 		friendRouterGroup.POST("/update_friends", f.UpdateFriends)
 		friendRouterGroup.POST("/get_incremental_friends", f.GetIncrementalFriends)
 		friendRouterGroup.POST("/get_full_friend_user_ids", f.GetFullFriendUserIDs)
+		friendRouterGroup.POST("/get_self_unhandled_apply_count", f.GetSelfUnhandledApplyCount)
 	}
 
 	g := NewGroupApi(group.NewGroupClient(groupConn))
@@ -185,6 +186,7 @@ func newGinRouter(ctx context.Context, client discovery.SvcDiscoveryRegistry, co
 		groupRouterGroup.POST("/get_incremental_group_members_batch", g.GetIncrementalGroupMemberBatch)
 		groupRouterGroup.POST("/get_full_group_member_user_ids", g.GetFullGroupMemberUserIDs)
 		groupRouterGroup.POST("/get_full_join_group_ids", g.GetFullJoinGroupIDs)
+		groupRouterGroup.POST("/get_group_application_unhandled_count", g.GetGroupApplicationUnhandledCount)
 	}
 	// certificate
 	{

internal/msggateway/hub_server.go

@@ -244,6 +244,7 @@ func (s *Server) MultiTerminalLoginCheck(ctx context.Context, req *msggateway.Mu
 		tempUserCtx.SetOperationID(mcontext.GetOperationID(ctx))
 		client := &Client{}
 		client.ctx = tempUserCtx
+		client.token = req.Token
 		client.UserID = req.UserID
 		client.PlatformID = int(req.PlatformID)
 		i := &kickHandler{

internal/msggateway/ws_server.go

@@ -337,17 +337,51 @@ func (ws *WsServer) multiTerminalLoginChecker(clientOK bool, oldClients []*Clien
 		}
 	}
 
+	// If reconnect: When multiple msgGateway instances are deployed, a client may disconnect from instance A and reconnect to instance B.
+	// During this process, instance A might still be executing, resulting in two clients with the same token existing simultaneously.
+	// This situation needs to be filtered to prevent duplicate clients.
+	checkSameTokenFunc := func(oldClients []*Client) []*Client {
+		var clientsNeedToKick []*Client
+
+		for _, c := range oldClients {
+			if c.token == newClient.token {
+				log.ZDebug(newClient.ctx, "token is same, not kick",
+					"userID", newClient.UserID,
+					"platformID", newClient.PlatformID,
+					"token", newClient.token)
+				continue
+			}
+
+			clientsNeedToKick = append(clientsNeedToKick, c)
+		}
+
+		return clientsNeedToKick
+	}
+
 	switch ws.msgGatewayConfig.Share.MultiLogin.Policy {
 	case constant.DefalutNotKick:
 	case constant.PCAndOther:
 		if constant.PlatformIDToClass(newClient.PlatformID) == constant.TerminalPC {
 			return
 		}
+		clients, ok := ws.clients.GetAll(newClient.UserID)
+		clientOK = ok
+		oldClients = make([]*Client, 0, len(clients))
+		for _, c := range clients {
+			if constant.PlatformIDToClass(c.PlatformID) == constant.TerminalPC {
+				continue
+			}
+			oldClients = append(oldClients, c)
+		}
+
 		fallthrough
 	case constant.AllLoginButSameTermKick:
 		if !clientOK {
 			return
 		}
+
+		oldClients = checkSameTokenFunc(oldClients)
+
 		ws.clients.DeleteClients(newClient.UserID, oldClients)
 		for _, c := range oldClients {
 			err := c.KickOnlineMessage()
@@ -373,14 +407,15 @@ func (ws *WsServer) multiTerminalLoginChecker(clientOK bool, oldClients []*Clien
 		if !ok {
 			return
 		}
-		var (
+
-			kickClients []*Client
+		var kickClients []*Client
-		)
 		for _, client := range clients {
 			if constant.PlatformIDToClass(client.PlatformID) == constant.PlatformIDToClass(newClient.PlatformID) {
 				kickClients = append(kickClients, client)
 			}
 		}
+		kickClients = checkSameTokenFunc(kickClients)
+
 		kickTokenFunc(kickClients)
 	}
 }

internal/msgtransfer/online_history_msg_handler.go

@@ -18,17 +18,20 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
-	"github.com/openimsdk/tools/discovery"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/tools/discovery"
+
+	"github.com/go-redis/redis"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/prommetrics"
 
 	"github.com/IBM/sarama"
-	"github.com/go-redis/redis"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/kafka"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
@@ -40,7 +43,6 @@ import (
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
 	"github.com/openimsdk/tools/utils/stringutil"
-	"google.golang.org/protobuf/proto"
 )
 
 const (
@@ -139,53 +141,48 @@ func (och *OnlineHistoryRedisConsumerHandler) do(ctx context.Context, channelID
 
 func (och *OnlineHistoryRedisConsumerHandler) doSetReadSeq(ctx context.Context, msgs []*ContextMsg) {
 
-	var conversationID string
+	// Outer map: conversationID -> (userID -> maxHasReadSeq)
-	var userSeqMap map[string]int64
+	conversationUserSeq := make(map[string]map[string]int64)
+
 	for _, msg := range msgs {
 		if msg.message.ContentType != constant.HasReadReceipt {
 			continue
 		}
 		var elem sdkws.NotificationElem
 		if err := json.Unmarshal(msg.message.Content, &elem); err != nil {
-			log.ZWarn(ctx, "handlerConversationRead Unmarshal NotificationElem msg err", err, "msg", msg)
+			log.ZWarn(ctx, "Unmarshal NotificationElem error", err, "msg", msg)
 			continue
 		}
 		var tips sdkws.MarkAsReadTips
 		if err := json.Unmarshal([]byte(elem.Detail), &tips); err != nil {
-			log.ZWarn(ctx, "handlerConversationRead Unmarshal MarkAsReadTips msg err", err, "msg", msg)
+			log.ZWarn(ctx, "Unmarshal MarkAsReadTips error", err, "msg", msg)
 			continue
 		}
-		//The conversation ID for each batch of messages processed by the batcher is the same.
+		if len(tips.ConversationID) == 0 || tips.HasReadSeq < 0 {
-		conversationID = tips.ConversationID
-		if len(tips.Seqs) > 0 {
-			for _, seq := range tips.Seqs {
-				if tips.HasReadSeq < seq {
-					tips.HasReadSeq = seq
-				}
-			}
-			clear(tips.Seqs)
-			tips.Seqs = nil
-		}
-		if tips.HasReadSeq < 0 {
 			continue
 		}
-		if userSeqMap == nil {
-			userSeqMap = make(map[string]int64)
-		}
 
-		if userSeqMap[tips.MarkAsReadUserID] > tips.HasReadSeq {
+		// Calculate the max seq from tips.Seqs
-			continue
+		for _, seq := range tips.Seqs {
+			if tips.HasReadSeq < seq {
+				tips.HasReadSeq = seq
+			}
+		}
+
+		if _, ok := conversationUserSeq[tips.ConversationID]; !ok {
+			conversationUserSeq[tips.ConversationID] = make(map[string]int64)
+		}
+		if conversationUserSeq[tips.ConversationID][tips.MarkAsReadUserID] < tips.HasReadSeq {
+			conversationUserSeq[tips.ConversationID][tips.MarkAsReadUserID] = tips.HasReadSeq
 		}
-		userSeqMap[tips.MarkAsReadUserID] = tips.HasReadSeq
 	}
-	if userSeqMap == nil {
+	log.ZInfo(ctx, "doSetReadSeq", "conversationUserSeq", conversationUserSeq)
-		return
+
-	}
+	// persist to db
-	if len(conversationID) == 0 {
+	for convID, userSeqMap := range conversationUserSeq {
-		log.ZWarn(ctx, "conversation err", nil, "conversationID", conversationID)
+		if err := och.msgTransferDatabase.SetHasReadSeqToDB(ctx, convID, userSeqMap); err != nil {
-	}
+			log.ZWarn(ctx, "SetHasReadSeqToDB error", err, "conversationID", convID, "userSeqMap", userSeqMap)
-	if err := och.msgTransferDatabase.SetHasReadSeqToDB(ctx, conversationID, userSeqMap); err != nil {
+		}
-		log.ZWarn(ctx, "set read seq to db error", err, "conversationID", conversationID, "userSeqMap", userSeqMap)
 	}
 
 }
@@ -289,6 +286,7 @@ func (och *OnlineHistoryRedisConsumerHandler) handleMsg(ctx context.Context, key
 		}
 
 		if isNewConversation {
+			ctx := storageList[0].ctx
 			switch msg.SessionType {
 			case constant.ReadGroupChatType:
 				log.ZDebug(ctx, "group chat first create conversation", "conversationID",

internal/msgtransfer/online_msg_to_mongo_handler.go

@@ -73,10 +73,14 @@ func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Cont
 	} else {
 		prommetrics.MsgInsertMongoSuccessCounter.Inc()
 	}
-	var seqs []int64
+	//var seqs []int64
-	for _, msg := range msgFromMQ.MsgData {
+	//for _, msg := range msgFromMQ.MsgData {
-		seqs = append(seqs, msg.Seq)
+	//	seqs = append(seqs, msg.Seq)
-	}
+	//}
+	//if err := mc.msgTransferDatabase.DeleteMessagesFromCache(ctx, msgFromMQ.ConversationID, seqs); err != nil {
+	//	log.ZError(ctx, "remove cache msg from redis err", err, "msg",
+	//		msgFromMQ.MsgData, "conversationID", msgFromMQ.ConversationID)
+	//}
 }
 
 func (*OnlineHistoryMongoConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error { return nil }

internal/push/push_handler.go

@@ -142,6 +142,7 @@ func (c *ConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim s
 
 	for msg := range claim.Messages() {
 		ctx := c.pushConsumerGroup.GetContextFromMsg(msg)
+		ctx = mcontext.WithOpUserIDContext(ctx, c.config.Share.IMAdminUserID[0])
 		c.handleMs2PsChat(ctx, msg.Value)
 		sess.MarkMessage(msg, "")
 	}

internal/rpc/group/cache.go

@@ -33,6 +33,9 @@ func (s *groupServer) GetGroupInfoCache(ctx context.Context, req *pbgroup.GetGro
 }
 
 func (s *groupServer) GetGroupMemberCache(ctx context.Context, req *pbgroup.GetGroupMemberCacheReq) (*pbgroup.GetGroupMemberCacheResp, error) {
+	if err := s.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
+	}
 	members, err := s.db.TakeGroupMember(ctx, req.GroupID, req.GroupMemberID)
 	if err != nil {
 		return nil, err

internal/rpc/group/group.go

@@ -426,7 +426,7 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 						ReqMessage:    request.ReqMsg,
 						JoinSource:    request.JoinSource,
 						InviterUserID: request.InviterUserID,
-					})
+					}, request)
 				}
 				return &pbgroup.InviteUserToGroupResp{}, nil
 			}
@@ -453,12 +453,25 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 		return nil, err
 	}
 
-	if err := g.db.CreateGroup(ctx, nil, groupMembers); err != nil {
+	const singleQuantity = 50
-		return nil, err
+	for start := 0; start < len(groupMembers); start += singleQuantity {
-	}
+		end := start + singleQuantity
+		if end > len(groupMembers) {
+			end = len(groupMembers)
+		}
+		currentMembers := groupMembers[start:end]
 
-	if err = g.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, req.SendMessage, opUserID, req.InvitedUserIDs...); err != nil {
+		if err := g.db.CreateGroup(ctx, nil, currentMembers); err != nil {
-		return nil, err
+			return nil, err
+		}
+
+		userIDs := datautil.Slice(currentMembers, func(e *model.GroupMember) string {
+			return e.UserID
+		})
+
+		if err = g.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, req.SendMessage, opUserID, userIDs...); err != nil {
+			return nil, err
+		}
 	}
 	return &pbgroup.InviteUserToGroupResp{}, nil
 }
@@ -478,7 +491,25 @@ func (g *groupServer) GetGroupAllMember(ctx context.Context, req *pbgroup.GetGro
 	return &resp, nil
 }
 
+func (g *groupServer) checkAdminOrInGroup(ctx context.Context, groupID string) error {
+	if authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+		return nil
+	}
+	opUserID := mcontext.GetOpUserID(ctx)
+	members, err := g.db.FindGroupMembers(ctx, groupID, []string{opUserID})
+	if err != nil {
+		return err
+	}
+	if len(members) == 0 {
+		return errs.ErrNoPermission.WrapMsg("op user not in group")
+	}
+	return nil
+}
+
 func (g *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGroupMemberListReq) (*pbgroup.GetGroupMemberListResp, error) {
+	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
+	}
 	var (
 		total   int64
 		members []*model.GroupMember
@@ -487,7 +518,7 @@ func (g *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGr
 	if req.Keyword == "" {
 		total, members, err = g.db.PageGetGroupMember(ctx, req.GroupID, req.Pagination)
 	} else {
-		members, err = g.db.FindGroupMemberAll(ctx, req.GroupID)
+		total, members, err = g.db.SearchGroupMember(ctx, req.GroupID, req.Keyword, req.Pagination)
 	}
 	if err != nil {
 		return nil, err
@@ -495,27 +526,6 @@ func (g *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGr
 	if err := g.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
-	if req.Keyword != "" {
-		groupMembers := make([]*model.GroupMember, 0)
-		for _, member := range members {
-			if member.UserID == req.Keyword {
-				groupMembers = append(groupMembers, member)
-				total++
-				continue
-			}
-			if member.Nickname == req.Keyword {
-				groupMembers = append(groupMembers, member)
-				total++
-				continue
-			}
-		}
-
-		members := datautil.Paginate(groupMembers, int(req.Pagination.GetPageNumber()), int(req.Pagination.GetShowNumber()))
-		return &pbgroup.GetGroupMemberListResp{
-			Total:   uint32(total),
-			Members: datautil.Batch(convert.Db2PbGroupMember, members),
-		}, nil
-	}
 	return &pbgroup.GetGroupMemberListResp{
 		Total:   uint32(total),
 		Members: datautil.Batch(convert.Db2PbGroupMember, members),
@@ -639,6 +649,9 @@ func (g *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbgroup.GetG
 	if req.GroupID == "" {
 		return nil, errs.ErrArgs.WrapMsg("groupID empty")
 	}
+	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
+	}
 	members, err := g.getGroupMembersInfo(ctx, req.GroupID, req.UserIDs)
 	if err != nil {
 		return nil, err
@@ -666,15 +679,34 @@ func (g *groupServer) getGroupMembersInfo(ctx context.Context, groupID string, u
 
 // GetGroupApplicationList handles functions that get a list of group requests.
 func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.GetGroupApplicationListReq) (*pbgroup.GetGroupApplicationListResp, error) {
-	groupIDs, err := g.db.FindUserManagedGroupID(ctx, req.FromUserID)
+	var (
-	if err != nil {
+		groupIDs []string
-		return nil, err
+		err      error
+	)
+	if len(req.GroupIDs) == 0 {
+		groupIDs, err = g.db.FindUserManagedGroupID(ctx, req.FromUserID)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		req.GroupIDs = datautil.Distinct(req.GroupIDs)
+		if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+			for _, groupID := range req.GroupIDs {
+				if err := g.CheckGroupAdmin(ctx, groupID); err != nil {
+					return nil, err
+				}
+			}
+		}
+		groupIDs = req.GroupIDs
 	}
 	resp := &pbgroup.GetGroupApplicationListResp{}
 	if len(groupIDs) == 0 {
 		return resp, nil
 	}
-	total, groupRequests, err := g.db.PageGroupRequest(ctx, groupIDs, req.Pagination)
+	handleResults := datautil.Slice(req.HandleResults, func(e int32) int {
+		return int(e)
+	})
+	total, groupRequests, err := g.db.PageGroupRequest(ctx, groupIDs, handleResults, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
@@ -739,6 +771,23 @@ func (g *groupServer) GetGroupsInfo(ctx context.Context, req *pbgroup.GetGroupsI
 	}, nil
 }
 
+func (g *groupServer) GetGroupApplicationUnhandledCount(ctx context.Context, req *pbgroup.GetGroupApplicationUnhandledCountReq) (*pbgroup.GetGroupApplicationUnhandledCountResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, g.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
+	groupIDs, err := g.db.FindUserManagedGroupID(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	count, err := g.db.GetGroupApplicationUnhandledCount(ctx, groupIDs, req.Time)
+	if err != nil {
+		return nil, err
+	}
+	return &pbgroup.GetGroupApplicationUnhandledCountResp{
+		Count: count,
+	}, nil
+}
+
 func (g *groupServer) getGroupsInfo(ctx context.Context, groupIDs []string) ([]*sdkws.GroupInfo, error) {
 	if len(groupIDs) == 0 {
 		return nil, nil
@@ -920,7 +969,7 @@ func (g *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
 	if err = g.db.CreateGroupRequest(ctx, []*model.GroupRequest{&groupRequest}); err != nil {
 		return nil, err
 	}
-	g.notification.JoinGroupApplicationNotification(ctx, req)
+	g.notification.JoinGroupApplicationNotification(ctx, req, &groupRequest)
 	return &pbgroup.JoinGroupResp{}, nil
 }
 
@@ -1284,6 +1333,9 @@ func (g *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq)
 }
 
 func (g *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbgroup.GetGroupMembersCMSReq) (*pbgroup.GetGroupMembersCMSResp, error) {
+	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
+	}
 	total, members, err := g.db.SearchGroupMember(ctx, req.UserName, req.GroupID, req.Pagination)
 	if err != nil {
 		return nil, err
@@ -1304,7 +1356,10 @@ func (g *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbgrou
 	if err != nil {
 		return nil, err
 	}
-	total, requests, err := g.db.PageGroupRequestUser(ctx, req.UserID, req.Pagination)
+	handleResults := datautil.Slice(req.HandleResults, func(e int32) int {
+		return int(e)
+	})
+	total, requests, err := g.db.PageGroupRequestUser(ctx, req.UserID, req.GroupIDs, handleResults, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
@@ -1659,6 +1714,11 @@ func (g *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbgroup.Get
 	if datautil.Duplicate(req.GroupIDs) {
 		return nil, errs.ErrArgs.WrapMsg("groupIDs duplicate")
 	}
+	for _, groupID := range req.GroupIDs {
+		if err := g.checkAdminOrInGroup(ctx, groupID); err != nil {
+			return nil, err
+		}
+	}
 	groups, err := g.db.FindGroup(ctx, req.GroupIDs)
 	if err != nil {
 		return nil, err
@@ -1687,6 +1747,9 @@ func (g *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbgroup.Ge
 	if len(req.GroupIDs) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("groupIDs empty")
 	}
+	if err := authverify.CheckAccessV3(ctx, req.UserID, g.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
 	members, err := g.db.FindGroupMemberUser(ctx, req.GroupIDs, req.UserID)
 	if err != nil {
 		return nil, err
@@ -1706,6 +1769,11 @@ func (g *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbgroup.Ge
 	if err != nil {
 		return nil, err
 	}
+	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+		if !datautil.Contain(mcontext.GetOpUserID(ctx), userIDs...) {
+			return nil, errs.ErrNoPermission.WrapMsg("opUser no permission")
+		}
+	}
 	return &pbgroup.GetGroupMemberUserIDsResp{
 		UserIDs: userIDs,
 	}, nil
@@ -1715,6 +1783,9 @@ func (g *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbgroup.
 	if len(req.RoleLevels) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("RoleLevels empty")
 	}
+	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
+	}
 	members, err := g.db.FindGroupMemberRoleLevels(ctx, req.GroupID, req.RoleLevels)
 	if err != nil {
 		return nil, err

internal/rpc/group/notification.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
@@ -283,7 +284,8 @@ func (g *NotificationSender) fillUserByUserID(ctx context.Context, userID string
 
 func (g *NotificationSender) setVersion(ctx context.Context, version *uint64, versionID *string, collName string, id string) {
 	versions := versionctx.GetVersionLog(ctx).Get()
-	for _, coll := range versions {
+	for i := len(versions) - 1; i >= 0; i-- {
+		coll := versions[i]
 		if coll.Name == collName && coll.Doc.DID == id {
 			*version = uint64(coll.Doc.Version)
 			*versionID = coll.Doc.ID.Hex()
@@ -363,13 +365,46 @@ func (g *NotificationSender) GroupInfoSetAnnouncementNotification(ctx context.Co
 	g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetAnnouncementNotification, tips, notification.WithRpcGetUserName(), notification.WithSendMessage(sendMessage))
 }
 
-func (g *NotificationSender) JoinGroupApplicationNotification(ctx context.Context, req *pbgroup.JoinGroupReq) {
+func (g *NotificationSender) uuid() string {
+	return uuid.New().String()
+}
+
+func (g *NotificationSender) getGroupRequest(ctx context.Context, groupID string, userID string) (*sdkws.GroupRequest, error) {
+	request, err := g.db.TakeGroupRequest(ctx, groupID, userID)
+	if err != nil {
+		return nil, err
+	}
+	users, err := g.getUsersInfo(ctx, []string{userID})
+	if err != nil {
+		return nil, err
+	}
+	if len(users) == 0 {
+		return nil, servererrs.ErrUserIDNotFound.WrapMsg(fmt.Sprintf("user %s not found", userID))
+	}
+	info, ok := users[0].(*sdkws.UserInfo)
+	if !ok {
+		info = &sdkws.UserInfo{
+			UserID:   users[0].GetUserID(),
+			Nickname: users[0].GetNickname(),
+			FaceURL:  users[0].GetFaceURL(),
+			Ex:       users[0].GetEx(),
+		}
+	}
+	return convert.Db2PbGroupRequest(request, info, nil), nil
+}
+
+func (g *NotificationSender) JoinGroupApplicationNotification(ctx context.Context, req *pbgroup.JoinGroupReq, dbReq *model.GroupRequest) {
 	var err error
 	defer func() {
 		if err != nil {
 			log.ZError(ctx, stringutil.GetFuncName(1)+" failed", err)
 		}
 	}()
+	request, err := g.getGroupRequest(ctx, dbReq.GroupID, dbReq.UserID)
+	if err != nil {
+		log.ZError(ctx, "JoinGroupApplicationNotification getGroupRequest", err, "dbReq", dbReq)
+		return
+	}
 	var group *sdkws.GroupInfo
 	group, err = g.getGroupInfo(ctx, req.GroupID)
 	if err != nil {
@@ -385,7 +420,13 @@ func (g *NotificationSender) JoinGroupApplicationNotification(ctx context.Contex
 		return
 	}
 	userIDs = append(userIDs, req.InviterUserID, mcontext.GetOpUserID(ctx))
-	tips := &sdkws.JoinGroupApplicationTips{Group: group, Applicant: user, ReqMsg: req.ReqMessage}
+	tips := &sdkws.JoinGroupApplicationTips{
+		Group:     group,
+		Applicant: user,
+		ReqMsg:    req.ReqMessage,
+		Uuid:      g.uuid(),
+		Request:   request,
+	}
 	for _, userID := range datautil.Distinct(userIDs) {
 		g.Notification(ctx, mcontext.GetOpUserID(ctx), userID, constant.JoinGroupApplicationNotification, tips)
 	}
@@ -415,6 +456,11 @@ func (g *NotificationSender) GroupApplicationAcceptedNotification(ctx context.Co
 			log.ZError(ctx, stringutil.GetFuncName(1)+" failed", err)
 		}
 	}()
+	request, err := g.getGroupRequest(ctx, req.GroupID, req.FromUserID)
+	if err != nil {
+		log.ZError(ctx, "GroupApplicationAcceptedNotification getGroupRequest", err, "req", req)
+		return
+	}
 	var group *sdkws.GroupInfo
 	group, err = g.getGroupInfo(ctx, req.GroupID)
 	if err != nil {
@@ -430,8 +476,14 @@ func (g *NotificationSender) GroupApplicationAcceptedNotification(ctx context.Co
 	if err = g.fillOpUser(ctx, &opUser, group.GroupID); err != nil {
 		return
 	}
+	tips := &sdkws.GroupApplicationAcceptedTips{
+		Group:     group,
+		OpUser:    opUser,
+		HandleMsg: req.HandledMsg,
+		Uuid:      g.uuid(),
+		Request:   request,
+	}
 	for _, userID := range append(userIDs, req.FromUserID) {
-		tips := &sdkws.GroupApplicationAcceptedTips{Group: group, OpUser: opUser, HandleMsg: req.HandledMsg}
 		if userID == req.FromUserID {
 			tips.ReceiverAs = applicantReceiver
 		} else {
@@ -448,6 +500,11 @@ func (g *NotificationSender) GroupApplicationRejectedNotification(ctx context.Co
 			log.ZError(ctx, stringutil.GetFuncName(1)+" failed", err)
 		}
 	}()
+	request, err := g.getGroupRequest(ctx, req.GroupID, req.FromUserID)
+	if err != nil {
+		log.ZError(ctx, "GroupApplicationAcceptedNotification getGroupRequest", err, "req", req)
+		return
+	}
 	var group *sdkws.GroupInfo
 	group, err = g.getGroupInfo(ctx, req.GroupID)
 	if err != nil {
@@ -463,8 +520,14 @@ func (g *NotificationSender) GroupApplicationRejectedNotification(ctx context.Co
 	if err = g.fillOpUser(ctx, &opUser, group.GroupID); err != nil {
 		return
 	}
+	tips := &sdkws.GroupApplicationRejectedTips{
+		Group:     group,
+		OpUser:    opUser,
+		HandleMsg: req.HandledMsg,
+		Uuid:      g.uuid(),
+		Request:   request,
+	}
 	for _, userID := range append(userIDs, req.FromUserID) {
-		tips := &sdkws.GroupApplicationAcceptedTips{Group: group, OpUser: opUser, HandleMsg: req.HandledMsg}
 		if userID == req.FromUserID {
 			tips.ReceiverAs = applicantReceiver
 		} else {
@@ -520,6 +583,10 @@ func (g *NotificationSender) MemberKickedNotification(ctx context.Context, tips
 }
 
 func (g *NotificationSender) GroupApplicationAgreeMemberEnterNotification(ctx context.Context, groupID string, SendMessage *bool, invitedOpUserID string, entrantUserID ...string) error {
+	return g.groupApplicationAgreeMemberEnterNotification(ctx, groupID, SendMessage, invitedOpUserID, entrantUserID...)
+}
+
+func (g *NotificationSender) groupApplicationAgreeMemberEnterNotification(ctx context.Context, groupID string, SendMessage *bool, invitedOpUserID string, entrantUserID ...string) error {
 	var err error
 	defer func() {
 		if err != nil {

internal/rpc/group/statistics.go

@@ -18,6 +18,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/tools/errs"
 )
@@ -26,6 +27,9 @@ func (s *groupServer) GroupCreateCount(ctx context.Context, req *group.GroupCrea
 	if req.Start > req.End {
 		return nil, errs.ErrArgs.WrapMsg("start > end: %d > %d", req.Start, req.End)
 	}
+	if err := authverify.CheckAdmin(ctx, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
 	total, err := s.db.CountTotal(ctx, nil)
 	if err != nil {
 		return nil, err

internal/rpc/group/sync.go

@@ -11,16 +11,24 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	pbgroup "github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/datautil"
 )
 
 const versionSyncLimit = 500
 
 func (g *groupServer) GetFullGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetFullGroupMemberUserIDsReq) (*pbgroup.GetFullGroupMemberUserIDsResp, error) {
-	vl, err := g.db.FindMaxGroupMemberVersionCache(ctx, req.GroupID)
+	userIDs, err := g.db.FindGroupMemberUserID(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	userIDs, err := g.db.FindGroupMemberUserID(ctx, req.GroupID)
+	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+		if !datautil.Contain(mcontext.GetOpUserID(ctx), userIDs...) {
+			return nil, errs.ErrNoPermission.WrapMsg("op user not in group")
+		}
+	}
+	vl, err := g.db.FindMaxGroupMemberVersionCache(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -37,6 +45,9 @@ func (g *groupServer) GetFullGroupMemberUserIDs(ctx context.Context, req *pbgrou
 }
 
 func (s *groupServer) GetFullJoinGroupIDs(ctx context.Context, req *pbgroup.GetFullJoinGroupIDsReq) (*pbgroup.GetFullJoinGroupIDsResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
 	vl, err := s.db.FindMaxJoinGroupVersionCache(ctx, req.UserID)
 	if err != nil {
 		return nil, err
@@ -58,6 +69,9 @@ func (s *groupServer) GetFullJoinGroupIDs(ctx context.Context, req *pbgroup.GetF
 }
 
 func (s *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgroup.GetIncrementalGroupMemberReq) (*pbgroup.GetIncrementalGroupMemberResp, error) {
+	if err := s.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+		return nil, err
+	}
 	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err

internal/rpc/msg/notification.go

@@ -48,7 +48,3 @@ func (m *MsgNotificationSender) MarkAsReadNotification(ctx context.Context, conv
 	}
 	m.NotificationWithSessionType(ctx, sendID, recvID, constant.HasReadReceipt, sessionType, tips)
 }
-
-func (m *MsgNotificationSender) StreamMsgNotification(ctx context.Context, sendID string, recvID string, sessionType int32, tips *sdkws.StreamMsgTips) {
-	m.NotificationWithSessionType(ctx, sendID, recvID, constant.StreamMsgNotification, sessionType, tips)
-}

internal/rpc/relation/friend.go

@@ -16,6 +16,8 @@ package relation
 
 import (
 	"context"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/notification/common_user"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 
 	"github.com/openimsdk/tools/mq/memamq"
@@ -101,22 +103,24 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	}
 	userClient := rpcli.NewUserClient(userConn)
 
+	database := controller.NewFriendDatabase(
+		friendMongoDB,
+		friendRequestMongoDB,
+		redis.NewFriendCacheRedis(rdb, &config.LocalCacheConfig, friendMongoDB, redis.GetRocksCacheOptions()),
+		mgocli.GetTx(),
+	)
 	// Initialize notification sender
 	notificationSender := NewFriendNotificationSender(
 		&config.NotificationConfig,
 		rpcli.NewMsgClient(msgConn),
 		WithRpcFunc(userClient.GetUsersInfo),
+		WithFriendDB(database),
 	)
 	localcache.InitLocalCache(&config.LocalCacheConfig)
 
 	// Register Friend server with refactored MongoDB and Redis integrations
 	relation.RegisterFriendServer(server, &friendServer{
-		db: controller.NewFriendDatabase(
+		db: database,
-			friendMongoDB,
-			friendRequestMongoDB,
-			redis.NewFriendCacheRedis(rdb, &config.LocalCacheConfig, friendMongoDB, redis.GetRocksCacheOptions()),
-			mgocli.GetTx(),
-		),
 		blackDatabase: controller.NewBlackDatabase(
 			blackMongoDB,
 			redis.NewBlackCacheRedis(rdb, &config.LocalCacheConfig, blackMongoDB, redis.GetRocksCacheOptions()),
@@ -190,7 +194,7 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *relation.ImportFr
 			FromUserID:   req.OwnerUserID,
 			ToUserID:     userID,
 			HandleResult: constant.FriendResponseAgree,
-		})
+		}, false)
 	}
 
 	s.webhookAfterImportFriends(ctx, &s.config.WebhooksConfig.AfterImportFriends, req)
@@ -219,7 +223,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *relation.Res
 			return nil, err
 		}
 		s.webhookAfterAddFriendAgree(ctx, &s.config.WebhooksConfig.AfterAddFriendAgree, req)
-		s.notificationSender.FriendApplicationAgreedNotification(ctx, req)
+		s.notificationSender.FriendApplicationAgreedNotification(ctx, req, true)
 		return resp, nil
 	}
 	if req.HandleResult == constant.FriendResponseRefuse {
@@ -280,6 +284,9 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *relation.SetFri
 }
 
 func (s *friendServer) GetFriendInfo(ctx context.Context, req *relation.GetFriendInfoReq) (*relation.GetFriendInfoResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
 	friends, err := s.db.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
 	if err != nil {
 		return nil, err
@@ -292,6 +299,9 @@ func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *relation.G
 	if datautil.Duplicate(req.FriendUserIDs) {
 		return nil, errs.ErrArgs.WrapMsg("friend userID repeated")
 	}
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
 	friends, err := s.getFriend(ctx, req.OwnerUserID, req.FriendUserIDs)
 	if err != nil {
 		return nil, err
@@ -321,7 +331,7 @@ func (s *friendServer) GetDesignatedFriendsApply(ctx context.Context,
 		return nil, err
 	}
 	resp = &relation.GetDesignatedFriendsApplyResp{}
-	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userClient.GetUsersInfoMap)
+	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.getCommonUserMap)
 	if err != nil {
 		return nil, err
 	}
@@ -334,13 +344,16 @@ func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *rel
 		return nil, err
 	}
 
-	total, friendRequests, err := s.db.PageFriendRequestToMe(ctx, req.UserID, req.Pagination)
+	handleResults := datautil.Slice(req.HandleResults, func(e int32) int {
+		return int(e)
+	})
+	total, friendRequests, err := s.db.PageFriendRequestToMe(ctx, req.UserID, handleResults, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
 
 	resp = &relation.GetPaginationFriendsApplyToResp{}
-	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userClient.GetUsersInfoMap)
+	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.getCommonUserMap)
 	if err != nil {
 		return nil, err
 	}
@@ -357,12 +370,15 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *r
 		return nil, err
 	}
 
-	total, friendRequests, err := s.db.PageFriendRequestFromMe(ctx, req.UserID, req.Pagination)
+	handleResults := datautil.Slice(req.HandleResults, func(e int32) int {
+		return int(e)
+	})
+	total, friendRequests, err := s.db.PageFriendRequestFromMe(ctx, req.UserID, handleResults, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
 
-	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.userClient.GetUsersInfoMap)
+	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.getCommonUserMap)
 	if err != nil {
 		return nil, err
 	}
@@ -426,6 +442,10 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *relatio
 		return nil, errs.ErrArgs.WrapMsg("userIDList repeated")
 	}
 
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
+
 	userMap, err := s.userClient.GetUsersInfoMap(ctx, req.UserIDList)
 	if err != nil {
 		return nil, err
@@ -505,6 +525,10 @@ func (s *friendServer) UpdateFriends(
 		return nil, errs.ErrArgs.WrapMsg("friendIDList repeated")
 	}
 
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
+
 	_, err := s.db.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
 	if err != nil {
 		return nil, err
@@ -530,3 +554,28 @@ func (s *friendServer) UpdateFriends(
 	s.notificationSender.FriendsInfoUpdateNotification(ctx, req.OwnerUserID, req.FriendUserIDs)
 	return resp, nil
 }
+
+func (s *friendServer) GetSelfUnhandledApplyCount(ctx context.Context, req *relation.GetSelfUnhandledApplyCountReq) (*relation.GetSelfUnhandledApplyCountResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
+
+	count, err := s.db.GetUnhandledCount(ctx, req.UserID, req.Time)
+	if err != nil {
+		return nil, err
+	}
+
+	return &relation.GetSelfUnhandledApplyCountResp{
+		Count: count,
+	}, nil
+}
+
+func (s *friendServer) getCommonUserMap(ctx context.Context, userIDs []string) (map[string]common_user.CommonUser, error) {
+	users, err := s.userClient.GetUsersInfo(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	return datautil.SliceToMapAny(users, func(e *sdkws.UserInfo) (string, common_user.CommonUser) {
+		return e.UserID, e
+	}), nil
+}

internal/rpc/relation/notification.go

@@ -19,6 +19,9 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"github.com/openimsdk/protocol/msg"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/utils/datautil"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/versionctx"
@@ -52,9 +55,7 @@ func WithFriendDB(db controller.FriendDatabase) friendNotificationSenderOptions
 	}
 }
 
-func WithDBFunc(
+func WithDBFunc(fn func(ctx context.Context, userIDs []string) (users []*relationtb.User, err error)) friendNotificationSenderOptions {
-	fn func(ctx context.Context, userIDs []string) (users []*relationtb.User, err error),
-) friendNotificationSenderOptions {
 	return func(s *FriendNotificationSender) {
 		f := func(ctx context.Context, userIDs []string) (result []common_user.CommonUser, err error) {
 			users, err := fn(ctx, userIDs)
@@ -70,9 +71,7 @@ func WithDBFunc(
 	}
 }
 
-func WithRpcFunc(
+func WithRpcFunc(fn func(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error)) friendNotificationSenderOptions {
-	fn func(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error),
-) friendNotificationSenderOptions {
 	return func(s *FriendNotificationSender) {
 		f := func(ctx context.Context, userIDs []string) (result []common_user.CommonUser, err error) {
 			users, err := fn(ctx, userIDs)
@@ -100,10 +99,7 @@ func NewFriendNotificationSender(conf *config.Notification, msgClient *rpcli.Msg
 	return f
 }
 
-func (f *FriendNotificationSender) getUsersInfoMap(
+func (f *FriendNotificationSender) getUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
-	ctx context.Context,
-	userIDs []string,
-) (map[string]*sdkws.UserInfo, error) {
 	users, err := f.getUsersInfo(ctx, userIDs)
 	if err != nil {
 		return nil, err
@@ -116,10 +112,7 @@ func (f *FriendNotificationSender) getUsersInfoMap(
 }
 
 //nolint:unused
-func (f *FriendNotificationSender) getFromToUserNickname(
+func (f *FriendNotificationSender) getFromToUserNickname(ctx context.Context, fromUserID, toUserID string) (string, string, error) {
-	ctx context.Context,
-	fromUserID, toUserID string,
-) (string, string, error) {
 	users, err := f.getUsersInfoMap(ctx, []string{fromUserID, toUserID})
 	if err != nil {
 		return "", "", nil
@@ -132,60 +125,113 @@ func (f *FriendNotificationSender) UserInfoUpdatedNotification(ctx context.Conte
 	f.Notification(ctx, mcontext.GetOpUserID(ctx), changedUserID, constant.UserInfoUpdatedNotification, &tips)
 }
 
+func (f *FriendNotificationSender) getCommonUserMap(ctx context.Context, userIDs []string) (map[string]common_user.CommonUser, error) {
+	users, err := f.getUsersInfo(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	return datautil.SliceToMap(users, func(e common_user.CommonUser) string {
+		return e.GetUserID()
+	}), nil
+}
+
+func (f *FriendNotificationSender) getFriendRequests(ctx context.Context, fromUserID, toUserID string) (*sdkws.FriendRequest, error) {
+	if f.db == nil {
+		return nil, errs.ErrInternalServer.WithDetail("db is nil")
+	}
+	friendRequests, err := f.db.FindBothFriendRequests(ctx, fromUserID, toUserID)
+	if err != nil {
+		return nil, err
+	}
+	requests, err := convert.FriendRequestDB2Pb(ctx, friendRequests, f.getCommonUserMap)
+	if err != nil {
+		return nil, err
+	}
+	for _, request := range requests {
+		if request.FromUserID == fromUserID && request.ToUserID == toUserID {
+			return request, nil
+		}
+	}
+	return nil, errs.ErrRecordNotFound.WrapMsg("friend request not found", "fromUserID", fromUserID, "toUserID", toUserID)
+}
+
 func (f *FriendNotificationSender) FriendApplicationAddNotification(ctx context.Context, req *relation.ApplyToAddFriendReq) {
-	tips := sdkws.FriendApplicationTips{FromToUserID: &sdkws.FromToUserID{
+	request, err := f.getFriendRequests(ctx, req.FromUserID, req.ToUserID)
-		FromUserID: req.FromUserID,
+	if err != nil {
-		ToUserID:   req.ToUserID,
+		log.ZError(ctx, "FriendApplicationAddNotification get friend request", err, "fromUserID", req.FromUserID, "toUserID", req.ToUserID)
-	}}
+		return
+	}
+	tips := sdkws.FriendApplicationTips{
+		FromToUserID: &sdkws.FromToUserID{
+			FromUserID: req.FromUserID,
+			ToUserID:   req.ToUserID,
+		},
+		Request: request,
+	}
 	f.Notification(ctx, req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &tips)
 }
 
-func (f *FriendNotificationSender) FriendApplicationAgreedNotification(
+func (f *FriendNotificationSender) FriendApplicationAgreedNotification(ctx context.Context, req *relation.RespondFriendApplyReq, checkReq bool) {
-	ctx context.Context,
+	var (
-	req *relation.RespondFriendApplyReq,
+		request *sdkws.FriendRequest
-) {
+		err     error
-	tips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{
+	)
-		FromUserID: req.FromUserID,
+	if checkReq {
-		ToUserID:   req.ToUserID,
+		request, err = f.getFriendRequests(ctx, req.FromUserID, req.ToUserID)
-	}, HandleMsg: req.HandleMsg}
+		if err != nil {
+			log.ZError(ctx, "FriendApplicationAgreedNotification get friend request", err, "fromUserID", req.FromUserID, "toUserID", req.ToUserID)
+			return
+		}
+	}
+	tips := sdkws.FriendApplicationApprovedTips{
+		FromToUserID: &sdkws.FromToUserID{
+			FromUserID: req.FromUserID,
+			ToUserID:   req.ToUserID,
+		},
+		HandleMsg: req.HandleMsg,
+		Request:   request,
+	}
 	f.Notification(ctx, req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &tips)
 }
 
-func (f *FriendNotificationSender) FriendApplicationRefusedNotification(
+func (f *FriendNotificationSender) FriendApplicationRefusedNotification(ctx context.Context, req *relation.RespondFriendApplyReq) {
-	ctx context.Context,
+	request, err := f.getFriendRequests(ctx, req.FromUserID, req.ToUserID)
-	req *relation.RespondFriendApplyReq,
+	if err != nil {
-) {
+		log.ZError(ctx, "FriendApplicationRefusedNotification get friend request", err, "fromUserID", req.FromUserID, "toUserID", req.ToUserID)
-	tips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{
+		return
-		FromUserID: req.FromUserID,
+	}
-		ToUserID:   req.ToUserID,
+	tips := sdkws.FriendApplicationRejectedTips{
-	}, HandleMsg: req.HandleMsg}
+		FromToUserID: &sdkws.FromToUserID{
+			FromUserID: req.FromUserID,
+			ToUserID:   req.ToUserID,
+		},
+		HandleMsg: req.HandleMsg,
+		Request:   request,
+	}
 	f.Notification(ctx, req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &tips)
 }
 
-func (f *FriendNotificationSender) FriendAddedNotification(
+//func (f *FriendNotificationSender) FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) error {
-	ctx context.Context,
+//	tips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
-	operationID, opUserID, fromUserID, toUserID string,
+//	user, err := f.getUsersInfo(ctx, []string{opUserID})
-) error {
+//	if err != nil {
-	tips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
+//		return err
-	user, err := f.getUsersInfo(ctx, []string{opUserID})
+//	}
-	if err != nil {
+//	tips.OpUser.UserID = user[0].GetUserID()
-		return err
+//	tips.OpUser.Ex = user[0].GetEx()
-	}
+//	tips.OpUser.Nickname = user[0].GetNickname()
-	tips.OpUser.UserID = user[0].GetUserID()
+//	tips.OpUser.FaceURL = user[0].GetFaceURL()
-	tips.OpUser.Ex = user[0].GetEx()
+//	friends, err := f.db.FindFriendsWithError(ctx, fromUserID, []string{toUserID})
-	tips.OpUser.Nickname = user[0].GetNickname()
+//	if err != nil {
-	tips.OpUser.FaceURL = user[0].GetFaceURL()
+//		return err
-	friends, err := f.db.FindFriendsWithError(ctx, fromUserID, []string{toUserID})
+//	}
-	if err != nil {
+//	tips.Friend, err = convert.FriendDB2Pb(ctx, friends[0], f.getUsersInfoMap)
-		return err
+//	if err != nil {
-	}
+//		return err
-	tips.Friend, err = convert.FriendDB2Pb(ctx, friends[0], f.getUsersInfoMap)
+//	}
-	if err != nil {
+//	f.Notification(ctx, fromUserID, toUserID, constant.FriendAddedNotification, &tips)
-		return err
+//	return nil
-	}
+//}
-	f.Notification(ctx, fromUserID, toUserID, constant.FriendAddedNotification, &tips)
-	return nil
-}
 
 func (f *FriendNotificationSender) FriendDeletedNotification(ctx context.Context, req *relation.DeleteFriendReq) {
 	tips := sdkws.FriendDeletedTips{FromToUserID: &sdkws.FromToUserID{

internal/rpc/relation/sync.go

@@ -2,10 +2,11 @@ package relation
 
 import (
 	"context"
+	"slices"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/util/hashutil"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/log"
-	"slices"
 
 	"github.com/openimsdk/open-im-server/v3/internal/rpc/incrversion"
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
@@ -39,6 +40,9 @@ func (s *friendServer) NotificationUserInfoUpdate(ctx context.Context, req *rela
 }
 
 func (s *friendServer) GetFullFriendUserIDs(ctx context.Context, req *relation.GetFullFriendUserIDsReq) (*relation.GetFullFriendUserIDsResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
+		return nil, err
+	}
 	vl, err := s.db.FindMaxFriendVersionCache(ctx, req.UserID)
 	if err != nil {
 		return nil, err

internal/rpc/third/third.go

@@ -17,9 +17,14 @@ package third
 import (
 	"context"
 	"fmt"
-	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/rpcli"
+	"github.com/openimsdk/tools/s3/aws"
+	"github.com/openimsdk/tools/s3/disable"
+
+	"google.golang.org/grpc"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
@@ -34,7 +39,6 @@ import (
 	"github.com/openimsdk/tools/s3/kodo"
 	"github.com/openimsdk/tools/s3/minio"
 	"github.com/openimsdk/tools/s3/oss"
-	"google.golang.org/grpc"
 )
 
 type thirdServer struct {
@@ -90,6 +94,10 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 		o, err = oss.NewOSS(*config.RpcConfig.Object.Oss.Build())
 	case "kodo":
 		o, err = kodo.NewKodo(*config.RpcConfig.Object.Kodo.Build())
+	case "aws":
+		o, err = aws.NewAws(*config.RpcConfig.Object.Aws.Build())
+	case "":
+		o = disable.NewDisable()
 	default:
 		err = fmt.Errorf("invalid object enable: %s", enable)
 	}

magefile.go

@@ -4,14 +4,23 @@
 package main
 
 import (
-	"github.com/openimsdk/gomake/mageutil"
+	"flag"
 	"os"
+
+	"github.com/openimsdk/gomake/mageutil"
 )
 
 var Default = Build
 
 func Build() {
-	mageutil.Build()
+	flag.Parse()
+
+	bin := flag.Args()
+	if len(bin) != 0 {
+		bin = bin[1:]
+	}
+
+	mageutil.Build(bin)
 }
 
 func Start() {

pkg/common/config/config.go

@@ -358,7 +358,7 @@ type Redis struct {
 	Username    string   `mapstructure:"username"`
 	Password    string   `mapstructure:"password"`
 	ClusterMode bool     `mapstructure:"clusterMode"`
-	DB          int      `mapstructure:"storage"`
+	DB          int      `mapstructure:"db"`
 	MaxRetry    int      `mapstructure:"maxRetry"`
 	PoolSize    int      `mapstructure:"poolSize"`
 }
@@ -384,6 +384,12 @@ type Share struct {
 	RpcRegisterName RpcRegisterName `mapstructure:"rpcRegisterName"`
 	IMAdminUserID   []string        `mapstructure:"imAdminUserID"`
 	MultiLogin      MultiLogin      `mapstructure:"multiLogin"`
+	RPCMaxBodySize  MaxRequestBody  `mapstructure:"rpcMaxBodySize"`
+}
+
+type MaxRequestBody struct {
+	RequestMaxBodySize  int `mapstructure:"requestMaxBodySize"`
+	ResponseMaxBodySize int `mapstructure:"responseMaxBodySize"`
 }
 
 type MultiLogin struct {

pkg/common/convert/friend.go

@@ -17,7 +17,9 @@ package convert
 import (
 	"context"
 	"fmt"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
+	"github.com/openimsdk/open-im-server/v3/pkg/notification/common_user"
 	"github.com/openimsdk/protocol/relation"
 
 	"github.com/openimsdk/protocol/sdkws"
@@ -98,7 +100,7 @@ func FriendOnlyDB2PbOnly(friendsDB []*model.Friend) []*relation.FriendInfoOnly {
 	})
 }
 
-func FriendRequestDB2Pb(ctx context.Context, friendRequests []*model.FriendRequest, getUsers func(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error)) ([]*sdkws.FriendRequest, error) {
+func FriendRequestDB2Pb(ctx context.Context, friendRequests []*model.FriendRequest, getUsers func(ctx context.Context, userIDs []string) (map[string]common_user.CommonUser, error)) ([]*sdkws.FriendRequest, error) {
 	if len(friendRequests) == 0 {
 		return nil, nil
 	}
@@ -117,11 +119,11 @@ func FriendRequestDB2Pb(ctx context.Context, friendRequests []*model.FriendReque
 		fromUser := users[friendRequest.FromUserID]
 		res = append(res, &sdkws.FriendRequest{
 			FromUserID:    friendRequest.FromUserID,
-			FromNickname:  fromUser.Nickname,
+			FromNickname:  fromUser.GetNickname(),
-			FromFaceURL:   fromUser.FaceURL,
+			FromFaceURL:   fromUser.GetFaceURL(),
 			ToUserID:      friendRequest.ToUserID,
-			ToNickname:    toUser.Nickname,
+			ToNickname:    toUser.GetNickname(),
-			ToFaceURL:     toUser.FaceURL,
+			ToFaceURL:     toUser.GetFaceURL(),
 			HandleResult:  friendRequest.HandleResult,
 			ReqMsg:        friendRequest.ReqMsg,
 			CreateTime:    friendRequest.CreateTime.UnixMilli(),

pkg/common/startrpc/start.go

@@ -22,6 +22,7 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"reflect"
 	"strconv"
 	"syscall"
 	"time"
@@ -43,6 +44,36 @@ import (
 	"google.golang.org/grpc/credentials/insecure"
 )
 
+func getConfigRpcMaxRequestBody(value reflect.Value) *conf.MaxRequestBody {
+	for value.Kind() == reflect.Pointer {
+		value = value.Elem()
+	}
+	if value.Kind() == reflect.Struct {
+		num := value.NumField()
+		for i := 0; i < num; i++ {
+			field := value.Field(i)
+			if !field.CanInterface() {
+				continue
+			}
+			for field.Kind() == reflect.Pointer {
+				field = field.Elem()
+			}
+			switch elem := field.Interface().(type) {
+			case conf.Share:
+				return &elem.RPCMaxBodySize
+			case conf.MaxRequestBody:
+				return &elem
+			}
+			if field.Kind() == reflect.Struct {
+				if elem := getConfigRpcMaxRequestBody(field); elem != nil {
+					return elem
+				}
+			}
+		}
+	}
+	return nil
+}
+
 // Start rpc server.
 func Start[T any](ctx context.Context, discovery *conf.Discovery, prometheusConfig *conf.Prometheus, listenIP,
 	registerIP string, autoSetPorts bool, rpcPorts []int, index int, rpcRegisterName string, share *conf.Share, config T,
@@ -50,6 +81,19 @@ func Start[T any](ctx context.Context, discovery *conf.Discovery, prometheusConf
 	rpcFn func(ctx context.Context, config T, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error,
 	options ...grpc.ServerOption) error {
 
+	maxRequestBody := &share.RPCMaxBodySize
+	var clientOptions []grpc.DialOption
+	if maxRequestBody != nil {
+		if maxRequestBody.RequestMaxBodySize > 0 {
+			options = append(options, grpc.MaxRecvMsgSize(maxRequestBody.RequestMaxBodySize))
+			clientOptions = append(clientOptions, grpc.WithDefaultCallOptions(grpc.MaxCallSendMsgSize(maxRequestBody.RequestMaxBodySize)))
+		}
+		if maxRequestBody.ResponseMaxBodySize > 0 {
+			options = append(options, grpc.MaxSendMsgSize(maxRequestBody.ResponseMaxBodySize))
+			clientOptions = append(clientOptions, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(maxRequestBody.ResponseMaxBodySize)))
+		}
+	}
+
 	var (
 		rpcTcpAddr     string
 		netDone        = make(chan struct{}, 2)
@@ -93,6 +137,10 @@ func Start[T any](ctx context.Context, discovery *conf.Discovery, prometheusConf
 	defer client.Close()
 	client.AddOption(mw.GrpcClient(), grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, "round_robin")))
 
+	if len(clientOptions) > 0 {
+		client.AddOption(clientOptions...)
+	}
+
 	// var reg *prometheus.Registry
 	// var metric *grpcprometheus.ServerMetrics
 	if prometheusConfig.Enable {

pkg/common/storage/controller/friend.go

@@ -17,10 +17,11 @@ package controller
 import (
 	"context"
 	"fmt"
+	"time"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database/mgo"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
-	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache"
 	"github.com/openimsdk/protocol/constant"
@@ -61,10 +62,10 @@ type FriendDatabase interface {
 	PageInWhoseFriends(ctx context.Context, friendUserID string, pagination pagination.Pagination) (total int64, friends []*model.Friend, err error)
 
 	// PageFriendRequestFromMe retrieves the friend requests sent by the user with pagination
-	PageFriendRequestFromMe(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, friends []*model.FriendRequest, err error)
+	PageFriendRequestFromMe(ctx context.Context, userID string, handleResults []int, pagination pagination.Pagination) (total int64, friends []*model.FriendRequest, err error)
 
 	// PageFriendRequestToMe retrieves the friend requests received by the user with pagination
-	PageFriendRequestToMe(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, friends []*model.FriendRequest, err error)
+	PageFriendRequestToMe(ctx context.Context, userID string, handleResults []int, pagination pagination.Pagination) (total int64, friends []*model.FriendRequest, err error)
 
 	// FindFriendsWithError fetches specified friends of a user and returns an error if any do not exist
 	FindFriendsWithError(ctx context.Context, ownerUserID string, friendUserIDs []string) (friends []*model.Friend, err error)
@@ -87,6 +88,8 @@ type FriendDatabase interface {
 	FindFriendUserID(ctx context.Context, friendUserID string) ([]string, error)
 
 	OwnerIncrVersion(ctx context.Context, ownerUserID string, friendUserIDs []string, state int32) error
+
+	GetUnhandledCount(ctx context.Context, userID string, ts int64) (int64, error)
 }
 
 type friendDatabase struct {
@@ -334,13 +337,13 @@ func (f *friendDatabase) PageInWhoseFriends(ctx context.Context, friendUserID st
 }
 
 // PageFriendRequestFromMe retrieves friend requests sent by me. It does not return an error if the result is empty.
-func (f *friendDatabase) PageFriendRequestFromMe(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, friends []*model.FriendRequest, err error) {
+func (f *friendDatabase) PageFriendRequestFromMe(ctx context.Context, userID string, handleResults []int, pagination pagination.Pagination) (total int64, friends []*model.FriendRequest, err error) {
-	return f.friendRequest.FindFromUserID(ctx, userID, pagination)
+	return f.friendRequest.FindFromUserID(ctx, userID, handleResults, pagination)
 }
 
 // PageFriendRequestToMe retrieves friend requests received by me. It does not return an error if the result is empty.
-func (f *friendDatabase) PageFriendRequestToMe(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, friends []*model.FriendRequest, err error) {
+func (f *friendDatabase) PageFriendRequestToMe(ctx context.Context, userID string, handleResults []int, pagination pagination.Pagination) (total int64, friends []*model.FriendRequest, err error) {
-	return f.friendRequest.FindToUserID(ctx, userID, pagination)
+	return f.friendRequest.FindToUserID(ctx, userID, handleResults, pagination)
 }
 
 // FindFriendsWithError retrieves specified friends' information for ownerUserID. Returns an error if any friend does not exist.
@@ -397,3 +400,7 @@ func (f *friendDatabase) OwnerIncrVersion(ctx context.Context, ownerUserID strin
 	}
 	return f.cache.DelMaxFriendVersion(ownerUserID).ChainExecDel(ctx)
 }
+
+func (f *friendDatabase) GetUnhandledCount(ctx context.Context, userID string, ts int64) (int64, error) {
+	return f.friendRequest.GetUnhandledCount(ctx, userID, ts)
+}

pkg/common/storage/controller/group.go

@@ -68,7 +68,7 @@ type GroupDatabase interface {
 	// FindUserManagedGroupID retrieves group IDs managed by a user.
 	FindUserManagedGroupID(ctx context.Context, userID string) (groupIDs []string, err error)
 	// PageGroupRequest paginates through group requests for specified groups.
-	PageGroupRequest(ctx context.Context, groupIDs []string, pagination pagination.Pagination) (int64, []*model.GroupRequest, error)
+	PageGroupRequest(ctx context.Context, groupIDs []string, handleResults []int, pagination pagination.Pagination) (int64, []*model.GroupRequest, error)
 	// GetGroupRoleLevelMemberIDs retrieves user IDs of group members with a specific role level.
 	GetGroupRoleLevelMemberIDs(ctx context.Context, groupID string, roleLevel int32) ([]string, error)
 
@@ -100,7 +100,7 @@ type GroupDatabase interface {
 	// FindGroupRequests retrieves multiple group join requests.
 	FindGroupRequests(ctx context.Context, groupID string, userIDs []string) ([]*model.GroupRequest, error)
 	// PageGroupRequestUser paginates through group join requests made by a user.
-	PageGroupRequestUser(ctx context.Context, userID string, pagination pagination.Pagination) (int64, []*model.GroupRequest, error)
+	PageGroupRequestUser(ctx context.Context, userID string, groupIDs []string, handleResults []int, pagination pagination.Pagination) (int64, []*model.GroupRequest, error)
 
 	// CountTotal counts the total number of groups as of a certain date.
 	CountTotal(ctx context.Context, before *time.Time) (count int64, err error)
@@ -124,6 +124,8 @@ type GroupDatabase interface {
 	SearchJoinGroup(ctx context.Context, userID string, keyword string, pagination pagination.Pagination) (int64, []*model.Group, error)
 
 	FindJoinGroupID(ctx context.Context, userID string) ([]string, error)
+
+	GetGroupApplicationUnhandledCount(ctx context.Context, groupIDs []string, ts int64) (int64, error)
 }
 
 func NewGroupDatabase(
@@ -304,8 +306,8 @@ func (g *groupDatabase) FindUserManagedGroupID(ctx context.Context, userID strin
 	return g.groupMemberDB.FindUserManagedGroupID(ctx, userID)
 }
 
-func (g *groupDatabase) PageGroupRequest(ctx context.Context, groupIDs []string, pagination pagination.Pagination) (int64, []*model.GroupRequest, error) {
+func (g *groupDatabase) PageGroupRequest(ctx context.Context, groupIDs []string, handleResults []int, pagination pagination.Pagination) (int64, []*model.GroupRequest, error) {
-	return g.groupRequestDB.PageGroup(ctx, groupIDs, pagination)
+	return g.groupRequestDB.PageGroup(ctx, groupIDs, handleResults, pagination)
 }
 
 func (g *groupDatabase) PageGetJoinGroup(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, totalGroupMembers []*model.GroupMember, err error) {
@@ -463,16 +465,12 @@ func (g *groupDatabase) CreateGroupRequest(ctx context.Context, requests []*mode
 	})
 }
 
-func (g *groupDatabase) TakeGroupRequest(
+func (g *groupDatabase) TakeGroupRequest(ctx context.Context, groupID string, userID string) (*model.GroupRequest, error) {
-	ctx context.Context,
-	groupID string,
-	userID string,
-) (*model.GroupRequest, error) {
 	return g.groupRequestDB.Take(ctx, groupID, userID)
 }
 
-func (g *groupDatabase) PageGroupRequestUser(ctx context.Context, userID string, pagination pagination.Pagination) (int64, []*model.GroupRequest, error) {
+func (g *groupDatabase) PageGroupRequestUser(ctx context.Context, userID string, groupIDs []string, handleResults []int, pagination pagination.Pagination) (int64, []*model.GroupRequest, error) {
-	return g.groupRequestDB.Page(ctx, userID, pagination)
+	return g.groupRequestDB.Page(ctx, userID, groupIDs, handleResults, pagination)
 }
 
 func (g *groupDatabase) CountTotal(ctx context.Context, before *time.Time) (count int64, err error) {
@@ -565,3 +563,7 @@ func (g *groupDatabase) MemberGroupIncrVersion(ctx context.Context, groupID stri
 	}
 	return g.cache.DelMaxGroupMemberVersion(groupID).ChainExecDel(ctx)
 }
+
+func (g *groupDatabase) GetGroupApplicationUnhandledCount(ctx context.Context, groupIDs []string, ts int64) (int64, error) {
+	return g.groupRequestDB.GetUnhandledCount(ctx, groupIDs, ts)
+}

pkg/common/storage/controller/msg.go

@@ -310,7 +310,7 @@ func (db *commonMsgDatabase) handlerDBMsg(ctx context.Context, cache map[int64][
 		log.ZError(ctx, "json.Unmarshal", err)
 		return
 	}
-	if quoteMsg.QuoteMessage == nil || quoteMsg.QuoteMessage.Content == "" {
+	if quoteMsg.QuoteMessage == nil {
 		return
 	}
 	if quoteMsg.QuoteMessage.Content == "e30=" {
@@ -675,12 +675,19 @@ func (db *commonMsgDatabase) SearchMessage(ctx context.Context, req *pbmsg.Searc
 func (db *commonMsgDatabase) FindOneByDocIDs(ctx context.Context, conversationIDs []string, seqs map[string]int64) (map[string]*sdkws.MsgData, error) {
 	totalMsgs := make(map[string]*sdkws.MsgData)
 	for _, conversationID := range conversationIDs {
-		seq := seqs[conversationID]
+		seq, ok := seqs[conversationID]
+		if !ok {
+			log.ZWarn(ctx, "seq not found for conversationID", errs.New("seq not found for conversation"), "conversationID", conversationID)
+			continue
+		}
+
 		docID := db.msgTable.GetDocID(conversationID, seq)
 		msgs, err := db.msgDocDatabase.FindOneByDocID(ctx, docID)
 		if err != nil {
-			return nil, err
+			log.ZWarn(ctx, "FindOneByDocID failed", err, "conversationID", conversationID, "docID", docID, "seq", seq)
+			continue
 		}
+
 		index := db.msgTable.GetMsgIndex(seq)
 		totalMsgs[conversationID] = convert.MsgDB2Pb(msgs.Msg[index].Msg)
 	}

pkg/common/storage/database/friend_request.go

@@ -16,6 +16,7 @@ package database
 
 import (
 	"context"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/tools/db/pagination"
 )
@@ -33,8 +34,9 @@ type FriendRequest interface {
 	Find(ctx context.Context, fromUserID, toUserID string) (friendRequest *model.FriendRequest, err error)
 	Take(ctx context.Context, fromUserID, toUserID string) (friendRequest *model.FriendRequest, err error)
 	// Get list of friend requests received by toUserID
-	FindToUserID(ctx context.Context, toUserID string, pagination pagination.Pagination) (total int64, friendRequests []*model.FriendRequest, err error)
+	FindToUserID(ctx context.Context, toUserID string, handleResults []int, pagination pagination.Pagination) (total int64, friendRequests []*model.FriendRequest, err error)
 	// Get list of friend requests sent by fromUserID
-	FindFromUserID(ctx context.Context, fromUserID string, pagination pagination.Pagination) (total int64, friendRequests []*model.FriendRequest, err error)
+	FindFromUserID(ctx context.Context, fromUserID string, handleResults []int, pagination pagination.Pagination) (total int64, friendRequests []*model.FriendRequest, err error)
 	FindBothFriendRequests(ctx context.Context, fromUserID, toUserID string) (friends []*model.FriendRequest, err error)
+	GetUnhandledCount(ctx context.Context, userID string, ts int64) (int64, error)
 }

pkg/common/storage/database/group_request.go

@@ -16,6 +16,7 @@ package database
 
 import (
 	"context"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/tools/db/pagination"
 )
@@ -26,6 +27,7 @@ type GroupRequest interface {
 	UpdateHandler(ctx context.Context, groupID string, userID string, handledMsg string, handleResult int32) (err error)
 	Take(ctx context.Context, groupID string, userID string) (groupRequest *model.GroupRequest, err error)
 	FindGroupRequests(ctx context.Context, groupID string, userIDs []string) ([]*model.GroupRequest, error)
-	Page(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, groups []*model.GroupRequest, err error)
+	Page(ctx context.Context, userID string, groupIDs []string, handleResults []int, pagination pagination.Pagination) (total int64, groups []*model.GroupRequest, err error)
-	PageGroup(ctx context.Context, groupIDs []string, pagination pagination.Pagination) (total int64, groups []*model.GroupRequest, err error)
+	PageGroup(ctx context.Context, groupIDs []string, handleResults []int, pagination pagination.Pagination) (total int64, groups []*model.GroupRequest, err error)
+	GetUnhandledCount(ctx context.Context, groupIDs []string, ts int64) (int64, error)
 }

pkg/common/storage/database/mgo/friend_request.go

@@ -16,24 +16,35 @@ package mgo
 
 import (
 	"context"
+	"time"
+
+	"go.mongodb.org/mongo-driver/mongo/options"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 
-	"github.com/openimsdk/tools/db/mongoutil"
-	"github.com/openimsdk/tools/db/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
 )
 
 func NewFriendRequestMongo(db *mongo.Database) (database.FriendRequest, error) {
 	coll := db.Collection(database.FriendRequestName)
-	_, err := coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{
+	_, err := coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{
-		Keys: bson.D{
+		{
-			{Key: "from_user_id", Value: 1},
+			Keys: bson.D{
-			{Key: "to_user_id", Value: 1},
+				{Key: "from_user_id", Value: 1},
+				{Key: "to_user_id", Value: 1},
+			},
+			Options: options.Index().SetUnique(true),
+		},
+		{
+			Keys: bson.D{
+				{Key: "create_time", Value: -1},
+			},
 		},
-		Options: options.Index().SetUnique(true),
 	})
 	if err != nil {
 		return nil, err
@@ -45,12 +56,24 @@ type FriendRequestMgo struct {
 	coll *mongo.Collection
 }
 
-func (f *FriendRequestMgo) FindToUserID(ctx context.Context, toUserID string, pagination pagination.Pagination) (total int64, friendRequests []*model.FriendRequest, err error) {
+func (f *FriendRequestMgo) sort() any {
-	return mongoutil.FindPage[*model.FriendRequest](ctx, f.coll, bson.M{"to_user_id": toUserID}, pagination)
+	return bson.D{{Key: "create_time", Value: -1}}
 }
 
-func (f *FriendRequestMgo) FindFromUserID(ctx context.Context, fromUserID string, pagination pagination.Pagination) (total int64, friendRequests []*model.FriendRequest, err error) {
+func (f *FriendRequestMgo) FindToUserID(ctx context.Context, toUserID string, handleResults []int, pagination pagination.Pagination) (total int64, friendRequests []*model.FriendRequest, err error) {
-	return mongoutil.FindPage[*model.FriendRequest](ctx, f.coll, bson.M{"from_user_id": fromUserID}, pagination)
+	filter := bson.M{"to_user_id": toUserID}
+	if len(handleResults) > 0 {
+		filter["handle_result"] = bson.M{"$in": handleResults}
+	}
+	return mongoutil.FindPage[*model.FriendRequest](ctx, f.coll, filter, pagination, options.Find().SetSort(f.sort()))
+}
+
+func (f *FriendRequestMgo) FindFromUserID(ctx context.Context, fromUserID string, handleResults []int, pagination pagination.Pagination) (total int64, friendRequests []*model.FriendRequest, err error) {
+	filter := bson.M{"from_user_id": fromUserID}
+	if len(handleResults) > 0 {
+		filter["handle_result"] = bson.M{"$in": handleResults}
+	}
+	return mongoutil.FindPage[*model.FriendRequest](ctx, f.coll, filter, pagination, options.Find().SetSort(f.sort()))
 }
 
 func (f *FriendRequestMgo) FindBothFriendRequests(ctx context.Context, fromUserID, toUserID string) (friends []*model.FriendRequest, err error) {
@@ -110,3 +133,11 @@ func (f *FriendRequestMgo) Find(ctx context.Context, fromUserID, toUserID string
 func (f *FriendRequestMgo) Take(ctx context.Context, fromUserID, toUserID string) (friendRequest *model.FriendRequest, err error) {
 	return f.Find(ctx, fromUserID, toUserID)
 }
+
+func (f *FriendRequestMgo) GetUnhandledCount(ctx context.Context, userID string, ts int64) (int64, error) {
+	filter := bson.M{"to_user_id": userID, "handle_result": 0}
+	if ts != 0 {
+		filter["create_time"] = bson.M{"$gt": time.Unix(ts, 0)}
+	}
+	return mongoutil.Count(ctx, f.coll, filter)
+}

pkg/common/storage/database/mgo/group_request.go

@@ -16,25 +16,36 @@ package mgo
 
 import (
 	"context"
+	"time"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
+	"github.com/openimsdk/tools/utils/datautil"
+
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
 
 	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/db/pagination"
 	"github.com/openimsdk/tools/errs"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
 func NewGroupRequestMgo(db *mongo.Database) (database.GroupRequest, error) {
 	coll := db.Collection(database.GroupRequestName)
-	_, err := coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{
+	_, err := coll.Indexes().CreateMany(context.Background(), []mongo.IndexModel{
-		Keys: bson.D{
+		{
-			{Key: "group_id", Value: 1},
+			Keys: bson.D{
-			{Key: "user_id", Value: 1},
+				{Key: "group_id", Value: 1},
+				{Key: "user_id", Value: 1},
+			},
+			Options: options.Index().SetUnique(true),
+		},
+		{
+			Keys: bson.D{
+				{Key: "req_time", Value: -1},
+			},
 		},
-		Options: options.Index().SetUnique(true),
 	})
 	if err != nil {
 		return nil, errs.Wrap(err)
@@ -66,10 +77,39 @@ func (g *GroupRequestMgo) FindGroupRequests(ctx context.Context, groupID string,
 	return mongoutil.Find[*model.GroupRequest](ctx, g.coll, bson.M{"group_id": groupID, "user_id": bson.M{"$in": userIDs}})
 }
 
-func (g *GroupRequestMgo) Page(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, groups []*model.GroupRequest, err error) {
+func (g *GroupRequestMgo) sort() any {
-	return mongoutil.FindPage[*model.GroupRequest](ctx, g.coll, bson.M{"user_id": userID}, pagination)
+	return bson.D{{Key: "req_time", Value: -1}}
 }
 
-func (g *GroupRequestMgo) PageGroup(ctx context.Context, groupIDs []string, pagination pagination.Pagination) (total int64, groups []*model.GroupRequest, err error) {
+func (g *GroupRequestMgo) Page(ctx context.Context, userID string, groupIDs []string, handleResults []int, pagination pagination.Pagination) (total int64, groups []*model.GroupRequest, err error) {
-	return mongoutil.FindPage[*model.GroupRequest](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}}, pagination)
+	filter := bson.M{"user_id": userID}
+	if len(groupIDs) > 0 {
+		filter["group_id"] = bson.M{"$in": datautil.Distinct(groupIDs)}
+	}
+	if len(handleResults) > 0 {
+		filter["handle_result"] = bson.M{"$in": handleResults}
+	}
+	return mongoutil.FindPage[*model.GroupRequest](ctx, g.coll, filter, pagination, options.Find().SetSort(g.sort()))
+}
+
+func (g *GroupRequestMgo) PageGroup(ctx context.Context, groupIDs []string, handleResults []int, pagination pagination.Pagination) (total int64, groups []*model.GroupRequest, err error) {
+	if len(groupIDs) == 0 {
+		return 0, nil, nil
+	}
+	filter := bson.M{"group_id": bson.M{"$in": groupIDs}}
+	if len(handleResults) > 0 {
+		filter["handle_result"] = bson.M{"$in": handleResults}
+	}
+	return mongoutil.FindPage[*model.GroupRequest](ctx, g.coll, filter, pagination, options.Find().SetSort(g.sort()))
+}
+
+func (g *GroupRequestMgo) GetUnhandledCount(ctx context.Context, groupIDs []string, ts int64) (int64, error) {
+	if len(groupIDs) == 0 {
+		return 0, nil
+	}
+	filter := bson.M{"group_id": bson.M{"$in": groupIDs}, "handle_result": 0}
+	if ts != 0 {
+		filter["req_time"] = bson.M{"$gt": time.Unix(ts, 0)}
+	}
+	return mongoutil.Count(ctx, g.coll, filter)
 }

pkg/common/storage/database/mgo/msg.go

@@ -5,6 +5,11 @@ import (
 	"fmt"
 	"time"
 
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/database"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/protocol/constant"
@@ -14,10 +19,6 @@ import (
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/openimsdk/tools/utils/jsonutil"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
 func NewMsgMongo(db *mongo.Database) (database.Msg, error) {
@@ -1149,7 +1150,7 @@ func (m *MsgMgo) findBeforeDocSendTime(ctx context.Context, docID string, limit
 	if err != nil {
 		return 0, 0, err
 	}
-	for i := len(res) - 1; i > 0; i-- {
+	for i := len(res) - 1; i >= 0; i-- {
 		v := res[i]
 		if v.Msgs != nil && v.Msgs.Msg != nil && v.Msgs.Msg.SendTime > 0 {
 			return v.Msgs.Msg.Seq, v.Msgs.Msg.SendTime, nil
@@ -1164,7 +1165,7 @@ func (m *MsgMgo) findBeforeSendTime(ctx context.Context, conversationID string,
 		limit := int64(-1)
 		if first {
 			first = false
-			limit = m.model.GetMsgIndex(seq)
+			limit = m.model.GetLimitForSingleDoc(seq)
 		}
 		docID := m.model.BuildDocIDByIndex(conversationID, i)
 		msgSeq, msgSendTime, err := m.findBeforeDocSendTime(ctx, docID, limit)

pkg/common/storage/model/msg.go

@@ -120,15 +120,11 @@ func (m *MsgDocModel) GetDocID(conversationID string, seq int64) string {
 
 func (m *MsgDocModel) GetDocIDSeqsMap(conversationID string, seqs []int64) map[string][]int64 {
 	t := make(map[string][]int64)
-	for i := 0; i < len(seqs); i++ {
+	for _, seq := range seqs {
-		docID := m.GetDocID(conversationID, seqs[i])
+		docID := m.GetDocID(conversationID, seq)
-		if value, ok := t[docID]; !ok {
+		t[docID] = append(t[docID], seq)
-			var temp []int64
-			t[docID] = append(temp, seqs[i])
-		} else {
-			t[docID] = append(value, seqs[i])
-		}
 	}
+
 	return t
 }
 
@@ -136,6 +132,10 @@ func (*MsgDocModel) GetMsgIndex(seq int64) int64 {
 	return (seq - 1) % singleGocMsgNum
 }
 
+func (*MsgDocModel) GetLimitForSingleDoc(seq int64) int64 {
+	return seq % singleGocMsgNum
+}
+
 func (*MsgDocModel) indexGen(conversationID string, seqSuffix int64) string {
 	return conversationID + ":" + strconv.FormatInt(seqSuffix, 10)
 }

pkg/rpcli/msg.go

@@ -2,9 +2,11 @@ package rpcli
 
 import (
 	"context"
+
+	"google.golang.org/grpc"
+
 	"github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/sdkws"
-	"google.golang.org/grpc"
 )
 
 func NewMsgClient(cc grpc.ClientConnInterface) *MsgClient {

tools/s3/internal/conversion.go

@@ -4,6 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log"
+	"net/http"
+	"path/filepath"
+	"time"
+
 	"github.com/mitchellh/mapstructure"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
@@ -19,10 +24,6 @@ import (
 	"github.com/openimsdk/tools/s3/oss"
 	"github.com/spf13/viper"
 	"go.mongodb.org/mongo-driver/mongo"
-	"log"
-	"net/http"
-	"path/filepath"
-	"time"
 )
 
 const defaultTimeout = time.Second * 10
@@ -159,7 +160,7 @@ func doObject(db database.ObjectInfo, newS3, oldS3 s3.Interface, skip int) (*Res
 	if err != nil {
 		return nil, err
 	}
-	putURL, err := newS3.PresignedPutObject(ctx, obj.Key, time.Hour)
+	putURL, err := newS3.PresignedPutObject(ctx, obj.Key, time.Hour, &s3.PutOption{ContentType: obj.ContentType})
 	if err != nil {
 		return nil, err
 	}
@@ -176,7 +177,7 @@ func doObject(db database.ObjectInfo, newS3, oldS3 s3.Interface, skip int) (*Res
 		return nil, fmt.Errorf("download object failed %s", downloadResp.Status)
 	}
 	log.Printf("file size %d", obj.Size)
-	request, err := http.NewRequest(http.MethodPut, putURL, downloadResp.Body)
+	request, err := http.NewRequest(http.MethodPut, putURL.URL, downloadResp.Body)
 	if err != nil {
 		return nil, err
 	}

version/version

@@ -1 +1 @@
-v3.8.3
+v3.8.3-patch.9

version/version.go

@@ -1,6 +1,14 @@
 package version
 
-import _ "embed"
+import (
+	_ "embed"
+	"strings"
+)
 
 //go:embed version
 var Version string
+
+func init() {
+	Version = strings.Trim(Version, "\n")
+	Version = strings.TrimSpace(Version)
+}