复制项目

internal/rpc/relation/black.go

@@ -0,0 +1,165 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package relation
+
+import (
+	"context"
+	"time"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/authverify"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/convert"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/model"
+	"git.imall.cloud/openim/protocol/relation"
+	"git.imall.cloud/openim/protocol/sdkws"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/datautil"
+)
+
+func (s *friendServer) GetPaginationBlacks(ctx context.Context, req *relation.GetPaginationBlacksReq) (resp *relation.GetPaginationBlacksResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	total, blacks, err := s.blackDatabase.FindOwnerBlacks(ctx, req.UserID, req.Pagination)
+	if err != nil {
+		return nil, err
+	}
+	resp = &relation.GetPaginationBlacksResp{}
+	resp.Blacks, err = convert.BlackDB2Pb(ctx, blacks, s.userClient.GetUsersInfoMap)
+	if err != nil {
+		return nil, err
+	}
+	resp.Total = int32(total)
+	return resp, nil
+}
+
+func (s *friendServer) IsBlack(ctx context.Context, req *relation.IsBlackReq) (*relation.IsBlackResp, error) {
+	if err := authverify.CheckAccessIn(ctx, req.UserID1, req.UserID2); err != nil {
+		return nil, err
+	}
+	in1, in2, err := s.blackDatabase.CheckIn(ctx, req.UserID1, req.UserID2)
+	if err != nil {
+		return nil, err
+	}
+	resp := &relation.IsBlackResp{}
+	resp.InUser1Blacks = in1
+	resp.InUser2Blacks = in2
+	return resp, nil
+}
+
+func (s *friendServer) RemoveBlack(ctx context.Context, req *relation.RemoveBlackReq) (*relation.RemoveBlackResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+
+	if err := s.blackDatabase.Delete(ctx, []*model.Black{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
+		return nil, err
+	}
+
+	s.notificationSender.BlackDeletedNotification(ctx, req)
+	s.webhookAfterRemoveBlack(ctx, &s.config.WebhooksConfig.AfterRemoveBlack, req)
+
+	return &relation.RemoveBlackResp{}, nil
+}
+
+func (s *friendServer) AddBlack(ctx context.Context, req *relation.AddBlackReq) (*relation.AddBlackResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+
+	if err := s.webhookBeforeAddBlack(ctx, &s.config.WebhooksConfig.BeforeAddBlack, req); err != nil {
+		return nil, err
+	}
+	if err := s.userClient.CheckUser(ctx, []string{req.OwnerUserID, req.BlackUserID}); err != nil {
+		return nil, err
+	}
+	black := model.Black{
+		OwnerUserID:    req.OwnerUserID,
+		BlockUserID:    req.BlackUserID,
+		OperatorUserID: mcontext.GetOpUserID(ctx),
+		CreateTime:     time.Now(),
+		Ex:             req.Ex,
+	}
+
+	if err := s.blackDatabase.Create(ctx, []*model.Black{&black}); err != nil {
+		return nil, err
+	}
+	s.notificationSender.BlackAddedNotification(ctx, req)
+	return &relation.AddBlackResp{}, nil
+}
+
+func (s *friendServer) GetSpecifiedBlacks(ctx context.Context, req *relation.GetSpecifiedBlacksReq) (*relation.GetSpecifiedBlacksResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+
+	if len(req.UserIDList) == 0 {
+		return nil, errs.ErrArgs.WrapMsg("userIDList is empty")
+	}
+
+	if datautil.Duplicate(req.UserIDList) {
+		return nil, errs.ErrArgs.WrapMsg("userIDList repeated")
+	}
+
+	userMap, err := s.userClient.GetUsersInfoMap(ctx, req.UserIDList)
+	if err != nil {
+		return nil, err
+	}
+
+	blacks, err := s.blackDatabase.FindBlackInfos(ctx, req.OwnerUserID, req.UserIDList)
+	if err != nil {
+		return nil, err
+	}
+
+	blackMap := datautil.SliceToMap(blacks, func(e *model.Black) string {
+		return e.BlockUserID
+	})
+
+	resp := &relation.GetSpecifiedBlacksResp{
+		Blacks: make([]*sdkws.BlackInfo, 0, len(req.UserIDList)),
+	}
+
+	toPublcUser := func(userID string) *sdkws.PublicUserInfo {
+		v, ok := userMap[userID]
+		if !ok {
+			return nil
+		}
+		return &sdkws.PublicUserInfo{
+			UserID:   v.UserID,
+			Nickname: v.Nickname,
+			FaceURL:  v.FaceURL,
+			Ex:       v.Ex,
+			UserType: v.UserType,
+		}
+	}
+
+	for _, userID := range req.UserIDList {
+		if black := blackMap[userID]; black != nil {
+			resp.Blacks = append(resp.Blacks,
+				&sdkws.BlackInfo{
+					OwnerUserID:    black.OwnerUserID,
+					CreateTime:     black.CreateTime.UnixMilli(),
+					BlackUserInfo:  toPublcUser(userID),
+					AddSource:      black.AddSource,
+					OperatorUserID: black.OperatorUserID,
+					Ex:             black.Ex,
+				})
+		}
+	}
+
+	resp.Total = int32(len(resp.Blacks))
+
+	return resp, nil
+}

internal/rpc/relation/callback.go

@@ -0,0 +1,169 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package relation
+
+import (
+	"context"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/webhook"
+
+	cbapi "git.imall.cloud/openim/open-im-server-deploy/pkg/callbackstruct"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/protocol/relation"
+)
+
+func (s *friendServer) webhookAfterDeleteFriend(ctx context.Context, after *config.AfterConfig, req *relation.DeleteFriendReq) {
+	cbReq := &cbapi.CallbackAfterDeleteFriendReq{
+		CallbackCommand: cbapi.CallbackAfterDeleteFriendCommand,
+		OwnerUserID:     req.OwnerUserID,
+		FriendUserID:    req.FriendUserID,
+	}
+	s.webhookClient.AsyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, &cbapi.CallbackAfterDeleteFriendResp{}, after)
+}
+
+func (s *friendServer) webhookBeforeAddFriend(ctx context.Context, before *config.BeforeConfig, req *relation.ApplyToAddFriendReq) error {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeAddFriendReq{
+			CallbackCommand: cbapi.CallbackBeforeAddFriendCommand,
+			FromUserID:      req.FromUserID,
+			ToUserID:        req.ToUserID,
+			ReqMsg:          req.ReqMsg,
+			Ex:              req.Ex,
+		}
+		resp := &cbapi.CallbackBeforeAddFriendResp{}
+
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (s *friendServer) webhookAfterAddFriend(ctx context.Context, after *config.AfterConfig, req *relation.ApplyToAddFriendReq) {
+	cbReq := &cbapi.CallbackAfterAddFriendReq{
+		CallbackCommand: cbapi.CallbackAfterAddFriendCommand,
+		FromUserID:      req.FromUserID,
+		ToUserID:        req.ToUserID,
+		ReqMsg:          req.ReqMsg,
+	}
+	resp := &cbapi.CallbackAfterAddFriendResp{}
+	s.webhookClient.AsyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, after)
+}
+
+func (s *friendServer) webhookAfterSetFriendRemark(ctx context.Context, after *config.AfterConfig, req *relation.SetFriendRemarkReq) {
+	cbReq := &cbapi.CallbackAfterSetFriendRemarkReq{
+		CallbackCommand: cbapi.CallbackAfterSetFriendRemarkCommand,
+		OwnerUserID:     req.OwnerUserID,
+		FriendUserID:    req.FriendUserID,
+		Remark:          req.Remark,
+	}
+	resp := &cbapi.CallbackAfterSetFriendRemarkResp{}
+	s.webhookClient.AsyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, after)
+}
+
+func (s *friendServer) webhookAfterImportFriends(ctx context.Context, after *config.AfterConfig, req *relation.ImportFriendReq) {
+	cbReq := &cbapi.CallbackAfterImportFriendsReq{
+		CallbackCommand: cbapi.CallbackAfterImportFriendsCommand,
+		OwnerUserID:     req.OwnerUserID,
+		FriendUserIDs:   req.FriendUserIDs,
+	}
+	resp := &cbapi.CallbackAfterImportFriendsResp{}
+	s.webhookClient.AsyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, after)
+}
+
+func (s *friendServer) webhookAfterRemoveBlack(ctx context.Context, after *config.AfterConfig, req *relation.RemoveBlackReq) {
+	cbReq := &cbapi.CallbackAfterRemoveBlackReq{
+		CallbackCommand: cbapi.CallbackAfterRemoveBlackCommand,
+		OwnerUserID:     req.OwnerUserID,
+		BlackUserID:     req.BlackUserID,
+	}
+	resp := &cbapi.CallbackAfterRemoveBlackResp{}
+	s.webhookClient.AsyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, after)
+}
+
+func (s *friendServer) webhookBeforeSetFriendRemark(ctx context.Context, before *config.BeforeConfig, req *relation.SetFriendRemarkReq) error {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeSetFriendRemarkReq{
+			CallbackCommand: cbapi.CallbackBeforeSetFriendRemarkCommand,
+			OwnerUserID:     req.OwnerUserID,
+			FriendUserID:    req.FriendUserID,
+			Remark:          req.Remark,
+		}
+		resp := &cbapi.CallbackBeforeSetFriendRemarkResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+		if resp.Remark != "" {
+			req.Remark = resp.Remark
+		}
+		return nil
+	})
+}
+
+func (s *friendServer) webhookBeforeAddBlack(ctx context.Context, before *config.BeforeConfig, req *relation.AddBlackReq) error {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeAddBlackReq{
+			CallbackCommand: cbapi.CallbackBeforeAddBlackCommand,
+			OwnerUserID:     req.OwnerUserID,
+			BlackUserID:     req.BlackUserID,
+		}
+		resp := &cbapi.CallbackBeforeAddBlackResp{}
+		return s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before)
+	})
+}
+
+func (s *friendServer) webhookBeforeAddFriendAgree(ctx context.Context, before *config.BeforeConfig, req *relation.RespondFriendApplyReq) error {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeAddFriendAgreeReq{
+			CallbackCommand: cbapi.CallbackBeforeAddFriendAgreeCommand,
+			FromUserID:      req.FromUserID,
+			ToUserID:        req.ToUserID,
+			HandleMsg:       req.HandleMsg,
+			HandleResult:    req.HandleResult,
+		}
+		resp := &cbapi.CallbackBeforeAddFriendAgreeResp{}
+		return s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before)
+	})
+}
+
+func (s *friendServer) webhookAfterAddFriendAgree(ctx context.Context, after *config.AfterConfig, req *relation.RespondFriendApplyReq) {
+	cbReq := &cbapi.CallbackAfterAddFriendAgreeReq{
+		CallbackCommand: cbapi.CallbackAfterAddFriendAgreeCommand,
+		FromUserID:      req.FromUserID,
+		ToUserID:        req.ToUserID,
+		HandleMsg:       req.HandleMsg,
+		HandleResult:    req.HandleResult,
+	}
+	resp := &cbapi.CallbackAfterAddFriendAgreeResp{}
+	s.webhookClient.AsyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, after)
+}
+
+func (s *friendServer) webhookBeforeImportFriends(ctx context.Context, before *config.BeforeConfig, req *relation.ImportFriendReq) error {
+	return webhook.WithCondition(ctx, before, func(ctx context.Context) error {
+		cbReq := &cbapi.CallbackBeforeImportFriendsReq{
+			CallbackCommand: cbapi.CallbackBeforeImportFriendsCommand,
+			OwnerUserID:     req.OwnerUserID,
+			FriendUserIDs:   req.FriendUserIDs,
+		}
+		resp := &cbapi.CallbackBeforeImportFriendsResp{}
+		if err := s.webhookClient.SyncPost(ctx, cbReq.GetCallbackCommand(), cbReq, resp, before); err != nil {
+			return err
+		}
+		if len(resp.FriendUserIDs) > 0 {
+			req.FriendUserIDs = resp.FriendUserIDs
+		}
+		return nil
+	})
+}

