feat: add the notificationAccount (#1602)

* feat: add notification API

* fix: fix the script

* fix: fix the error

internal/api/friend.go

@@ -92,6 +92,3 @@ func (o *FriendApi) GetFriendIDs(c *gin.Context) {
 func (o *FriendApi) GetSpecifiedFriendsInfo(c *gin.Context) {
 	a2r.Call(friend.FriendClient.GetSpecifiedFriendsInfo, o.Client, c)
 }
-func (o *FriendApi) SetPinFriends(c *gin.Context) {
-	a2r.Call(friend.FriendClient.PinFriends, o.Client, c)
-}

internal/api/msg.go

@@ -169,9 +169,8 @@ func (m *MessageApi) getSendMsgReq(c *gin.Context, req apistruct.SendMsg) (sendM
 	case constant.OANotification:
 		data = apistruct.OANotificationElem{}
 		req.SessionType = constant.NotificationChatType
-		if !authverify.IsManagerUserID(req.SendID) {
-			return nil, errs.ErrNoPermission.
-				Wrap("only app manager can as sender send OANotificationElem")
+		if err = m.userRpcClient.GetNotificationByID(c, req.SendID); err != nil {
+			return nil, err
 		}
 	default:
 		return nil, errs.ErrArgs.WithDetail("not support err contentType")

internal/api/route.go

@@ -82,6 +82,10 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		userRouterGroup.POST("/process_user_command_delete", ParseToken, u.ProcessUserCommandDelete)
 		userRouterGroup.POST("/process_user_command_update", ParseToken, u.ProcessUserCommandUpdate)
 		userRouterGroup.POST("/process_user_command_get", ParseToken, u.ProcessUserCommandGet)
+
+		userRouterGroup.POST("/add_notification_account", ParseToken, u.AddNotificationAccount)
+		userRouterGroup.POST("/update_notification_account", ParseToken, u.UpdateNotificationAccountInfo)
+		userRouterGroup.POST("/search_notification_account", ParseToken, u.SearchNotificationAccount)
 	}
 	// friend routing group
 	friendRouterGroup := r.Group("/friend", ParseToken)
@@ -103,7 +107,7 @@ func NewGinRouter(discov discoveryregistry.SvcDiscoveryRegistry, rdb redis.Unive
 		friendRouterGroup.POST("/is_friend", f.IsFriend)
 		friendRouterGroup.POST("/get_friend_id", f.GetFriendIDs)
 		friendRouterGroup.POST("/get_specified_friends_info", f.GetSpecifiedFriendsInfo)
-		friendRouterGroup.POST("/set_pin_friend", f.SetPinFriends)
+		//friendRouterGroup.POST("/set_pin_friend", f.SetPinFriends)
 	}
 	g := NewGroupApi(*groupRpc)
 	groupRouterGroup := r.Group("/group", ParseToken)

internal/api/user.go

@@ -15,8 +15,6 @@
 package api
 
 import (
-	"github.com/gin-gonic/gin"
-
 	"github.com/OpenIMSDK/protocol/constant"
 	"github.com/OpenIMSDK/protocol/msggateway"
 	"github.com/OpenIMSDK/protocol/user"
@@ -24,6 +22,7 @@ import (
 	"github.com/OpenIMSDK/tools/apiresp"
 	"github.com/OpenIMSDK/tools/errs"
 	"github.com/OpenIMSDK/tools/log"
+	"github.com/gin-gonic/gin"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
@@ -219,3 +218,15 @@ func (u *UserApi) ProcessUserCommandUpdate(c *gin.Context) {
 func (u *UserApi) ProcessUserCommandGet(c *gin.Context) {
 	a2r.Call(user.UserClient.ProcessUserCommandGet, u.Client, c)
 }
+
+func (u *UserApi) AddNotificationAccount(c *gin.Context) {
+	a2r.Call(user.UserClient.AddNotificationAccount, u.Client, c)
+}
+
+func (u *UserApi) UpdateNotificationAccountInfo(c *gin.Context) {
+	a2r.Call(user.UserClient.UpdateNotificationAccountInfo, u.Client, c)
+}
+
+func (u *UserApi) SearchNotificationAccount(c *gin.Context) {
+	a2r.Call(user.UserClient.SearchNotificationAccount, u.Client, c)
+}

internal/rpc/friend/friend.go

@@ -53,6 +53,11 @@ type friendServer struct {
 	RegisterCenter        registry.SvcDiscoveryRegistry
 }
 
+func (s *friendServer) UpdateFriends(ctx context.Context, req *pbfriend.UpdateFriendsReq) (*pbfriend.UpdateFriendsResp, error) {
+	//TODO implement me
+	panic("implement me")
+}
+
 func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	// Initialize MongoDB
 	mongo, err := unrelation.NewMongo()
@@ -438,8 +443,8 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *pbfrien
 }
 func (s *friendServer) PinFriends(
 	ctx context.Context,
-	req *pbfriend.PinFriendsReq,
-) (*pbfriend.PinFriendsResp, error) {
+	req *pbfriend.UpdateFriendsReq,
+) (*pbfriend.UpdateFriendsResp, error) {
 	if len(req.FriendUserIDs) == 0 {
 		return nil, errs.ErrArgs.Wrap("friendIDList is empty")
 	}
@@ -465,6 +470,6 @@ func (s *friendServer) PinFriends(
 		}
 	}
 
-	resp := &pbfriend.PinFriendsResp{}
+	resp := &pbfriend.UpdateFriendsResp{}
 	return resp, nil
 }

internal/rpc/user/user.go

@@ -17,6 +17,7 @@ package user
 import (
 	"context"
 	"errors"
+	"math/rand"
 	"strings"
 	"time"
 
@@ -72,6 +73,12 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	for k, v := range config.Config.Manager.UserID {
 		users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.Manager.Nickname[k], AppMangerLevel: constant.AppAdmin})
 	}
+	if len(config.Config.IMAdmin.UserID) != len(config.Config.IMAdmin.Nickname) {
+		return errors.New("len(config.Config.AppNotificationAdmin.AppManagerUid) != len(config.Config.AppNotificationAdmin.Nickname)")
+	}
+	for k, v := range config.Config.IMAdmin.UserID {
+		users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.IMAdmin.Nickname[k], AppMangerLevel: constant.AppNotificationAdmin})
+	}
 	userDB, err := mgo.NewUserMongo(mongo.GetDatabase())
 	if err != nil {
 		return err
@@ -390,3 +397,124 @@ func (s *userServer) ProcessUserCommandGet(ctx context.Context, req *pbuser.Proc
 	// Return the response with the slice
 	return &pbuser.ProcessUserCommandGetResp{KVArray: commandInfoSlice}, nil
 }
+
+func (s *userServer) AddNotificationAccount(ctx context.Context, req *pbuser.AddNotificationAccountReq) (*pbuser.AddNotificationAccountResp, error) {
+	if err := authverify.CheckIMAdmin(ctx); err != nil {
+		return nil, err
+	}
+
+	var userID string
+	for i := 0; i < 20; i++ {
+		userId := s.genUserID()
+		_, err := s.UserDatabase.FindWithError(ctx, []string{userId})
+		if err == nil {
+			continue
+		}
+		userID = userId
+		break
+	}
+	if userID == "" {
+		return nil, errs.ErrInternalServer.Wrap("gen user id failed")
+	}
+
+	user := &tablerelation.UserModel{
+		UserID:         userID,
+		Nickname:       req.NickName,
+		FaceURL:        req.FaceURL,
+		CreateTime:     time.Now(),
+		AppMangerLevel: constant.AppNotificationAdmin,
+	}
+	if err := s.UserDatabase.Create(ctx, []*tablerelation.UserModel{user}); err != nil {
+		return nil, err
+	}
+
+	return &pbuser.AddNotificationAccountResp{}, nil
+}
+
+func (s *userServer) UpdateNotificationAccountInfo(ctx context.Context, req *pbuser.UpdateNotificationAccountInfoReq) (*pbuser.UpdateNotificationAccountInfoResp, error) {
+	if err := authverify.CheckIMAdmin(ctx); err != nil {
+		return nil, err
+	}
+
+	if _, err := s.UserDatabase.FindWithError(ctx, []string{req.UserID}); err != nil {
+		return nil, errs.ErrArgs.Wrap()
+	}
+
+	user := map[string]interface{}{}
+
+	if req.NickName != "" {
+		user["nickname"] = req.NickName
+	}
+
+	if req.FaceURL != "" {
+		user["face_url"] = req.FaceURL
+	}
+
+	if err := s.UserDatabase.UpdateByMap(ctx, req.UserID, user); err != nil {
+		return nil, err
+	}
+
+	return &pbuser.UpdateNotificationAccountInfoResp{}, nil
+}
+
+func (s *userServer) SearchNotificationAccount(ctx context.Context, req *pbuser.SearchNotificationAccountReq) (*pbuser.SearchNotificationAccountResp, error) {
+	if err := authverify.CheckIMAdmin(ctx); err != nil {
+		return nil, err
+	}
+
+	_, users, err := s.UserDatabase.Page(ctx, req.Pagination)
+	if err != nil {
+		return nil, err
+	}
+
+	var total int64
+	accounts := make([]*pbuser.NotificationAccountInfo, 0, len(users))
+	for _, v := range users {
+		if v.AppMangerLevel != constant.AppNotificationAdmin {
+			continue
+		}
+		temp := &pbuser.NotificationAccountInfo{
+			UserID:   v.UserID,
+			FaceURL:  v.FaceURL,
+			NickName: v.Nickname,
+		}
+		accounts = append(accounts, temp)
+		total += 1
+	}
+	return &pbuser.SearchNotificationAccountResp{Total: total, NotificationAccounts: accounts}, nil
+}
+
+func (s *userServer) UpdateUserInfoEx(ctx context.Context, req *pbuser.UpdateUserInfoExReq) (*pbuser.UpdateUserInfoExResp, error) {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (s *userServer) GetNotificationAccount(ctx context.Context, req *pbuser.GetNotificationAccountReq) (*pbuser.GetNotificationAccountResp, error) {
+	if req.UserID == "" {
+		return nil, errs.ErrArgs.Wrap("userID is empty")
+	}
+	user, err := s.UserDatabase.GetUserByID(ctx, req.UserID)
+	if err != nil {
+		return nil, errs.ErrUserIDNotFound.Wrap()
+	}
+	if user.AppMangerLevel == constant.AppAdmin || user.AppMangerLevel == constant.AppNotificationAdmin {
+		return &pbuser.GetNotificationAccountResp{}, nil
+	}
+
+	return nil, errs.ErrNoPermission.Wrap("notification messages cannot be sent for this ID")
+}
+
+func (s *userServer) genUserID() string {
+	const l = 10
+	data := make([]byte, l)
+	rand.Read(data)
+	chars := []byte("0123456789")
+	for i := 0; i < len(data); i++ {
+		if i == 0 {
+			data[i] = chars[1:][data[i]%9]
+		} else {
+			data[i] = chars[data[i]%10]
+		}
+	}
+	return string(data)
+}