mirror of
https://github.com/openimsdk/open-im-server.git
synced 2025-04-06 04:15:46 +08:00
e24b0e2114
* Resolving code conflicts after project directory changes and Add subscribe and unsubscribe mongodb operations * Organize and update module dependencies * Get user online status * Get user online status * Get user online status
279 lines
9.6 KiB
Go
279 lines
9.6 KiB
Go
// 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 user
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/authverify"
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
|
||
"github.com/OpenIMSDK/tools/log"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
|
||
tablerelation "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient"
|
||
"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
|
||
"github.com/OpenIMSDK/protocol/constant"
|
||
"github.com/OpenIMSDK/protocol/sdkws"
|
||
pbuser "github.com/OpenIMSDK/protocol/user"
|
||
registry "github.com/OpenIMSDK/tools/discoveryregistry"
|
||
"github.com/OpenIMSDK/tools/errs"
|
||
"github.com/OpenIMSDK/tools/tx"
|
||
|
||
"google.golang.org/grpc"
|
||
|
||
"github.com/OpenIMSDK/tools/utils"
|
||
)
|
||
|
||
type userServer struct {
|
||
controller.UserDatabase
|
||
notificationSender *notification.FriendNotificationSender
|
||
friendRpcClient *rpcclient.FriendRpcClient
|
||
RegisterCenter registry.SvcDiscoveryRegistry
|
||
}
|
||
|
||
func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
|
||
db, err := relation.NewGormDB()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
rdb, err := cache.NewRedis()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
mongo, err := unrelation.NewMongo()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if err := db.AutoMigrate(&tablerelation.UserModel{}); err != nil {
|
||
return err
|
||
}
|
||
users := make([]*tablerelation.UserModel, 0)
|
||
if len(config.Config.Manager.UserID) != len(config.Config.Manager.Nickname) {
|
||
return errors.New("len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname)")
|
||
}
|
||
for k, v := range config.Config.Manager.UserID {
|
||
users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.Manager.Nickname[k], AppMangerLevel: constant.AppAdmin})
|
||
}
|
||
userDB := relation.NewUserGorm(db)
|
||
cache := cache.NewUserCacheRedis(rdb, userDB, cache.GetDefaultOpt())
|
||
userMongoDB := unrelation.NewUserMongoDriver(mongo.GetDatabase())
|
||
database := controller.NewUserDatabase(userDB, cache, tx.NewGorm(db), userMongoDB)
|
||
friendRpcClient := rpcclient.NewFriendRpcClient(client)
|
||
msgRpcClient := rpcclient.NewMessageRpcClient(client)
|
||
u := &userServer{
|
||
UserDatabase: database,
|
||
RegisterCenter: client,
|
||
friendRpcClient: &friendRpcClient,
|
||
notificationSender: notification.NewFriendNotificationSender(&msgRpcClient, notification.WithDBFunc(database.FindWithError)),
|
||
}
|
||
pbuser.RegisterUserServer(server, u)
|
||
return u.UserDatabase.InitOnce(context.Background(), users)
|
||
}
|
||
|
||
func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbuser.GetDesignateUsersReq) (resp *pbuser.GetDesignateUsersResp, err error) {
|
||
resp = &pbuser.GetDesignateUsersResp{}
|
||
users, err := s.FindWithError(ctx, req.UserIDs)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
resp.UsersInfo = convert.UsersDB2Pb(users)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserInfoReq) (resp *pbuser.UpdateUserInfoResp, err error) {
|
||
resp = &pbuser.UpdateUserInfoResp{}
|
||
err = authverify.CheckAccessV3(ctx, req.UserInfo.UserID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
user := convert.UserPb2DB(req.UserInfo)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
err = s.Update(ctx, user)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
_ = s.notificationSender.UserInfoUpdatedNotification(ctx, req.UserInfo.UserID)
|
||
friends, err := s.friendRpcClient.GetFriendIDs(ctx, req.UserInfo.UserID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
for _, friendID := range friends {
|
||
s.notificationSender.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, friendID)
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.SetGlobalRecvMessageOptReq) (resp *pbuser.SetGlobalRecvMessageOptResp, err error) {
|
||
resp = &pbuser.SetGlobalRecvMessageOptResp{}
|
||
if _, err := s.FindWithError(ctx, []string{req.UserID}); err != nil {
|
||
return nil, err
|
||
}
|
||
m := make(map[string]interface{}, 1)
|
||
m["global_recv_msg_opt"] = req.GlobalRecvMsgOpt
|
||
if err := s.UpdateByMap(ctx, req.UserID, m); err != nil {
|
||
return nil, err
|
||
}
|
||
s.notificationSender.UserInfoUpdatedNotification(ctx, req.UserID)
|
||
return resp, nil
|
||
}
|
||
|
||
func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckReq) (resp *pbuser.AccountCheckResp, err error) {
|
||
resp = &pbuser.AccountCheckResp{}
|
||
if utils.Duplicate(req.CheckUserIDs) {
|
||
return nil, errs.ErrArgs.Wrap("userID repeated")
|
||
}
|
||
err = authverify.CheckAdmin(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
users, err := s.Find(ctx, req.CheckUserIDs)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
userIDs := make(map[string]interface{}, 0)
|
||
for _, v := range users {
|
||
userIDs[v.UserID] = nil
|
||
}
|
||
for _, v := range req.CheckUserIDs {
|
||
temp := &pbuser.AccountCheckRespSingleUserStatus{UserID: v}
|
||
if _, ok := userIDs[v]; ok {
|
||
temp.AccountStatus = constant.Registered
|
||
} else {
|
||
temp.AccountStatus = constant.UnRegistered
|
||
}
|
||
resp.Results = append(resp.Results, temp)
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbuser.GetPaginationUsersReq) (resp *pbuser.GetPaginationUsersResp, err error) {
|
||
var pageNumber, showNumber int32
|
||
if req.Pagination != nil {
|
||
pageNumber = req.Pagination.PageNumber
|
||
showNumber = req.Pagination.ShowNumber
|
||
}
|
||
users, total, err := s.Page(ctx, pageNumber, showNumber)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &pbuser.GetPaginationUsersResp{Total: int32(total), Users: convert.UsersDB2Pb(users)}, err
|
||
}
|
||
|
||
func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterReq) (resp *pbuser.UserRegisterResp, err error) {
|
||
resp = &pbuser.UserRegisterResp{}
|
||
if len(req.Users) == 0 {
|
||
return nil, errs.ErrArgs.Wrap("users is empty")
|
||
}
|
||
if req.Secret != config.Config.Secret {
|
||
log.ZDebug(ctx, "UserRegister", config.Config.Secret, req.Secret)
|
||
return nil, errs.ErrNoPermission.Wrap("secret invalid")
|
||
}
|
||
if utils.DuplicateAny(req.Users, func(e *sdkws.UserInfo) string { return e.UserID }) {
|
||
return nil, errs.ErrArgs.Wrap("userID repeated")
|
||
}
|
||
userIDs := make([]string, 0)
|
||
for _, user := range req.Users {
|
||
if user.UserID == "" {
|
||
return nil, errs.ErrArgs.Wrap("userID is empty")
|
||
}
|
||
if strings.Contains(user.UserID, ":") {
|
||
return nil, errs.ErrArgs.Wrap("userID contains ':' is invalid userID")
|
||
}
|
||
userIDs = append(userIDs, user.UserID)
|
||
}
|
||
exist, err := s.IsExist(ctx, userIDs)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if exist {
|
||
return nil, errs.ErrRegisteredAlready.Wrap("userID registered already")
|
||
}
|
||
now := time.Now()
|
||
users := make([]*tablerelation.UserModel, 0, len(req.Users))
|
||
for _, user := range req.Users {
|
||
users = append(users, &tablerelation.UserModel{
|
||
UserID: user.UserID,
|
||
Nickname: user.Nickname,
|
||
FaceURL: user.FaceURL,
|
||
Ex: user.Ex,
|
||
CreateTime: now,
|
||
AppMangerLevel: user.AppMangerLevel,
|
||
GlobalRecvMsgOpt: user.GlobalRecvMsgOpt,
|
||
})
|
||
}
|
||
if err := s.Create(ctx, users); err != nil {
|
||
return nil, err
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
func (s *userServer) GetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.GetGlobalRecvMessageOptReq) (resp *pbuser.GetGlobalRecvMessageOptResp, err error) {
|
||
user, err := s.FindWithError(ctx, []string{req.UserID})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &pbuser.GetGlobalRecvMessageOptResp{GlobalRecvMsgOpt: user[0].GlobalRecvMsgOpt}, nil
|
||
}
|
||
|
||
// GetAllUserID Get user account by page.
|
||
func (s *userServer) GetAllUserID(ctx context.Context, req *pbuser.GetAllUserIDReq) (resp *pbuser.GetAllUserIDResp, err error) {
|
||
userIDs, err := s.UserDatabase.GetAllUserID(ctx, req.Pagination.PageNumber, req.Pagination.ShowNumber)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &pbuser.GetAllUserIDResp{UserIDs: userIDs}, nil
|
||
}
|
||
|
||
// SubscribeOrCancelUsersStatus Subscribe online or cancel online users.
|
||
func (s *userServer) SubscribeOrCancelUsersStatus(ctx context.Context, req *pbuser.SubscribeOrCancelUsersStatusReq) (resp *pbuser.SubscribeOrCancelUsersStatusResp, err error) {
|
||
err = s.UserDatabase.SubscribeOrCancelUsersStatus(ctx, req.UserID, req.UserIDs, req.Genre)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
//var status map[string][]string
|
||
//TODO 获取用户在线列表，返回订阅的用户的在线列表
|
||
|
||
return &pbuser.SubscribeOrCancelUsersStatusResp{}, nil
|
||
}
|
||
|
||
func (s *userServer) GetUserStatus(ctx context.Context, req *pbuser.GetUserStatusReq) (resp *pbuser.GetUserStatusResp, err error) {
|
||
//TODO 是否加一个参数校验-判断req.userID的数量，每一个获取加一个限制，一次请求限制500？
|
||
onlineStatusList, err := s.UserDatabase.GetUserStatus(ctx, req.UserIDs)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &pbuser.GetUserStatusResp{StatusList: onlineStatusList}, nil
|
||
}
|
||
|
||
func (s *userServer) SetUserStatus(ctx context.Context, req *pbuser.SetUserStatusReq) (resp *pbuser.SetUserStatusResp, err error) {
|
||
err = s.UserDatabase.SetUserStatus(ctx, req.StatusList)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &pbuser.SetUserStatusResp{}, nil
|
||
}
|