internal/rpc/relation/friend.go

@@ -0,0 +1,597 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package relation
+
+import (
+	"context"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/dbbuild"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/notification/common_user"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/rpcli"
+
+	"github.com/openimsdk/tools/mq/memamq"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/authverify"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/convert"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/servererrs"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/cache/redis"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/controller"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/database/mgo"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/model"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/webhook"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/localcache"
+	"git.imall.cloud/openim/protocol/constant"
+	"git.imall.cloud/openim/protocol/relation"
+	"git.imall.cloud/openim/protocol/sdkws"
+	"github.com/openimsdk/tools/discovery"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/utils/datautil"
+	"google.golang.org/grpc"
+)
+
+type friendServer struct {
+	relation.UnimplementedFriendServer
+	db                 controller.FriendDatabase
+	blackDatabase      controller.BlackDatabase
+	notificationSender *FriendNotificationSender
+	RegisterCenter     discovery.Conn
+	config             *Config
+	webhookClient      *webhook.Client
+	queue              *memamq.MemoryQueue
+	userClient         *rpcli.UserClient
+}
+
+type Config struct {
+	RpcConfig     config.Friend
+	RedisConfig   config.Redis
+	MongodbConfig config.Mongo
+	// ZookeeperConfig    config.ZooKeeper
+	NotificationConfig config.Notification
+	Share              config.Share
+	WebhooksConfig     config.Webhooks
+	LocalCacheConfig   config.LocalCache
+	Discovery          config.Discovery
+}
+
+func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryRegistry, server grpc.ServiceRegistrar) error {
+	dbb := dbbuild.NewBuilder(&config.MongodbConfig, &config.RedisConfig)
+	mgocli, err := dbb.Mongo(ctx)
+	if err != nil {
+		return err
+	}
+	rdb, err := dbb.Redis(ctx)
+	if err != nil {
+		return err
+	}
+
+	friendMongoDB, err := mgo.NewFriendMongo(mgocli.GetDB())
+	if err != nil {
+		return err
+	}
+
+	friendRequestMongoDB, err := mgo.NewFriendRequestMongo(mgocli.GetDB())
+	if err != nil {
+		return err
+	}
+
+	blackMongoDB, err := mgo.NewBlackMongo(mgocli.GetDB())
+	if err != nil {
+		return err
+	}
+
+	userConn, err := client.GetConn(ctx, config.Discovery.RpcService.User)
+	if err != nil {
+		return err
+	}
+	msgConn, err := client.GetConn(ctx, config.Discovery.RpcService.Msg)
+	if err != nil {
+		return err
+	}
+	userClient := rpcli.NewUserClient(userConn)
+	database := controller.NewFriendDatabase(
+		friendMongoDB,
+		friendRequestMongoDB,
+		redis.NewFriendCacheRedis(rdb, &config.LocalCacheConfig, friendMongoDB),
+		mgocli.GetTx(),
+	)
+	// Initialize notification sender
+	notificationSender := NewFriendNotificationSender(
+		&config.NotificationConfig,
+		rpcli.NewMsgClient(msgConn),
+		WithRpcFunc(userClient.GetUsersInfo),
+		WithFriendDB(database),
+	)
+	localcache.InitLocalCache(&config.LocalCacheConfig)
+
+	// 初始化webhook配置管理器（支持从数据库读取配置）
+	var webhookClient *webhook.Client
+	systemConfigDB, err := mgo.NewSystemConfigMongo(mgocli.GetDB())
+	if err == nil {
+		// 如果SystemConfig数据库初始化成功，使用配置管理器
+		webhookConfigManager := webhook.NewConfigManager(systemConfigDB, &config.WebhooksConfig)
+		if err := webhookConfigManager.Start(ctx); err != nil {
+			log.ZWarn(ctx, "failed to start webhook config manager, using default config", err)
+			webhookClient = webhook.NewWebhookClient(config.WebhooksConfig.URL)
+		} else {
+			webhookClient = webhook.NewWebhookClientWithManager(webhookConfigManager)
+		}
+	} else {
+		// 如果SystemConfig数据库初始化失败，使用默认配置
+		log.ZWarn(ctx, "failed to init system config db, using default webhook config", err)
+		webhookClient = webhook.NewWebhookClient(config.WebhooksConfig.URL)
+	}
+
+	// Register Friend server with refactored MongoDB and Redis integrations
+	relation.RegisterFriendServer(server, &friendServer{
+		db: database,
+		blackDatabase: controller.NewBlackDatabase(
+			blackMongoDB,
+			redis.NewBlackCacheRedis(rdb, &config.LocalCacheConfig, blackMongoDB),
+		),
+		notificationSender: notificationSender,
+		RegisterCenter:     client,
+		config:             config,
+		webhookClient:      webhookClient,
+		queue:              memamq.NewMemoryQueue(16, 1024*1024),
+		userClient:         userClient,
+	})
+	return nil
+}
+
+// ok.
+func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *relation.ApplyToAddFriendReq) (resp *relation.ApplyToAddFriendResp, err error) {
+	resp = &relation.ApplyToAddFriendResp{}
+	if err := authverify.CheckAccess(ctx, req.FromUserID); err != nil {
+		return nil, err
+	}
+	if req.ToUserID == req.FromUserID {
+		return nil, servererrs.ErrCanNotAddYourself.WrapMsg("req.ToUserID", req.ToUserID)
+	}
+	if err = s.webhookBeforeAddFriend(ctx, &s.config.WebhooksConfig.BeforeAddFriend, req); err != nil && err != servererrs.ErrCallbackContinue {
+		return nil, err
+	}
+	if err := s.userClient.CheckUser(ctx, []string{req.ToUserID, req.FromUserID}); err != nil {
+		return nil, err
+	}
+
+	in1, in2, err := s.db.CheckIn(ctx, req.FromUserID, req.ToUserID)
+	if err != nil {
+		return nil, err
+	}
+	if in1 && in2 {
+		return nil, servererrs.ErrRelationshipAlready.WrapMsg("already friends has f")
+	}
+	if err = s.db.AddFriendRequest(ctx, req.FromUserID, req.ToUserID, req.ReqMsg, req.Ex); err != nil {
+		return nil, err
+	}
+	s.notificationSender.FriendApplicationAddNotification(ctx, req)
+	s.webhookAfterAddFriend(ctx, &s.config.WebhooksConfig.AfterAddFriend, req)
+	return resp, nil
+}
+
+// ok.
+func (s *friendServer) ImportFriends(ctx context.Context, req *relation.ImportFriendReq) (resp *relation.ImportFriendResp, err error) {
+	if err := authverify.CheckAdmin(ctx); err != nil {
+		return nil, err
+	}
+
+	if err := s.userClient.CheckUser(ctx, append([]string{req.OwnerUserID}, req.FriendUserIDs...)); err != nil {
+		return nil, err
+	}
+	if datautil.Contain(req.OwnerUserID, req.FriendUserIDs...) {
+		return nil, servererrs.ErrCanNotAddYourself.WrapMsg("can not add yourself")
+	}
+	if datautil.Duplicate(req.FriendUserIDs) {
+		return nil, errs.ErrArgs.WrapMsg("friend userID repeated")
+	}
+
+	if err := s.webhookBeforeImportFriends(ctx, &s.config.WebhooksConfig.BeforeImportFriends, req); err != nil && err != servererrs.ErrCallbackContinue {
+		return nil, err
+	}
+
+	if err := s.db.BecomeFriends(ctx, req.OwnerUserID, req.FriendUserIDs, constant.BecomeFriendByImport); err != nil {
+		return nil, err
+	}
+	for _, userID := range req.FriendUserIDs {
+		s.notificationSender.FriendApplicationAgreedNotification(ctx, &relation.RespondFriendApplyReq{
+			FromUserID:   req.OwnerUserID,
+			ToUserID:     userID,
+			HandleResult: constant.FriendResponseAgree,
+		}, false)
+	}
+
+	s.webhookAfterImportFriends(ctx, &s.config.WebhooksConfig.AfterImportFriends, req)
+	return &relation.ImportFriendResp{}, nil
+}
+
+// ok.
+func (s *friendServer) RespondFriendApply(ctx context.Context, req *relation.RespondFriendApplyReq) (resp *relation.RespondFriendApplyResp, err error) {
+	resp = &relation.RespondFriendApplyResp{}
+	if err := authverify.CheckAccess(ctx, req.ToUserID); err != nil {
+		return nil, err
+	}
+
+	friendRequest := model.FriendRequest{
+		FromUserID:   req.FromUserID,
+		ToUserID:     req.ToUserID,
+		HandleMsg:    req.HandleMsg,
+		HandleResult: req.HandleResult,
+	}
+	if req.HandleResult == constant.FriendResponseAgree {
+		if err := s.webhookBeforeAddFriendAgree(ctx, &s.config.WebhooksConfig.BeforeAddFriendAgree, req); err != nil && err != servererrs.ErrCallbackContinue {
+			return nil, err
+		}
+		err := s.db.AgreeFriendRequest(ctx, &friendRequest)
+		if err != nil {
+			return nil, err
+		}
+		s.webhookAfterAddFriendAgree(ctx, &s.config.WebhooksConfig.AfterAddFriendAgree, req)
+		s.notificationSender.FriendApplicationAgreedNotification(ctx, req, true)
+		return resp, nil
+	}
+	if req.HandleResult == constant.FriendResponseRefuse {
+		err := s.db.RefuseFriendRequest(ctx, &friendRequest)
+		if err != nil {
+			return nil, err
+		}
+		s.notificationSender.FriendApplicationRefusedNotification(ctx, req)
+		return resp, nil
+	}
+	return nil, errs.ErrArgs.WrapMsg("req.HandleResult != -1/1")
+}
+
+// ok.
+func (s *friendServer) DeleteFriend(ctx context.Context, req *relation.DeleteFriendReq) (resp *relation.DeleteFriendResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+
+	_, err = s.db.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
+	if err != nil {
+		return nil, err
+	}
+
+	if err := s.db.Delete(ctx, req.OwnerUserID, []string{req.FriendUserID}); err != nil {
+		return nil, err
+	}
+
+	s.notificationSender.FriendDeletedNotification(ctx, req)
+	s.webhookAfterDeleteFriend(ctx, &s.config.WebhooksConfig.AfterDeleteFriend, req)
+
+	return &relation.DeleteFriendResp{}, nil
+}
+
+// ok.
+func (s *friendServer) SetFriendRemark(ctx context.Context, req *relation.SetFriendRemarkReq) (resp *relation.SetFriendRemarkResp, err error) {
+	if err = s.webhookBeforeSetFriendRemark(ctx, &s.config.WebhooksConfig.BeforeSetFriendRemark, req); err != nil && err != servererrs.ErrCallbackContinue {
+		return nil, err
+	}
+
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+
+	_, err = s.db.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
+	if err != nil {
+		return nil, err
+	}
+
+	if err := s.db.UpdateRemark(ctx, req.OwnerUserID, req.FriendUserID, req.Remark); err != nil {
+		return nil, err
+	}
+
+	s.webhookAfterSetFriendRemark(ctx, &s.config.WebhooksConfig.AfterSetFriendRemark, req)
+	s.notificationSender.FriendRemarkSetNotification(ctx, req.OwnerUserID, req.FriendUserID)
+
+	return &relation.SetFriendRemarkResp{}, nil
+}
+
+func (s *friendServer) GetFriendInfo(ctx context.Context, req *relation.GetFriendInfoReq) (*relation.GetFriendInfoResp, error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+	friends, err := s.db.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
+	if err != nil {
+		return nil, err
+	}
+	return &relation.GetFriendInfoResp{FriendInfos: convert.FriendOnlyDB2PbOnly(friends)}, nil
+}
+
+func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *relation.GetDesignatedFriendsReq) (resp *relation.GetDesignatedFriendsResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+	resp = &relation.GetDesignatedFriendsResp{}
+	if datautil.Duplicate(req.FriendUserIDs) {
+		return nil, errs.ErrArgs.WrapMsg("friend userID repeated")
+	}
+	friends, err := s.getFriend(ctx, req.OwnerUserID, req.FriendUserIDs)
+	if err != nil {
+		return nil, err
+	}
+	return &relation.GetDesignatedFriendsResp{
+		FriendsInfo: friends,
+	}, nil
+}
+
+func (s *friendServer) getFriend(ctx context.Context, ownerUserID string, friendUserIDs []string) ([]*sdkws.FriendInfo, error) {
+	if len(friendUserIDs) == 0 {
+		return nil, nil
+	}
+	friends, err := s.db.FindFriendsWithError(ctx, ownerUserID, friendUserIDs)
+	if err != nil {
+		return nil, err
+	}
+	return convert.FriendsDB2Pb(ctx, friends, s.userClient.GetUsersInfoMap)
+}
+
+// Get the list of friend requests sent out proactively.
+func (s *friendServer) GetDesignatedFriendsApply(ctx context.Context, req *relation.GetDesignatedFriendsApplyReq) (resp *relation.GetDesignatedFriendsApplyResp, err error) {
+	if err := authverify.CheckAccessIn(ctx, req.FromUserID, req.ToUserID); err != nil {
+		return nil, err
+	}
+	friendRequests, err := s.db.FindBothFriendRequests(ctx, req.FromUserID, req.ToUserID)
+	if err != nil {
+		return nil, err
+	}
+	resp = &relation.GetDesignatedFriendsApplyResp{}
+	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.getCommonUserMap)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// Get received friend requests (i.e., those initiated by others).
+func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *relation.GetPaginationFriendsApplyToReq) (resp *relation.GetPaginationFriendsApplyToResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+
+	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.getCommonUserMap)
+	if err != nil {
+		return nil, err
+	}
+
+	resp.Total = int32(total)
+
+	return resp, nil
+}
+
+func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *relation.GetPaginationFriendsApplyFromReq) (resp *relation.GetPaginationFriendsApplyFromResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+
+	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 = &relation.GetPaginationFriendsApplyFromResp{}
+	resp.FriendRequests, err = convert.FriendRequestDB2Pb(ctx, friendRequests, s.getCommonUserMap)
+	if err != nil {
+		return nil, err
+	}
+
+	resp.Total = int32(total)
+
+	return resp, nil
+}
+
+// ok.
+func (s *friendServer) IsFriend(ctx context.Context, req *relation.IsFriendReq) (resp *relation.IsFriendResp, err error) {
+	if err := authverify.CheckAccessIn(ctx, req.UserID1, req.UserID2); err != nil {
+		return nil, err
+	}
+	resp = &relation.IsFriendResp{}
+	resp.InUser1Friends, resp.InUser2Friends, err = s.db.CheckIn(ctx, req.UserID1, req.UserID2)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+func (s *friendServer) GetPaginationFriends(ctx context.Context, req *relation.GetPaginationFriendsReq) (resp *relation.GetPaginationFriendsResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+
+	total, friends, err := s.db.PageOwnerFriends(ctx, req.UserID, req.Pagination)
+	if err != nil {
+		return nil, err
+	}
+
+	resp = &relation.GetPaginationFriendsResp{}
+	resp.FriendsInfo, err = convert.FriendsDB2Pb(ctx, friends, s.userClient.GetUsersInfoMap)
+	if err != nil {
+		return nil, err
+	}
+
+	resp.Total = int32(total)
+
+	return resp, nil
+}
+
+func (s *friendServer) GetFriendIDs(ctx context.Context, req *relation.GetFriendIDsReq) (resp *relation.GetFriendIDsResp, err error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+
+	resp = &relation.GetFriendIDsResp{}
+	resp.FriendIDs, err = s.db.FindFriendUserIDs(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *relation.GetSpecifiedFriendsInfoReq) (*relation.GetSpecifiedFriendsInfoResp, error) {
+	if len(req.UserIDList) == 0 {
+		return nil, errs.ErrArgs.WrapMsg("userIDList is empty")
+	}
+
+	if datautil.Duplicate(req.UserIDList) {
+		return nil, errs.ErrArgs.WrapMsg("userIDList repeated")
+	}
+
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+	userMap, err := s.userClient.GetUsersInfoMap(ctx, req.UserIDList)
+	if err != nil {
+		return nil, err
+	}
+
+	friends, err := s.db.FindFriendsWithError(ctx, req.OwnerUserID, req.UserIDList)
+	if err != nil {
+		return nil, err
+	}
+
+	blacks, err := s.blackDatabase.FindBlackInfos(ctx, req.OwnerUserID, req.UserIDList)
+	if err != nil {
+		return nil, err
+	}
+
+	friendMap := datautil.SliceToMap(friends, func(e *model.Friend) string {
+		return e.FriendUserID
+	})
+
+	blackMap := datautil.SliceToMap(blacks, func(e *model.Black) string {
+		return e.BlockUserID
+	})
+
+	resp := &relation.GetSpecifiedFriendsInfoResp{
+		Infos: make([]*relation.GetSpecifiedFriendsInfoInfo, 0, len(req.UserIDList)),
+	}
+
+	for _, userID := range req.UserIDList {
+		user := userMap[userID]
+
+		if user == nil {
+			continue
+		}
+
+		var friendInfo *sdkws.FriendInfo
+		if friend := friendMap[userID]; friend != nil {
+			friendInfo = &sdkws.FriendInfo{
+				OwnerUserID:    friend.OwnerUserID,
+				Remark:         friend.Remark,
+				CreateTime:     friend.CreateTime.UnixMilli(),
+				AddSource:      friend.AddSource,
+				OperatorUserID: friend.OperatorUserID,
+				Ex:             friend.Ex,
+				IsPinned:       friend.IsPinned,
+			}
+		}
+
+		var blackInfo *sdkws.BlackInfo
+		if black := blackMap[userID]; black != nil {
+			blackInfo = &sdkws.BlackInfo{
+				OwnerUserID:    black.OwnerUserID,
+				CreateTime:     black.CreateTime.UnixMilli(),
+				AddSource:      black.AddSource,
+				OperatorUserID: black.OperatorUserID,
+				Ex:             black.Ex,
+			}
+		}
+
+		resp.Infos = append(resp.Infos, &relation.GetSpecifiedFriendsInfoInfo{
+			UserInfo:   user,
+			FriendInfo: friendInfo,
+			BlackInfo:  blackInfo,
+		})
+	}
+
+	return resp, nil
+}
+
+func (s *friendServer) UpdateFriends(ctx context.Context, req *relation.UpdateFriendsReq) (*relation.UpdateFriendsResp, error) {
+	if len(req.FriendUserIDs) == 0 {
+		return nil, errs.ErrArgs.WrapMsg("friendIDList is empty")
+	}
+	if datautil.Duplicate(req.FriendUserIDs) {
+		return nil, errs.ErrArgs.WrapMsg("friendIDList repeated")
+	}
+
+	if err := authverify.CheckAccess(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+
+	_, err := s.db.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
+	if err != nil {
+		return nil, err
+	}
+
+	val := make(map[string]any)
+
+	if req.IsPinned != nil {
+		val["is_pinned"] = req.IsPinned.Value
+	}
+	if req.Remark != nil {
+		val["remark"] = req.Remark.Value
+	}
+	if req.Ex != nil {
+		val["ex"] = req.Ex.Value
+	}
+	if err = s.db.UpdateFriends(ctx, req.OwnerUserID, req.FriendUserIDs, val); err != nil {
+		return nil, err
+	}
+
+	resp := &relation.UpdateFriendsResp{}
+
+	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.CheckAccess(ctx, req.UserID); 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

@@ -0,0 +1,303 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package relation
+
+import (
+	"context"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/rpcli"
+	"git.imall.cloud/openim/protocol/msg"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/utils/datautil"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/database"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/versionctx"
+
+	relationtb "git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/model"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/convert"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/controller"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/notification"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/notification/common_user"
+	"git.imall.cloud/openim/protocol/constant"
+	"git.imall.cloud/openim/protocol/relation"
+	"git.imall.cloud/openim/protocol/sdkws"
+	"github.com/openimsdk/tools/mcontext"
+)
+
+type FriendNotificationSender struct {
+	*notification.NotificationSender
+	// Target not found err
+	getUsersInfo func(ctx context.Context, userIDs []string) ([]common_user.CommonUser, error)
+	// db controller
+	db controller.FriendDatabase
+}
+
+type friendNotificationSenderOptions func(*FriendNotificationSender)
+
+func WithFriendDB(db controller.FriendDatabase) friendNotificationSenderOptions {
+	return func(s *FriendNotificationSender) {
+		s.db = db
+	}
+}
+
+func WithDBFunc(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)
+			if err != nil {
+				return nil, err
+			}
+			for _, user := range users {
+				result = append(result, user)
+			}
+			return result, nil
+		}
+		s.getUsersInfo = f
+	}
+}
+
+func WithRpcFunc(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)
+			if err != nil {
+				return nil, err
+			}
+			for _, user := range users {
+				result = append(result, user)
+			}
+			return result, err
+		}
+		s.getUsersInfo = f
+	}
+}
+
+func NewFriendNotificationSender(conf *config.Notification, msgClient *rpcli.MsgClient, opts ...friendNotificationSenderOptions) *FriendNotificationSender {
+	f := &FriendNotificationSender{
+		NotificationSender: notification.NewNotificationSender(conf, notification.WithRpcClient(func(ctx context.Context, req *msg.SendMsgReq) (*msg.SendMsgResp, error) {
+			return msgClient.SendMsg(ctx, req)
+		})),
+	}
+	for _, opt := range opts {
+		opt(f)
+	}
+	return f
+}
+
+func (f *FriendNotificationSender) getUsersInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
+	users, err := f.getUsersInfo(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string]*sdkws.UserInfo)
+	for _, user := range users {
+		result[user.GetUserID()] = user.(*sdkws.UserInfo)
+	}
+	return result, nil
+}
+
+//nolint:unused
+func (f *FriendNotificationSender) getFromToUserNickname(ctx context.Context, fromUserID, toUserID string) (string, string, error) {
+	users, err := f.getUsersInfoMap(ctx, []string{fromUserID, toUserID})
+	if err != nil {
+		return "", "", nil
+	}
+	return users[fromUserID].Nickname, users[toUserID].Nickname, nil
+}
+
+func (f *FriendNotificationSender) UserInfoUpdatedNotification(ctx context.Context, changedUserID string) {
+	tips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
+	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) {
+	request, err := f.getFriendRequests(ctx, req.FromUserID, req.ToUserID)
+	if err != nil {
+		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(ctx context.Context, req *relation.RespondFriendApplyReq, checkReq bool) {
+	var (
+		request *sdkws.FriendRequest
+		err     error
+	)
+	if checkReq {
+		request, err = f.getFriendRequests(ctx, req.FromUserID, req.ToUserID)
+		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(ctx context.Context, req *relation.RespondFriendApplyReq) {
+	request, err := f.getFriendRequests(ctx, req.FromUserID, req.ToUserID)
+	if err != nil {
+		log.ZError(ctx, "FriendApplicationRefusedNotification get friend request", err, "fromUserID", req.FromUserID, "toUserID", req.ToUserID)
+		return
+	}
+	tips := sdkws.FriendApplicationRejectedTips{
+		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(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) error {
+//	tips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
+//	user, err := f.getUsersInfo(ctx, []string{opUserID})
+//	if err != nil {
+//		return err
+//	}
+//	tips.OpUser.UserID = user[0].GetUserID()
+//	tips.OpUser.Ex = user[0].GetEx()
+//	tips.OpUser.Nickname = user[0].GetNickname()
+//	tips.OpUser.FaceURL = user[0].GetFaceURL()
+//	friends, err := f.db.FindFriendsWithError(ctx, fromUserID, []string{toUserID})
+//	if err != nil {
+//		return err
+//	}
+//	tips.Friend, err = convert.FriendDB2Pb(ctx, friends[0], f.getUsersInfoMap)
+//	if err != nil {
+//		return err
+//	}
+//	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{
+		FromUserID: req.OwnerUserID,
+		ToUserID:   req.FriendUserID,
+	}}
+	f.Notification(ctx, req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &tips)
+}
+
+func (f *FriendNotificationSender) setVersion(ctx context.Context, version *uint64, versionID *string, collName string, id string) {
+	versions := versionctx.GetVersionLog(ctx).Get()
+	for _, coll := range versions {
+		if coll.Name == collName && coll.Doc.DID == id {
+			*version = uint64(coll.Doc.Version)
+			*versionID = coll.Doc.ID.Hex()
+			return
+		}
+	}
+}
+
+func (f *FriendNotificationSender) setSortVersion(ctx context.Context, version *uint64, versionID *string, collName string, id string, sortVersion *uint64) {
+	versions := versionctx.GetVersionLog(ctx).Get()
+	for _, coll := range versions {
+		if coll.Name == collName && coll.Doc.DID == id {
+			*version = uint64(coll.Doc.Version)
+			*versionID = coll.Doc.ID.Hex()
+			for _, elem := range coll.Doc.Logs {
+				if elem.EID == relationtb.VersionSortChangeID {
+					*sortVersion = uint64(elem.Version)
+				}
+			}
+		}
+	}
+}
+
+func (f *FriendNotificationSender) FriendRemarkSetNotification(ctx context.Context, fromUserID, toUserID string) {
+	tips := sdkws.FriendInfoChangedTips{FromToUserID: &sdkws.FromToUserID{}}
+	tips.FromToUserID.FromUserID = fromUserID
+	tips.FromToUserID.ToUserID = toUserID
+	f.setSortVersion(ctx, &tips.FriendVersion, &tips.FriendVersionID, database.FriendVersionName, toUserID, &tips.FriendSortVersion)
+	f.Notification(ctx, fromUserID, toUserID, constant.FriendRemarkSetNotification, &tips)
+}
+
+func (f *FriendNotificationSender) FriendsInfoUpdateNotification(ctx context.Context, toUserID string, friendIDs []string) {
+	tips := sdkws.FriendsInfoUpdateTips{FromToUserID: &sdkws.FromToUserID{}}
+	tips.FromToUserID.ToUserID = toUserID
+	tips.FriendIDs = friendIDs
+	f.Notification(ctx, toUserID, toUserID, constant.FriendsInfoUpdateNotification, &tips)
+}
+
+func (f *FriendNotificationSender) BlackAddedNotification(ctx context.Context, req *relation.AddBlackReq) {
+	tips := sdkws.BlackAddedTips{FromToUserID: &sdkws.FromToUserID{}}
+	tips.FromToUserID.FromUserID = req.OwnerUserID
+	tips.FromToUserID.ToUserID = req.BlackUserID
+	f.Notification(ctx, req.OwnerUserID, req.BlackUserID, constant.BlackAddedNotification, &tips)
+}
+
+func (f *FriendNotificationSender) BlackDeletedNotification(ctx context.Context, req *relation.RemoveBlackReq) {
+	blackDeletedTips := sdkws.BlackDeletedTips{FromToUserID: &sdkws.FromToUserID{
+		FromUserID: req.OwnerUserID,
+		ToUserID:   req.BlackUserID,
+	}}
+	f.Notification(ctx, req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
+}
+
+func (f *FriendNotificationSender) FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string) {
+	tips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
+	f.Notification(ctx, mcontext.GetOpUserID(ctx), needNotifiedUserID, constant.FriendInfoUpdatedNotification, &tips)
+}

internal/rpc/relation/sync.go

@@ -0,0 +1,108 @@
+package relation
+
+import (
+	"context"
+	"slices"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/util/hashutil"
+	"git.imall.cloud/openim/protocol/sdkws"
+	"github.com/openimsdk/tools/log"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/rpc/incrversion"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/authverify"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/model"
+	"git.imall.cloud/openim/protocol/relation"
+)
+
+func (s *friendServer) NotificationUserInfoUpdate(ctx context.Context, req *relation.NotificationUserInfoUpdateReq) (*relation.NotificationUserInfoUpdateResp, error) {
+	userIDs, err := s.db.FindFriendUserIDs(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	if len(userIDs) > 0 {
+		friendUserIDs := []string{req.UserID}
+		noCancelCtx := context.WithoutCancel(ctx)
+		err := s.queue.PushCtx(ctx, func() {
+			for _, userID := range userIDs {
+				if err := s.db.OwnerIncrVersion(noCancelCtx, userID, friendUserIDs, model.VersionStateUpdate); err != nil {
+					log.ZError(ctx, "OwnerIncrVersion", err, "userID", userID, "friendUserIDs", friendUserIDs)
+				}
+			}
+			for _, userID := range userIDs {
+				s.notificationSender.FriendInfoUpdatedNotification(noCancelCtx, req.UserID, userID)
+			}
+		})
+		if err != nil {
+			log.ZError(ctx, "NotificationUserInfoUpdate timeout", err, "userID", req.UserID)
+		}
+	}
+	return &relation.NotificationUserInfoUpdateResp{}, nil
+}
+
+func (s *friendServer) GetFullFriendUserIDs(ctx context.Context, req *relation.GetFullFriendUserIDsReq) (*relation.GetFullFriendUserIDsResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	vl, err := s.db.FindMaxFriendVersionCache(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	userIDs, err := s.db.FindFriendUserIDs(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	idHash := hashutil.IdHash(userIDs)
+	if req.IdHash == idHash {
+		userIDs = nil
+	}
+	return &relation.GetFullFriendUserIDsResp{
+		Version:   idHash,
+		VersionID: vl.ID.Hex(),
+		Equal:     req.IdHash == idHash,
+		UserIDs:   userIDs,
+	}, nil
+}
+
+func (s *friendServer) GetIncrementalFriends(ctx context.Context, req *relation.GetIncrementalFriendsReq) (*relation.GetIncrementalFriendsResp, error) {
+	if err := authverify.CheckAccess(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	var sortVersion uint64
+	opt := incrversion.Option[*sdkws.FriendInfo, relation.GetIncrementalFriendsResp]{
+		Ctx:           ctx,
+		VersionKey:    req.UserID,
+		VersionID:     req.VersionID,
+		VersionNumber: req.Version,
+		Version: func(ctx context.Context, ownerUserID string, version uint, limit int) (*model.VersionLog, error) {
+			vl, err := s.db.FindFriendIncrVersion(ctx, ownerUserID, version, limit)
+			if err != nil {
+				return nil, err
+			}
+			vl.Logs = slices.DeleteFunc(vl.Logs, func(elem model.VersionLogElem) bool {
+				if elem.EID == model.VersionSortChangeID {
+					vl.LogLen--
+					sortVersion = uint64(elem.Version)
+					return true
+				}
+				return false
+			})
+			return vl, nil
+		},
+		CacheMaxVersion: s.db.FindMaxFriendVersionCache,
+		Find: func(ctx context.Context, ids []string) ([]*sdkws.FriendInfo, error) {
+			return s.getFriend(ctx, req.UserID, ids)
+		},
+		Resp: func(version *model.VersionLog, deleteIds []string, insertList, updateList []*sdkws.FriendInfo, full bool) *relation.GetIncrementalFriendsResp {
+			return &relation.GetIncrementalFriendsResp{
+				VersionID:   version.ID.Hex(),
+				Version:     uint64(version.Version),
+				Full:        full,
+				Delete:      deleteIds,
+				Insert:      insertList,
+				Update:      updateList,
+				SortVersion: sortVersion,
+			}
+		},
+	}
+	return opt.Build()
+}