Merge remote-tracking branch 'origin/errcode' into errcode

# Conflicts:
#	internal/rpc/group/callback.go

internal/rpc/admincms/admin_cms.go

@@ -1,547 +0,0 @@
-package admincms
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db/cache"
-	"Open_IM/pkg/common/db/controller"
-	"Open_IM/pkg/common/db/relation"
-	"Open_IM/pkg/common/log"
-	promePkg "Open_IM/pkg/common/prometheus"
-	"Open_IM/pkg/common/tokenverify"
-	"Open_IM/pkg/common/tracelog"
-	pbAdminCMS "Open_IM/pkg/proto/admin_cms"
-	common "Open_IM/pkg/proto/sdkws"
-
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-
-	"Open_IM/pkg/utils"
-	"context"
-	"errors"
-	"net"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"google.golang.org/grpc"
-	"gorm.io/gorm"
-)
-
-type adminCMSServer struct {
-	rpcPort           int
-	rpcRegisterName   string
-	etcdSchema        string
-	etcdAddr          []string
-	adminCMSInterface controller.AdminCMSInterface
-	groupInterface    controller.GroupInterface
-	userInterface     controller.UserInterface
-	chatLogInterface  controller.ChatLogInterface
-}
-
-func NewAdminCMSServer(port int) *adminCMSServer {
-	log.NewPrivateLog(constant.LogFileName)
-	admin := &adminCMSServer{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImAdminCMSName,
-		etcdSchema:      config.Config.Zookeeper.Schema,
-		etcdAddr:        config.Config.Zookeeper.ZkAddr,
-	}
-	var mysql relation.Mysql
-	var redis cache.RedisClient
-	mysql.InitConn()
-	redis.InitRedis()
-	admin.userInterface = controller.NewUserController(mysql.GormConn())
-	admin.groupInterface = controller.NewGroupInterface(mysql.GormConn(), redis.GetClient(), nil)
-	admin.adminCMSInterface = controller.NewAdminCMSController(mysql.GormConn())
-	admin.chatLogInterface = controller.NewChatLogController(mysql.GormConn())
-	return admin
-}
-
-func (s *adminCMSServer) Run() {
-	log.NewInfo("0", "AdminCMS rpc start ")
-	listenIP := ""
-	if config.Config.ListenIP == "" {
-		listenIP = "0.0.0.0"
-	} else {
-		listenIP = config.Config.ListenIP
-	}
-	address := listenIP + ":" + strconv.Itoa(s.rpcPort)
-	//listener network
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		panic("listening err:" + err.Error() + s.rpcRegisterName)
-	}
-	log.NewInfo("0", "listen network success, ", address, listener)
-	defer listener.Close()
-	var grpcOpts []grpc.ServerOption
-	if config.Config.Prometheus.Enable {
-		promePkg.NewGrpcRequestCounter()
-		promePkg.NewGrpcRequestFailedCounter()
-		promePkg.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(promePkg.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	//Service registers with etcd
-	pbAdminCMS.RegisterAdminCMSServer(srv, s)
-	rpcRegisterIP := config.Config.RpcRegisterIP
-	if config.Config.RpcRegisterIP == "" {
-		rpcRegisterIP, err = utils.GetLocalIP()
-		if err != nil {
-			log.Error("", "GetLocalIP failed ", err.Error())
-		}
-	}
-	log.NewInfo("", "rpcRegisterIP ", rpcRegisterIP)
-	err = rpc.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10, "")
-	if err != nil {
-		log.NewError("0", "RegisterEtcd failed ", err.Error())
-		panic(utils.Wrap(err, "register admin module  rpc to etcd err"))
-	}
-	err = srv.Serve(listener)
-	if err != nil {
-		log.NewError("0", "Serve failed ", err.Error())
-		return
-	}
-	log.NewInfo("0", "message cms rpc success")
-}
-
-func (s *adminCMSServer) AdminLogin(ctx context.Context, req *pbAdminCMS.AdminLoginReq) (*pbAdminCMS.AdminLoginResp, error) {
-	resp := &pbAdminCMS.AdminLoginResp{}
-	for i, adminID := range config.Config.Manager.AppManagerUid {
-		if adminID == req.AdminID && config.Config.Manager.Secrets[i] == req.Secret {
-			token, expTime, err := tokenverify.CreateToken(adminID, constant.LinuxPlatformID)
-			if err != nil {
-				log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "generate token failed", "adminID: ", adminID, err.Error())
-				return nil, err
-			}
-			log.NewInfo(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "generate token success", "token: ", token, "expTime:", expTime)
-			resp.Token = token
-			break
-		}
-	}
-	if resp.Token == "" {
-		log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "failed")
-		return nil, constant.ErrInternalServer
-	}
-	admin, err := s.userInterface.Take(ctx, req.AdminID)
-	if err != nil {
-		return nil, err
-	}
-	resp.UserName = admin.Nickname
-	resp.FaceURL = admin.FaceURL
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetUserToken(ctx context.Context, req *pbAdminCMS.GetUserTokenReq) (*pbAdminCMS.GetUserTokenResp, error) {
-	token, expTime, err := tokenverify.CreateToken(req.UserID, int(req.PlatformID))
-	if err != nil {
-		return nil, err
-	}
-	resp := &pbAdminCMS.GetUserTokenResp{Token: token, ExpTime: expTime}
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetChatLogs(ctx context.Context, req *pbAdminCMS.GetChatLogsReq) (*pbAdminCMS.GetChatLogsResp, error) {
-	chatLog := relation.ChatLog{
-		Content:     req.Content,
-		ContentType: req.ContentType,
-		SessionType: req.SessionType,
-		RecvID:      req.RecvID,
-		SendID:      req.SendID,
-	}
-	if req.SendTime != "" {
-		sendTime, err := utils.TimeStringToTime(req.SendTime)
-		if err != nil {
-			log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "time string parse error", err.Error())
-			return nil, err
-		}
-		chatLog.SendTime = sendTime
-	}
-	num, chatLogs, err := s.chatLogInterface.GetChatLog(&chatLog, req.Pagination.PageNumber, req.Pagination.ShowNumber, []int32{
-		constant.Text,
-		constant.Picture,
-		constant.Voice,
-		constant.Video,
-		constant.File,
-		constant.AtText,
-		constant.Merger,
-		constant.Card,
-		constant.Location,
-		constant.Custom,
-		constant.Revoke,
-		constant.Quote,
-		constant.AdvancedText,
-		constant.AdvancedRevoke,
-		constant.CustomNotTriggerConversation,
-	})
-	if err != nil {
-		return nil, err
-	}
-	resp := &pbAdminCMS.GetChatLogsResp{}
-	resp.ChatLogsNum = int32(num)
-	for _, chatLog := range chatLogs {
-		pbChatLog := &pbAdminCMS.ChatLog{}
-		utils.CopyStructFields(pbChatLog, chatLog)
-		pbChatLog.SendTime = chatLog.SendTime.Unix()
-		pbChatLog.CreateTime = chatLog.CreateTime.Unix()
-		if chatLog.SenderNickname == "" {
-			sendUser, err := s.userInterface.Take(ctx, chatLog.SendID)
-			if err != nil {
-				return nil, err
-			}
-			pbChatLog.SenderNickname = sendUser.Nickname
-		}
-		switch chatLog.SessionType {
-		case constant.SingleChatType:
-			recvUser, err := s.userInterface.Take(ctx, chatLog.RecvID)
-			if err != nil {
-				return nil, err
-			}
-			pbChatLog.SenderNickname = recvUser.Nickname
-
-		case constant.GroupChatType, constant.SuperGroupChatType:
-			group, err := s.groupInterface.TakeGroup(ctx, chatLog.RecvID)
-			if err != nil {
-				return nil, err
-			}
-			pbChatLog.RecvID = group.GroupID
-			pbChatLog.GroupName = group.GroupName
-		}
-		resp.ChatLogs = append(resp.ChatLogs, pbChatLog)
-	}
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetActiveGroup(_ context.Context, req *pbAdminCMS.GetActiveGroupReq) (*pbAdminCMS.GetActiveGroupResp, error) {
-	resp := &pbAdminCMS.GetActiveGroupResp{}
-	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
-	if err != nil {
-		return nil, err
-	}
-	activeGroups, err := s.adminCMSInterface.GetActiveGroups(fromTime, toTime, 12)
-	if err != nil {
-		return nil, err
-	}
-	for _, activeGroup := range activeGroups {
-		resp.Groups = append(resp.Groups,
-			&pbAdminCMS.GroupResp{
-				GroupName:  activeGroup.Name,
-				GroupID:    activeGroup.ID,
-				MessageNum: int32(activeGroup.MessageNum),
-			})
-	}
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetActiveUser(ctx context.Context, req *pbAdminCMS.GetActiveUserReq) (*pbAdminCMS.GetActiveUserResp, error) {
-	resp := &pbAdminCMS.GetActiveUserResp{}
-	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
-	if err != nil {
-		log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
-		return nil, err
-	}
-	activeUsers, err := s.adminCMSInterface.GetActiveUsers(fromTime, toTime, 12)
-	if err != nil {
-		return nil, err
-	}
-	for _, activeUser := range activeUsers {
-		resp.Users = append(resp.Users,
-			&pbAdminCMS.UserResp{
-				UserID:     activeUser.ID,
-				NickName:   activeUser.Name,
-				MessageNum: int32(activeUser.MessageNum),
-			},
-		)
-	}
-	return resp, nil
-}
-
-func ParseTimeFromTo(from, to string) (time.Time, time.Time, error) {
-	var fromTime time.Time
-	var toTime time.Time
-	fromTime, err := utils.TimeStringToTime(from)
-	if err != nil {
-		return fromTime, toTime, err
-	}
-	toTime, err = utils.TimeStringToTime(to)
-	if err != nil {
-		return fromTime, toTime, err
-	}
-	return fromTime, toTime, nil
-}
-
-func isInOneMonth(from, to time.Time) bool {
-	return from.Month() == to.Month() && from.Year() == to.Year()
-}
-
-func GetRangeDate(from, to time.Time) [][2]time.Time {
-	interval := to.Sub(from)
-	var times [][2]time.Time
-	switch {
-	// today
-	case interval == 0:
-		times = append(times, [2]time.Time{
-			from, from.Add(time.Hour * 24),
-		})
-	// days
-	case isInOneMonth(from, to):
-		for i := 0; ; i++ {
-			fromTime := from.Add(time.Hour * 24 * time.Duration(i))
-			toTime := from.Add(time.Hour * 24 * time.Duration(i+1))
-			if toTime.After(to.Add(time.Hour * 24)) {
-				break
-			}
-			times = append(times, [2]time.Time{
-				fromTime, toTime,
-			})
-		}
-	// month
-	case !isInOneMonth(from, to):
-		if to.Sub(from) < time.Hour*24*30 {
-			for i := 0; ; i++ {
-				fromTime := from.Add(time.Hour * 24 * time.Duration(i))
-				toTime := from.Add(time.Hour * 24 * time.Duration(i+1))
-				if toTime.After(to.Add(time.Hour * 24)) {
-					break
-				}
-				times = append(times, [2]time.Time{
-					fromTime, toTime,
-				})
-			}
-		} else {
-			for i := 0; ; i++ {
-				if i == 0 {
-					fromTime := from
-					toTime := getFirstDateOfNextNMonth(fromTime, 1)
-					times = append(times, [2]time.Time{
-						fromTime, toTime,
-					})
-				} else {
-					fromTime := getFirstDateOfNextNMonth(from, i)
-					toTime := getFirstDateOfNextNMonth(fromTime, 1)
-					if toTime.After(to) {
-						toTime = to
-						times = append(times, [2]time.Time{
-							fromTime, toTime,
-						})
-						break
-					}
-					times = append(times, [2]time.Time{
-						fromTime, toTime,
-					})
-				}
-
-			}
-		}
-	}
-	return times
-}
-
-func getFirstDateOfNextNMonth(currentTime time.Time, n int) time.Time {
-	lastOfMonth := time.Date(currentTime.Year(), currentTime.Month(), 1, 0, 0, 0, 0, currentTime.Location()).AddDate(0, n, 0)
-	return lastOfMonth
-}
-
-func (s *adminCMSServer) GetGroupStatistics(ctx context.Context, req *pbAdminCMS.GetGroupStatisticsReq) (*pbAdminCMS.GetGroupStatisticsResp, error) {
-	resp := &pbAdminCMS.GetGroupStatisticsResp{}
-	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
-	if err != nil {
-		return nil, err
-	}
-	increaseGroupNum, err := s.adminCMSInterface.GetIncreaseGroupNum(fromTime, toTime.Add(time.Hour*24))
-	if err != nil {
-		return nil, err
-	}
-	totalGroupNum, err := s.adminCMSInterface.GetTotalGroupNum()
-	if err != nil {
-		return nil, err
-	}
-	resp.IncreaseGroupNum = int32(increaseGroupNum)
-	resp.TotalGroupNum = int32(totalGroupNum)
-	times := GetRangeDate(fromTime, toTime)
-	wg := &sync.WaitGroup{}
-	resp.IncreaseGroupNumList = make([]*pbAdminCMS.DateNumList, len(times), len(times))
-	resp.TotalGroupNumList = make([]*pbAdminCMS.DateNumList, len(times), len(times))
-	wg.Add(len(times))
-	for i, v := range times {
-		go func(wg *sync.WaitGroup, index int, v [2]time.Time) {
-			defer wg.Done()
-			num, err := s.adminCMSInterface.GetIncreaseGroupNum(v[0], v[1])
-			if err != nil {
-				log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
-			}
-			resp.IncreaseGroupNumList[index] = &pbAdminCMS.DateNumList{
-				Date: v[0].String(),
-				Num:  int32(num),
-			}
-			num, err = s.adminCMSInterface.GetGroupNum(v[1])
-			if err != nil {
-				log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
-			}
-			resp.TotalGroupNumList[index] = &pbAdminCMS.DateNumList{
-				Date: v[0].String(),
-				Num:  int32(num),
-			}
-		}(wg, i, v)
-	}
-	wg.Wait()
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetMessageStatistics(ctx context.Context, req *pbAdminCMS.GetMessageStatisticsReq) (*pbAdminCMS.GetMessageStatisticsResp, error) {
-	resp := &pbAdminCMS.GetMessageStatisticsResp{}
-	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
-	log.NewDebug(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "times: ", fromTime, toTime)
-	if err != nil {
-		log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
-		return nil, err
-	}
-	privateMessageNum, err := s.adminCMSInterface.GetSingleChatMessageNum(fromTime, toTime.Add(time.Hour*24))
-	if err != nil {
-		return nil, err
-	}
-	groupMessageNum, err := s.adminCMSInterface.GetGroupMessageNum(fromTime, toTime.Add(time.Hour*24))
-	if err != nil {
-		return nil, err
-	}
-	log.NewDebug(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), privateMessageNum, groupMessageNum)
-	resp.PrivateMessageNum = int32(privateMessageNum)
-	resp.GroupMessageNum = int32(groupMessageNum)
-	times := GetRangeDate(fromTime, toTime)
-	resp.GroupMessageNumList = make([]*pbAdminCMS.DateNumList, len(times), len(times))
-	resp.PrivateMessageNumList = make([]*pbAdminCMS.DateNumList, len(times), len(times))
-	wg := &sync.WaitGroup{}
-	wg.Add(len(times))
-	for i, v := range times {
-		go func(wg *sync.WaitGroup, index int, v [2]time.Time) {
-			defer wg.Done()
-			num, err := s.adminCMSInterface.GetSingleChatMessageNum(v[0], v[1])
-			if err != nil {
-				log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
-			}
-			resp.PrivateMessageNumList[index] = &pbAdminCMS.DateNumList{
-				Date: v[0].String(),
-				Num:  int32(num),
-			}
-			num, err = s.adminCMSInterface.GetGroupMessageNum(v[0], v[1])
-			if err != nil {
-				log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
-			}
-			resp.GroupMessageNumList[index] = &pbAdminCMS.DateNumList{
-				Date: v[0].String(),
-				Num:  int32(num),
-			}
-		}(wg, i, v)
-	}
-	wg.Wait()
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetUserStatistics(_ context.Context, req *pbAdminCMS.GetUserStatisticsReq) (*pbAdminCMS.GetUserStatisticsResp, error) {
-	resp := &pbAdminCMS.GetUserStatisticsResp{}
-	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
-		return nil, err
-	}
-	activeUserNum, err := s.adminCMSInterface.GetActiveUserNum(fromTime, toTime.Add(time.Hour*24))
-	if err != nil {
-		return nil, err
-	}
-	increaseUserNum, err := s.adminCMSInterface.GetIncreaseUserNum(fromTime, toTime.Add(time.Hour*24))
-	if err != nil {
-		return nil, err
-	}
-	totalUserNum, err := s.adminCMSInterface.GetTotalUserNum()
-	if err != nil {
-		return nil, err
-	}
-	resp.ActiveUserNum = int32(activeUserNum)
-	resp.TotalUserNum = int32(totalUserNum)
-	resp.IncreaseUserNum = int32(increaseUserNum)
-	times := GetRangeDate(fromTime, toTime)
-	resp.TotalUserNumList = make([]*pbAdminCMS.DateNumList, len(times), len(times))
-	resp.ActiveUserNumList = make([]*pbAdminCMS.DateNumList, len(times), len(times))
-	resp.IncreaseUserNumList = make([]*pbAdminCMS.DateNumList, len(times), len(times))
-	wg := &sync.WaitGroup{}
-	wg.Add(len(times))
-	for i, v := range times {
-		go func(wg *sync.WaitGroup, index int, v [2]time.Time) {
-			defer wg.Done()
-			num, err := s.adminCMSInterface.GetActiveUserNum(v[0], v[1])
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
-			}
-			resp.ActiveUserNumList[index] = &pbAdminCMS.DateNumList{
-				Date: v[0].String(),
-				Num:  int32(num),
-			}
-
-			num, err = s.adminCMSInterface.GetTotalUserNumByDate(v[1])
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTotalUserNumByDate", v, err.Error())
-			}
-			resp.TotalUserNumList[index] = &pbAdminCMS.DateNumList{
-				Date: v[0].String(),
-				Num:  int32(num),
-			}
-			num, err = s.adminCMSInterface.GetIncreaseUserNum(v[0], v[1])
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseUserNum", v, err.Error())
-			}
-			resp.IncreaseUserNumList[index] = &pbAdminCMS.DateNumList{
-				Date: v[0].String(),
-				Num:  int32(num),
-			}
-		}(wg, i, v)
-	}
-	wg.Wait()
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetUserFriends(ctx context.Context, req *pbAdminCMS.GetUserFriendsReq) (*pbAdminCMS.GetUserFriendsResp, error) {
-	resp := &pbAdminCMS.GetUserFriendsResp{}
-	var friendList []*relation.FriendUser
-	var err error
-	if req.FriendUserID != "" {
-		friend, err := s.adminCMSInterface.GetFriendByIDCMS(req.UserID, req.FriendUserID)
-		if err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return resp, nil
-			}
-			return nil, err
-		}
-		friendList = append(friendList, friend)
-		resp.FriendNums = 1
-	} else {
-		var count int64
-		friendList, count, err = s.adminCMSInterface.GetUserFriendsCMS(req.UserID, req.FriendUserName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
-		if err != nil {
-			return nil, err
-		}
-		resp.FriendNums = int32(count)
-	}
-	for _, v := range friendList {
-		friendInfo := &common.FriendInfo{}
-		userInfo := &common.UserInfo{UserID: v.FriendUserID, Nickname: v.Nickname}
-		utils.CopyStructFields(friendInfo, v)
-		friendInfo.FriendUser = userInfo
-		resp.FriendInfoList = append(resp.FriendInfoList, friendInfo)
-	}
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetUserIDByEmailAndPhoneNumber(ctx context.Context, req *pbAdminCMS.GetUserIDByEmailAndPhoneNumberReq) (*pbAdminCMS.GetUserIDByEmailAndPhoneNumberResp, error) {
-	resp := &pbAdminCMS.GetUserIDByEmailAndPhoneNumberResp{}
-	userIDList, err := s.userInterface.GetUserIDsByEmailAndID(req.PhoneNumber, req.Email)
-	if err != nil {
-		return resp, nil
-	}
-	resp.UserIDList = userIDList
-	return resp, nil
-}

internal/rpc/auth/auth.go

@@ -20,7 +20,7 @@ import (
 )
 
 func NewRpcAuthServer(port int) *rpcAuth {
-	r, err := rpc_server.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImAuthName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImAuthName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
 	if err != nil {
 		panic(err)
 	}
@@ -35,7 +35,7 @@ func NewRpcAuthServer(port int) *rpcAuth {
 func (s *rpcAuth) Run() {
 	operationID := utils.OperationIDGenerator()
 	log.NewInfo(operationID, "rpc auth start...")
-	listener, address, err := rpc_server.GetTcpListen(config.Config.ListenIP, s.Port)
+	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
 	if err != nil {
 		panic(err)
 	}
@@ -141,6 +141,6 @@ func (s *rpcAuth) forceKickOff(ctx context.Context, userID string, platformID in
 }
 
 type rpcAuth struct {
-	*rpc_server.RpcServer
+	*rpcserver.RpcServer
 	controller.AuthInterface
 }

internal/rpc/friend/friend.go

@@ -23,14 +23,14 @@ import (
 )
 
 type friendServer struct {
-	*rpc_server.RpcServer
+	*rpcserver.RpcServer
 
 	controller.FriendInterface
 	controller.BlackInterface
 }
 
 func NewFriendServer(port int) *friendServer {
-	r, err := rpc_server.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImFriendName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImFriendName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
 	if err != nil {
 		panic(err)
 	}
@@ -64,7 +64,7 @@ func NewFriendServer(port int) *friendServer {
 func (s *friendServer) Run() {
 	operationID := utils.OperationIDGenerator()
 	log.NewInfo(operationID, "friendServer run...")
-	listener, address, err := rpc_server.GetTcpListen(config.Config.ListenIP, s.Port)
+	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
 	if err != nil {
 		panic(err)
 	}

internal/rpc/group/copy.go

@@ -3,12 +3,12 @@ package group
 import (
 	"Open_IM/pkg/common/db/table/relation"
 	pbGroup "Open_IM/pkg/proto/group"
-	open_im_sdk "Open_IM/pkg/proto/sdkws"
+	sdkws "Open_IM/pkg/proto/sdkws"
 	"time"
 )
 
-func DbToPbGroupInfo(m *relation.GroupModel, ownerUserID string, memberCount uint32) *open_im_sdk.GroupInfo {
-	return &open_im_sdk.GroupInfo{
+func DbToPbGroupInfo(m *relation.GroupModel, ownerUserID string, memberCount uint32) *sdkws.GroupInfo {
+	return &sdkws.GroupInfo{
 		GroupID:                m.GroupID,
 		GroupName:              m.GroupName,
 		Notification:           m.Notification,
@@ -48,8 +48,8 @@ func DbToPbCMSGroup(m *relation.GroupModel, ownerUserID string, ownerUserName st
 	}
 }
 
-func DbToPbGroupMembersCMSResp(m *relation.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
-	return &open_im_sdk.GroupMemberFullInfo{
+func DbToPbGroupMembersCMSResp(m *relation.GroupMemberModel) *sdkws.GroupMemberFullInfo {
+	return &sdkws.GroupMemberFullInfo{
 		GroupID:   m.GroupID,
 		UserID:    m.UserID,
 		RoleLevel: m.RoleLevel,
@@ -65,8 +65,8 @@ func DbToPbGroupMembersCMSResp(m *relation.GroupMemberModel) *open_im_sdk.GroupM
 	}
 }
 
-func DbToPbGroupRequest(m *relation.GroupRequestModel, user *open_im_sdk.PublicUserInfo, group *open_im_sdk.GroupInfo) *open_im_sdk.GroupRequest {
-	return &open_im_sdk.GroupRequest{
+func DbToPbGroupRequest(m *relation.GroupRequestModel, user *sdkws.PublicUserInfo, group *sdkws.GroupInfo) *sdkws.GroupRequest {
+	return &sdkws.GroupRequest{
 		UserInfo:      user,
 		GroupInfo:     group,
 		HandleResult:  m.HandleResult,
@@ -89,7 +89,7 @@ func DbToPbGroupAbstractInfo(groupID string, groupMemberNumber uint32, groupMemb
 	}
 }
 
-func PbToDBGroupInfo(m *open_im_sdk.GroupInfo) *relation.GroupModel {
+func PbToDBGroupInfo(m *sdkws.GroupInfo) *relation.GroupModel {
 	return &relation.GroupModel{
 		GroupID:                m.GroupID,
 		GroupName:              m.GroupName,
@@ -109,7 +109,7 @@ func PbToDBGroupInfo(m *open_im_sdk.GroupInfo) *relation.GroupModel {
 	}
 }
 
-func PbToDbGroupMember(m *open_im_sdk.UserInfo) *relation.GroupMemberModel {
+func PbToDbGroupMember(m *sdkws.UserInfo) *relation.GroupMemberModel {
 	return &relation.GroupMemberModel{
 		UserID:   m.UserID,
 		Nickname: m.Nickname,

internal/rpc/group/db_map.go

@@ -2,11 +2,11 @@ package group
 
 import (
 	pbGroup "Open_IM/pkg/proto/group"
-	open_im_sdk "Open_IM/pkg/proto/sdkws"
+	sdkws "Open_IM/pkg/proto/sdkws"
 	"time"
 )
 
-func UpdateGroupInfoMap(group *open_im_sdk.GroupInfoForSet) map[string]any {
+func UpdateGroupInfoMap(group *sdkws.GroupInfoForSet) map[string]any {
 	m := make(map[string]any)
 	if group.GroupName != "" {
 		m["group_name"] = group.GroupName

internal/rpc/group/group.go

@@ -18,7 +18,7 @@ import (
 	"Open_IM/pkg/common/tracelog"
 	discoveryRegistry "Open_IM/pkg/discoveryregistry"
 	pbGroup "Open_IM/pkg/proto/group"
-	open_im_sdk "Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 	"fmt"
@@ -201,7 +201,7 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
 }
 
 func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
-	resp := &pbGroup.CreateGroupResp{GroupInfo: &open_im_sdk.GroupInfo{}}
+	resp := &pbGroup.CreateGroupResp{GroupInfo: &sdkws.GroupInfo{}}
 	if err := tokenverify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
@@ -307,7 +307,7 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 	})
 	resp.Groups = utils.Slice(utils.Order(groupIDs, groups, func(group *relationTb.GroupModel) string {
 		return group.GroupID
-	}), func(group *relationTb.GroupModel) *open_im_sdk.GroupInfo {
+	}), func(group *relationTb.GroupModel) *sdkws.GroupInfo {
 		return DbToPbGroupInfo(group, ownerMap[group.GroupID].UserID, groupMemberNum[group.GroupID])
 	})
 	return resp, nil
@@ -424,7 +424,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 	if err != nil {
 		return nil, err
 	}
-	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
@@ -446,7 +446,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 	if err != nil {
 		return nil, err
 	}
-	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
@@ -540,7 +540,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 	if err != nil {
 		return nil, err
 	}
-	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
@@ -594,7 +594,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	ownerMap := utils.SliceToMap(owners, func(e *relationTb.GroupMemberModel) string {
 		return e.GroupID
 	})
-	resp.GroupRequests = utils.Slice(groupRequests, func(e *relationTb.GroupRequestModel) *open_im_sdk.GroupRequest {
+	resp.GroupRequests = utils.Slice(groupRequests, func(e *relationTb.GroupRequestModel) *sdkws.GroupRequest {
 		return DbToPbGroupRequest(e, userMap[e.UserID], DbToPbGroupInfo(groupMap[e.GroupID], ownerMap[e.GroupID].UserID, uint32(groupMemberNumMap[e.GroupID])))
 	})
 	return resp, nil
@@ -620,7 +620,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
 	ownerMap := utils.SliceToMap(owners, func(e *relationTb.GroupMemberModel) string {
 		return e.GroupID
 	})
-	resp.GroupInfos = utils.Slice(groups, func(e *relationTb.GroupModel) *open_im_sdk.GroupInfo {
+	resp.GroupInfos = utils.Slice(groups, func(e *relationTb.GroupModel) *sdkws.GroupInfo {
 		return DbToPbGroupInfo(e, ownerMap[e.GroupID].UserID, uint32(groupMemberNumMap[e.GroupID]))
 	})
 	return resp, nil
@@ -898,7 +898,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 	if err != nil {
 		return nil, err
 	}
-	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}
@@ -948,7 +948,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 	if err != nil {
 		return nil, err
 	}
-	resp.GroupRequests = utils.Slice(requests, func(e *relationTb.GroupRequestModel) *open_im_sdk.GroupRequest {
+	resp.GroupRequests = utils.Slice(requests, func(e *relationTb.GroupRequestModel) *sdkws.GroupRequest {
 		return DbToPbGroupRequest(e, user, DbToPbGroupInfo(groupMap[e.GroupID], ownerMap[e.GroupID].UserID, uint32(groupMemberNum[e.GroupID])))
 	})
 	return resp, nil
@@ -1173,7 +1173,7 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.Ge
 	if err != nil {
 		return nil, err
 	}
-	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *open_im_sdk.GroupMemberFullInfo {
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
 		if e.Nickname == "" {
 			e.Nickname = nameMap[e.UserID]
 		}

internal/rpc/msg/conversation_notification.go

@@ -4,14 +4,14 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
-	open_im_sdk "Open_IM/pkg/proto/sdkws"
+	sdkws "Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 	"github.com/golang/protobuf/jsonpb"
 	"github.com/golang/protobuf/proto"
 )
 
-func SetConversationNotification(operationID, sendID, recvID string, contentType int, m proto.Message, tips open_im_sdk.TipsComm) {
+func SetConversationNotification(operationID, sendID, recvID string, contentType int, m proto.Message, tips sdkws.TipsComm) {
 	log.NewInfo(operationID, "args: ", sendID, recvID, contentType, m.String(), tips.String())
 	var err error
 	tips.Detail, err = proto.Marshal(m)
@@ -43,12 +43,12 @@ func SetConversationNotification(operationID, sendID, recvID string, contentType
 // SetPrivate调用
 func ConversationSetPrivateNotification(operationID, sendID, recvID string, isPrivateChat bool) {
 	log.NewInfo(operationID, utils.GetSelfFuncName())
-	conversationSetPrivateTips := &open_im_sdk.ConversationSetPrivateTips{
+	conversationSetPrivateTips := &sdkws.ConversationSetPrivateTips{
 		RecvID:    recvID,
 		SendID:    sendID,
 		IsPrivate: isPrivateChat,
 	}
-	var tips open_im_sdk.TipsComm
+	var tips sdkws.TipsComm
 	var tipsMsg string
 	if isPrivateChat == true {
 		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.OpenTips
@@ -62,10 +62,10 @@ func ConversationSetPrivateNotification(operationID, sendID, recvID string, isPr
 // 会话改变
 func ConversationChangeNotification(ctx context.Context, userID string) {
 	log.NewInfo(operationID, utils.GetSelfFuncName())
-	ConversationChangedTips := &open_im_sdk.ConversationUpdateTips{
+	ConversationChangedTips := &sdkws.ConversationUpdateTips{
 		UserID: userID,
 	}
-	var tips open_im_sdk.TipsComm
+	var tips sdkws.TipsComm
 	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
 	SetConversationNotification(operationID, userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, tips)
 }
@@ -73,12 +73,12 @@ func ConversationChangeNotification(ctx context.Context, userID string) {
 //会话未读数同步
 func ConversationUnreadChangeNotification(operationID, userID, conversationID string, updateUnreadCountTime int64) {
 	log.NewInfo(operationID, utils.GetSelfFuncName())
-	ConversationChangedTips := &open_im_sdk.ConversationUpdateTips{
+	ConversationChangedTips := &sdkws.ConversationUpdateTips{
 		UserID:                userID,
 		ConversationIDList:    []string{conversationID},
 		UpdateUnreadCountTime: updateUnreadCountTime,
 	}
-	var tips open_im_sdk.TipsComm
+	var tips sdkws.TipsComm
 	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
 	SetConversationNotification(operationID, userID, userID, constant.ConversationUnreadNotification, ConversationChangedTips, tips)
 }

internal/rpc/msg/extend_msg.notification.go

@@ -7,7 +7,7 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/getcdv3"
 	"Open_IM/pkg/proto/msg"
-	open_im_sdk "Open_IM/pkg/proto/sdkws"
+	sdkws "Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 )
@@ -18,7 +18,7 @@ func ExtendMessageUpdatedNotification(operationID, sendID string, sourceID strin
 	m.SourceID = req.SourceID
 	m.OpUserID = req.OpUserID
 	m.SessionType = req.SessionType
-	keyMap := make(map[string]*open_im_sdk.KeyValue)
+	keyMap := make(map[string]*sdkws.KeyValue)
 	for _, valueResp := range resp.Result {
 		if valueResp.ErrCode == 0 {
 			keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue
@@ -41,7 +41,7 @@ func ExtendMessageDeleteNotification(operationID, sendID string, sourceID string
 	m.SourceID = req.SourceID
 	m.OpUserID = req.OpUserID
 	m.SessionType = req.SessionType
-	keyMap := make(map[string]*open_im_sdk.KeyValue)
+	keyMap := make(map[string]*sdkws.KeyValue)
 	for _, valueResp := range resp.Result {
 		if valueResp.ErrCode == 0 {
 			keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue
@@ -70,7 +70,7 @@ func messageReactionSender(operationID, sendID string, sourceID string, sessionT
 	}
 	pbData := msg.SendMsgReq{
 		OperationID: operationID,
-		MsgData: &open_im_sdk.MsgData{
+		MsgData: &sdkws.MsgData{
 			SendID:      sendID,
 			ClientMsgID: utils.GetMsgID(sendID),
 			SessionType: sessionType,

internal/rpc/msg/friend_notification.go

@@ -7,7 +7,7 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tracelog"
 	pbFriend "Open_IM/pkg/proto/friend"
-	open_im_sdk "Open_IM/pkg/proto/sdkws"
+	sdkws "Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 	"github.com/golang/protobuf/jsonpb"
@@ -29,7 +29,7 @@ func getFromToUserNickname(fromUserID, toUserID string) (string, string, error)
 func friendNotification(operationID, fromUserID, toUserID string, contentType int32, m proto.Message) {
 	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType)
 	var err error
-	var tips open_im_sdk.TipsComm
+	var tips sdkws.TipsComm
 	tips.Detail, err = proto.Marshal(m)
 	if err != nil {
 		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
@@ -92,14 +92,14 @@ func friendNotification(operationID, fromUserID, toUserID string, contentType in
 }
 
 func FriendApplicationAddNotification(ctx context.Context, req *pbFriend.AddFriendReq) {
-	FriendApplicationTips := open_im_sdk.FriendApplicationTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationTips := sdkws.FriendApplicationTips{FromToUserID: &sdkws.FromToUserID{}}
 	FriendApplicationTips.FromToUserID.FromUserID = req.FromUserID
 	FriendApplicationTips.FromToUserID.ToUserID = req.ToUserID
 	friendNotification(tracelog.GetOperationID(ctx), req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &FriendApplicationTips)
 }
 
 func FriendApplicationAgreedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
-	FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}}
 	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
 	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
 	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
@@ -107,7 +107,7 @@ func FriendApplicationAgreedNotification(ctx context.Context, req *pbFriend.Resp
 }
 
 func FriendApplicationRefusedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
-	FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}}
 	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
 	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
 	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
@@ -115,7 +115,7 @@ func FriendApplicationRefusedNotification(ctx context.Context, req *pbFriend.Res
 }
 
 func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) {
-	friendAddedTips := open_im_sdk.FriendAddedTips{Friend: &open_im_sdk.FriendInfo{}, OpUser: &open_im_sdk.PublicUserInfo{}}
+	friendAddedTips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
 	user, err := check.GetUsersInfo(context.Background(), opUserID)
 	if err != nil {
 		return
@@ -134,28 +134,28 @@ func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUse
 }
 
 func FriendDeletedNotification(ctx context.Context, req *pbFriend.DeleteFriendReq) {
-	friendDeletedTips := open_im_sdk.FriendDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	friendDeletedTips := sdkws.FriendDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
 	friendDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
 	friendDeletedTips.FromToUserID.ToUserID = req.FriendUserID
 	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &friendDeletedTips)
 }
 
 func FriendRemarkSetNotification(ctx context.Context, fromUserID, toUserID string) {
-	friendInfoChangedTips := open_im_sdk.FriendInfoChangedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	friendInfoChangedTips := sdkws.FriendInfoChangedTips{FromToUserID: &sdkws.FromToUserID{}}
 	friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
 	friendInfoChangedTips.FromToUserID.ToUserID = toUserID
 	friendNotification(tracelog.GetOperationID(ctx), fromUserID, toUserID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
 }
 
 func BlackAddedNotification(ctx context.Context, req *pbFriend.AddBlackReq) {
-	blackAddedTips := open_im_sdk.BlackAddedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	blackAddedTips := sdkws.BlackAddedTips{FromToUserID: &sdkws.FromToUserID{}}
 	blackAddedTips.FromToUserID.FromUserID = req.OwnerUserID
 	blackAddedTips.FromToUserID.ToUserID = req.BlackUserID
 	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackAddedNotification, &blackAddedTips)
 }
 
 func BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq) {
-	blackDeletedTips := open_im_sdk.BlackDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	blackDeletedTips := sdkws.BlackDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
 	blackDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
 	blackDeletedTips.FromToUserID.ToUserID = req.BlackUserID
 	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
@@ -163,11 +163,11 @@ func BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq)
 
 // send to myself
 func UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
-	selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: changedUserID}
+	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
 	friendNotification(tracelog.GetOperationID(ctx), opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
 }
 
 func FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) {
-	selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: changedUserID}
+	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
 	friendNotification(tracelog.GetOperationID(ctx), opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
 }

internal/rpc/msg/group_notification.go

@@ -106,7 +106,7 @@ func groupNotification(contentType int32, m proto.Message, sendID, groupID, recv
 	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType, sendID, groupID, recvUserID)
 
 	var err error
-	var tips open_im_sdk.TipsComm
+	var tips sdkws.TipsComm
 	tips.Detail, err = proto.Marshal(m)
 	if err != nil {
 		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
@@ -211,8 +211,8 @@ func groupNotification(contentType int32, m proto.Message, sendID, groupID, recv
 
 // 创建群后调用
 func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) {
-	GroupCreatedTips := sdkws.GroupCreatedTips{Group: &open_im_sdk.GroupInfo{},
-		OpUser: &open_im_sdk.GroupMemberFullInfo{}, GroupOwnerUser: &open_im_sdk.GroupMemberFullInfo{}}
+	GroupCreatedTips := sdkws.GroupCreatedTips{Group: &sdkws.GroupInfo{},
+		OpUser: &sdkws.GroupMemberFullInfo{}, GroupOwnerUser: &sdkws.GroupMemberFullInfo{}}
 	if err := setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil {
 		log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser)
 		return
@@ -228,7 +228,7 @@ func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberL
 		return
 	}
 	for _, v := range initMemberList {
-		var groupMemberInfo open_im_sdk.GroupMemberFullInfo
+		var groupMemberInfo sdkws.GroupMemberFullInfo
 		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
 			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v)
 			continue

internal/rpc/msg/msg_notification.go

@@ -3,21 +3,21 @@ package msg
 import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
-	open_im_sdk "Open_IM/pkg/proto/sdkws"
+	sdkws "Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"github.com/golang/protobuf/jsonpb"
 	"github.com/golang/protobuf/proto"
 )
 
 func DeleteMessageNotification(opUserID, userID string, seqList []uint32, operationID string) {
-	DeleteMessageTips := open_im_sdk.DeleteMessageTips{OpUserID: opUserID, UserID: userID, SeqList: seqList}
+	DeleteMessageTips := sdkws.DeleteMessageTips{OpUserID: opUserID, UserID: userID, SeqList: seqList}
 	MessageNotification(operationID, userID, userID, constant.DeleteMessageNotification, &DeleteMessageTips)
 }
 
 func MessageNotification(operationID, sendID, recvID string, contentType int32, m proto.Message) {
 	log.Debug(operationID, utils.GetSelfFuncName(), "args: ", m.String(), contentType)
 	var err error
-	var tips open_im_sdk.TipsComm
+	var tips sdkws.TipsComm
 	tips.Detail, err = proto.Marshal(m)
 	if err != nil {
 		log.Error(operationID, "Marshal failed ", err.Error(), m.String())

internal/rpc/msg/pull_message.go

@@ -7,15 +7,15 @@ import (
 
 	commonDB "Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/log"
-	open_im_sdk "Open_IM/pkg/proto/sdkws"
+	sdkws "Open_IM/pkg/proto/sdkws"
 
 	promePkg "Open_IM/pkg/common/prometheus"
 )
 
-func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *open_im_sdk.GetMaxAndMinSeqReq) (*open_im_sdk.GetMaxAndMinSeqResp, error) {
+func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
 	log.NewInfo(in.OperationID, "rpc getMaxAndMinSeq is arriving", in.String())
-	resp := new(open_im_sdk.GetMaxAndMinSeqResp)
-	m := make(map[string]*open_im_sdk.MaxAndMinSeq)
+	resp := new(sdkws.GetMaxAndMinSeqResp)
+	m := make(map[string]*sdkws.MaxAndMinSeq)
 	var maxSeq, minSeq uint64
 	var err1, err2 error
 	maxSeq, err1 = commonDB.DB.GetUserMaxSeq(in.UserID)
@@ -35,7 +35,7 @@ func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *open_im_sdk.GetMaxAnd
 	resp.MaxSeq = uint32(maxSeq)
 	resp.MinSeq = uint32(minSeq)
 	for _, groupID := range in.GroupIDList {
-		x := new(open_im_sdk.MaxAndMinSeq)
+		x := new(sdkws.MaxAndMinSeq)
 		maxSeq, _ := commonDB.DB.GetGroupMaxSeq(groupID)
 		minSeq, _ := commonDB.DB.GetGroupUserMinSeq(groupID, in.UserID)
 		x.MaxSeq = uint32(maxSeq)
@@ -46,10 +46,10 @@ func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *open_im_sdk.GetMaxAnd
 	return resp, nil
 }
 
-func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *open_im_sdk.PullMessageBySeqListReq) (*open_im_sdk.PullMessageBySeqListResp, error) {
+func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *sdkws.PullMessageBySeqListReq) (*sdkws.PullMessageBySeqListResp, error) {
 	log.NewInfo(in.OperationID, "rpc PullMessageBySeqList is arriving", in.String())
-	resp := new(open_im_sdk.PullMessageBySeqListResp)
-	m := make(map[string]*open_im_sdk.MsgDataList)
+	resp := new(sdkws.PullMessageBySeqListResp)
+	m := make(map[string]*sdkws.MsgDataList)
 	redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(in.UserID, in.SeqList, in.OperationID)
 	if err != nil {
 		if err != go_redis.Nil {
@@ -76,7 +76,7 @@ func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *open_im_sdk.Pull
 	}
 
 	for k, v := range in.GroupSeqList {
-		x := new(open_im_sdk.MsgDataList)
+		x := new(sdkws.MsgDataList)
 		redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(k, v.SeqList, in.OperationID)
 		if err != nil {
 			if err != go_redis.Nil {
@@ -108,7 +108,7 @@ func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *open_im_sdk.Pull
 	return resp, nil
 }
 
-type MsgFormats []*open_im_sdk.MsgData
+type MsgFormats []*sdkws.MsgData
 
 // Implement the sort.Interface interface to get the number of elements method
 func (s MsgFormats) Len() int {

internal/rpc/msg/send_msg.go

@@ -750,7 +750,7 @@ func modifyMessageByUserMessageReceiveOptoptimization(userID, sourceID string, s
 type NotificationMsg struct {
 	SendID         string
 	RecvID         string
-	Content        []byte //  open_im_sdk.TipsComm
+	Content        []byte //  sdkws.TipsComm
 	MsgFrom        int32
 	ContentType    int32
 	SessionType    int32
@@ -975,14 +975,6 @@ func Notification(n *NotificationMsg) {
 		reliabilityLevel = config.Config.Notification.GroupMemberInfoSet.Conversation.ReliabilityLevel
 		unReadCount = config.Config.Notification.GroupMemberInfoSet.Conversation.UnreadCount
 
-	case constant.WorkMomentNotification:
-		pushSwitch = config.Config.Notification.WorkMomentsNotification.OfflinePush.PushSwitch
-		title = config.Config.Notification.WorkMomentsNotification.OfflinePush.Title
-		desc = config.Config.Notification.WorkMomentsNotification.OfflinePush.Desc
-		ex = config.Config.Notification.WorkMomentsNotification.OfflinePush.Ext
-		reliabilityLevel = config.Config.Notification.WorkMomentsNotification.Conversation.ReliabilityLevel
-		unReadCount = config.Config.Notification.WorkMomentsNotification.Conversation.UnreadCount
-
 	case constant.ConversationPrivateChatNotification:
 		pushSwitch = config.Config.Notification.ConversationSetPrivate.OfflinePush.PushSwitch
 		title = config.Config.Notification.ConversationSetPrivate.OfflinePush.Title

internal/rpc/msg/tag_send_msg.go

@@ -1,52 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/getcdv3"
-	pbChat "Open_IM/pkg/proto/msg"
-	pbCommon "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"strings"
-)
-
-func TagSendMessage(operationID string, user *im_mysql_model.User, recvID, content string, senderPlatformID int32) {
-	log.NewInfo(operationID, utils.GetSelfFuncName(), "args: ", user.UserID, recvID, content)
-	var req pbChat.SendMsgReq
-	var msgData pbCommon.MsgData
-	msgData.SendID = user.UserID
-	msgData.RecvID = recvID
-	msgData.ContentType = constant.Custom
-	msgData.SessionType = constant.SingleChatType
-	msgData.MsgFrom = constant.UserMsgType
-	msgData.Content = []byte(content)
-	msgData.SenderFaceURL = user.FaceURL
-	msgData.SenderNickname = user.Nickname
-	msgData.Options = map[string]bool{}
-	msgData.Options[constant.IsSenderConversationUpdate] = false
-	msgData.Options[constant.IsSenderNotificationPush] = false
-	msgData.CreateTime = utils.GetCurrentTimestampByMill()
-	msgData.ClientMsgID = utils.GetMsgID(user.UserID)
-	msgData.SenderPlatformID = senderPlatformID
-	req.MsgData = &msgData
-	req.OperationID = operationID
-	etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, operationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		return
-	}
-
-	client := pbChat.NewMsgClient(etcdConn)
-	respPb, err := client.SendMsg(context.Background(), &req)
-	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "send msg failed", err.Error())
-		return
-	}
-	if respPb.ErrCode != 0 {
-		log.NewError(operationID, utils.GetSelfFuncName(), "send tag msg failed ", respPb)
-	}
-}

internal/rpc/msg/work_moments_notification.go

@@ -1,42 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	pbOffice "Open_IM/pkg/proto/office"
-	sdk "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func WorkMomentSendNotification(operationID, recvID string, notificationMsg *pbOffice.WorkMomentNotificationMsg) {
-	log.NewInfo(operationID, utils.GetSelfFuncName(), recvID, notificationMsg)
-	WorkMomentNotification(operationID, recvID, recvID, notificationMsg)
-}
-
-func WorkMomentNotification(operationID, sendID, recvID string, m proto.Message) {
-	var tips sdk.TipsComm
-	var err error
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	n := &NotificationMsg{
-		SendID:      sendID,
-		RecvID:      recvID,
-		MsgFrom:     constant.UserMsgType,
-		ContentType: constant.WorkMomentNotification,
-		SessionType: constant.SingleChatType,
-		OperationID: operationID,
-	}
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "proto.Marshal failed")
-		return
-	}
-	log.NewInfo(operationID, utils.GetSelfFuncName(), string(n.Content))
-	Notification(n)
-}

internal/rpc/office/office.go

@@ -1,734 +0,0 @@
-package office
-
-import (
-	"Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/db/mongo"
-	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
-	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
-	rocksCache "Open_IM/pkg/common/db/rocks_cache"
-	"Open_IM/pkg/common/log"
-	promePkg "Open_IM/pkg/common/prometheus"
-	pbCache "Open_IM/pkg/proto/cache"
-	pbOffice "Open_IM/pkg/proto/office"
-	pbCommon "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"github.com/OpenIMSDK/getcdv3"
-	"net"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-	"unsafe"
-
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-
-	"google.golang.org/grpc"
-)
-
-type officeServer struct {
-	rpcPort         int
-	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
-	ch              chan tagSendStruct
-}
-
-func NewOfficeServer(port int) *officeServer {
-	log.NewPrivateLog(constant.LogFileName)
-	ch := make(chan tagSendStruct, 100000)
-	return &officeServer{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImOfficeName,
-		etcdSchema:      config.Config.Etcd.EtcdSchema,
-		etcdAddr:        config.Config.Etcd.EtcdAddr,
-		ch:              ch,
-	}
-}
-
-func (s *officeServer) Run() {
-	log.NewInfo("0", "officeServer rpc start ")
-	listenIP := ""
-	if config.Config.ListenIP == "" {
-		listenIP = "0.0.0.0"
-	} else {
-		listenIP = config.Config.ListenIP
-	}
-	address := listenIP + ":" + strconv.Itoa(s.rpcPort)
-	//listener network
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		panic("listening err:" + err.Error() + s.rpcRegisterName)
-	}
-	log.NewInfo("0", "listen network success, ", address, listener)
-	defer listener.Close()
-	//grpc server
-	recvSize := 1024 * 1024 * 30
-	sendSize := 1024 * 1024 * 30
-	var grpcOpts = []grpc.ServerOption{
-		grpc.MaxRecvMsgSize(recvSize),
-		grpc.MaxSendMsgSize(sendSize),
-	}
-	if config.Config.Prometheus.Enable {
-		promePkg.NewGrpcRequestCounter()
-		promePkg.NewGrpcRequestFailedCounter()
-		promePkg.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(promePkg.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	//Service registers with etcd
-	pbOffice.RegisterOfficeServiceServer(srv, s)
-	rpcRegisterIP := config.Config.RpcRegisterIP
-	if config.Config.RpcRegisterIP == "" {
-		rpcRegisterIP, err = utils.GetLocalIP()
-		if err != nil {
-			log.Error("", "GetLocalIP failed ", err.Error())
-		}
-	}
-	log.NewInfo("", "rpcRegisterIP", rpcRegisterIP)
-	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10)
-	if err != nil {
-		log.NewError("0", "RegisterEtcd failed ", err.Error())
-		panic(utils.Wrap(err, "register office module  rpc to etcd err"))
-	}
-	go s.sendTagMsgRoutine()
-	err = srv.Serve(listener)
-	if err != nil {
-		log.NewError("0", "Serve failed ", err.Error())
-		return
-	}
-	log.NewInfo("0", "message cms rpc success")
-}
-
-type tagSendStruct struct {
-	operationID      string
-	user             *imdb.User
-	userID           string
-	content          string
-	senderPlatformID int32
-}
-
-func (s *officeServer) sendTagMsgRoutine() {
-	log.NewInfo("", utils.GetSelfFuncName(), "start")
-	for {
-		select {
-		case v := <-s.ch:
-			msg.TagSendMessage(v.operationID, v.user, v.userID, v.content, v.senderPlatformID)
-			time.Sleep(time.Millisecond * 100)
-		}
-	}
-}
-
-func (s *officeServer) GetUserTags(_ context.Context, req *pbOffice.GetUserTagsReq) (resp *pbOffice.GetUserTagsResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req ", req.String())
-	resp = &pbOffice.GetUserTagsResp{
-		CommonResp: &pbOffice.CommonResp{},
-		Tags:       []*pbOffice.Tag{},
-	}
-	tags, err := db.DB.GetUserTags(req.UserID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTags failed", err.Error())
-		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		return resp, nil
-	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "tags: ", tags)
-	for _, v := range tags {
-		tag := &pbOffice.Tag{
-			TagID:   v.TagID,
-			TagName: v.TagName,
-		}
-		for _, userID := range v.UserList {
-			UserName, err := im_mysql_model.GetUserNameByUserID(userID)
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID failed", err.Error())
-				continue
-			}
-			tag.UserList = append(tag.UserList, &pbOffice.TagUser{
-				UserID:   userID,
-				UserName: UserName,
-			})
-		}
-		resp.Tags = append(resp.Tags, tag)
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) CreateTag(_ context.Context, req *pbOffice.CreateTagReq) (resp *pbOffice.CreateTagResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "CreateTag req", req.String())
-	userIDList := utils.RemoveRepeatedStringInList(req.UserIDList)
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "userIDList: ", userIDList)
-	resp = &pbOffice.CreateTagResp{CommonResp: &pbOffice.CommonResp{}}
-	if err := db.DB.CreateTag(req.UserID, req.TagName, userIDList); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTags failed", err.Error())
-		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) DeleteTag(_ context.Context, req *pbOffice.DeleteTagReq) (resp *pbOffice.DeleteTagResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.DeleteTagResp{CommonResp: &pbOffice.CommonResp{}}
-	if err := db.DB.DeleteTag(req.UserID, req.TagID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DeleteTag failed", err.Error())
-		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) SetTag(_ context.Context, req *pbOffice.SetTagReq) (resp *pbOffice.SetTagResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.SetTagResp{CommonResp: &pbOffice.CommonResp{}}
-	increaseUserIDList := utils.RemoveRepeatedStringInList(req.IncreaseUserIDList)
-	reduceUserIDList := utils.RemoveRepeatedStringInList(req.ReduceUserIDList)
-	if err := db.DB.SetTag(req.UserID, req.TagID, req.NewName, increaseUserIDList, reduceUserIDList); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetTag failed", increaseUserIDList, reduceUserIDList, err.Error())
-		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) SendMsg2Tag(_ context.Context, req *pbOffice.SendMsg2TagReq) (resp *pbOffice.SendMsg2TagResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.SendMsg2TagResp{CommonResp: &pbOffice.CommonResp{}}
-	var tagUserIDList []string
-	for _, tagID := range req.TagList {
-		userIDList, err := db.DB.GetUserIDListByTagID(req.SendID, tagID)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserIDListByTagID failed", err.Error())
-			continue
-		}
-		tagUserIDList = append(tagUserIDList, userIDList...)
-	}
-	var groupUserIDList []string
-	for _, groupID := range req.GroupList {
-		etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
-		if etcdConn == nil {
-			errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-			log.NewError(req.OperationID, errMsg)
-			resp.CommonResp.ErrCode = constant.ErrInternal.ErrCode
-			resp.CommonResp.ErrMsg = errMsg
-			return resp, nil
-		}
-
-		cacheClient := pbCache.NewCacheClient(etcdConn)
-		req := pbCache.GetGroupMemberIDListFromCacheReq{
-			OperationID: req.OperationID,
-			GroupID:     groupID,
-		}
-		getGroupMemberIDListFromCacheResp, err := cacheClient.GetGroupMemberIDListFromCache(context.Background(), &req)
-		if err != nil {
-			log.NewError(req.OperationID, "GetGroupMemberIDListFromCache rpc call failed ", err.Error(), req.String())
-			resp.CommonResp.ErrCode = constant.ErrServer.ErrCode
-			resp.CommonResp.ErrMsg = err.Error()
-			return resp, nil
-		}
-		if getGroupMemberIDListFromCacheResp.CommonResp.ErrCode != 0 {
-			log.NewError(req.OperationID, "GetGroupMemberIDListFromCache rpc logic call failed ", getGroupMemberIDListFromCacheResp.CommonResp.ErrCode)
-			resp.CommonResp.ErrCode = getGroupMemberIDListFromCacheResp.CommonResp.ErrCode
-			resp.CommonResp.ErrMsg = getGroupMemberIDListFromCacheResp.CommonResp.ErrMsg
-			return resp, nil
-		}
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), getGroupMemberIDListFromCacheResp.UserIDList)
-		groupUserIDList = append(groupUserIDList, getGroupMemberIDListFromCacheResp.UserIDList...)
-	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), groupUserIDList, req.GroupList)
-	var userIDList []string
-	userIDList = append(userIDList, tagUserIDList...)
-	userIDList = append(userIDList, groupUserIDList...)
-	userIDList = append(userIDList, req.UserList...)
-	userIDList = utils.RemoveRepeatedStringInList(userIDList)
-	for i, userID := range userIDList {
-		if userID == req.SendID || userID == "" {
-			userIDList = append(userIDList[:i], userIDList[i+1:]...)
-		}
-	}
-	if unsafe.Sizeof(userIDList) > 1024*1024 {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "size", unsafe.Sizeof(userIDList))
-		resp.CommonResp.ErrMsg = constant.ErrSendLimit.ErrMsg
-		resp.CommonResp.ErrCode = constant.ErrSendLimit.ErrCode
-		return
-	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "total userIDList result: ", userIDList)
-	user, err := imdb.GetUserByUserID(req.SendID)
-	if err != nil {
-		log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.SendID)
-		resp.CommonResp.ErrMsg = err.Error()
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		return resp, nil
-	}
-	var successUserIDList []string
-	for _, userID := range userIDList {
-		t := tagSendStruct{
-			operationID:      req.OperationID,
-			user:             user,
-			userID:           userID,
-			content:          req.Content,
-			senderPlatformID: req.SenderPlatformID,
-		}
-		select {
-		case s.ch <- t:
-			log.NewDebug(t.operationID, utils.GetSelfFuncName(), "msg: ", t, "send success")
-			successUserIDList = append(successUserIDList, userID)
-		// if channel is full, return grpc req
-		case <-time.After(1 * time.Second):
-			log.NewError(t.operationID, utils.GetSelfFuncName(), s.ch, "channel is full")
-			resp.CommonResp.ErrCode = constant.ErrSendLimit.ErrCode
-			resp.CommonResp.ErrMsg = constant.ErrSendLimit.ErrMsg
-			return resp, nil
-		}
-	}
-
-	var tagSendLogs mongoDB.TagSendLog
-	var wg sync.WaitGroup
-	wg.Add(len(successUserIDList))
-	var lock sync.Mutex
-	for _, userID := range successUserIDList {
-		go func(userID string) {
-			defer wg.Done()
-			userName, err := im_mysql_model.GetUserNameByUserID(userID)
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID failed", err.Error(), userID)
-				return
-			}
-			lock.Lock()
-			tagSendLogs.UserList = append(tagSendLogs.UserList, mongoDB.TagUser{
-				UserID:   userID,
-				UserName: userName,
-			})
-			lock.Unlock()
-		}(userID)
-	}
-	wg.Wait()
-	tagSendLogs.SendID = req.SendID
-	tagSendLogs.Content = req.Content
-	tagSendLogs.SenderPlatformID = req.SenderPlatformID
-	tagSendLogs.SendTime = time.Now().Unix()
-	if err := db.DB.SaveTagSendLog(&tagSendLogs); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SaveTagSendLog failed", tagSendLogs, err.Error())
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) GetTagSendLogs(_ context.Context, req *pbOffice.GetTagSendLogsReq) (resp *pbOffice.GetTagSendLogsResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.GetTagSendLogsResp{
-		CommonResp: &pbOffice.CommonResp{},
-		Pagination: &pbCommon.ResponsePagination{
-			CurrentPage: req.Pagination.PageNumber,
-			ShowNumber:  req.Pagination.ShowNumber,
-		},
-		TagSendLogs: []*pbOffice.TagSendLog{},
-	}
-	tagSendLogs, err := db.DB.GetTagSendLogs(req.UserID, req.Pagination.ShowNumber, req.Pagination.PageNumber)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTagSendLogs", err.Error())
-		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		return resp, nil
-	}
-	if err := utils.CopyStructFields(&resp.TagSendLogs, tagSendLogs); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), err.Error())
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) GetUserTagByID(_ context.Context, req *pbOffice.GetUserTagByIDReq) (resp *pbOffice.GetUserTagByIDResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.GetUserTagByIDResp{
-		CommonResp: &pbOffice.CommonResp{},
-		Tag:        &pbOffice.Tag{},
-	}
-	tag, err := db.DB.GetTagByID(req.UserID, req.TagID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTagByID failed", err.Error())
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-		return resp, nil
-	}
-	for _, userID := range tag.UserList {
-		userName, err := im_mysql_model.GetUserNameByUserID(userID)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID failed", err.Error())
-			continue
-		}
-		resp.Tag.UserList = append(resp.Tag.UserList, &pbOffice.TagUser{
-			UserID:   userID,
-			UserName: userName,
-		})
-	}
-	resp.Tag.TagID = tag.TagID
-	resp.Tag.TagName = tag.TagName
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) CreateOneWorkMoment(_ context.Context, req *pbOffice.CreateOneWorkMomentReq) (resp *pbOffice.CreateOneWorkMomentResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.CreateOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
-	workMoment := mongoDB.WorkMoment{
-		Comments:           []*mongoDB.Comment{},
-		LikeUserList:       []*mongoDB.WorkMomentUser{},
-		PermissionUserList: []*mongoDB.WorkMomentUser{},
-	}
-	createUser, err := imdb.GetUserByUserID(req.WorkMoment.UserID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	if err := utils.CopyStructFields(&workMoment, req.WorkMoment); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
-	}
-	workMoment.UserName = createUser.Nickname
-	workMoment.FaceURL = createUser.FaceURL
-	workMoment.PermissionUserIDList = s.getPermissionUserIDList(req.OperationID, req.WorkMoment.PermissionGroupList, req.WorkMoment.PermissionUserList)
-	workMoment.PermissionUserList = []*mongoDB.WorkMomentUser{}
-	for _, userID := range workMoment.PermissionUserIDList {
-		userName, err := imdb.GetUserNameByUserID(userID)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID failed", err.Error())
-			continue
-		}
-		workMoment.PermissionUserList = append(workMoment.PermissionUserList, &mongoDB.WorkMomentUser{
-			UserID:   userID,
-			UserName: userName,
-		})
-	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "workMoment to create", workMoment)
-	err = db.DB.CreateOneWorkMoment(&workMoment)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CreateOneWorkMoment", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-
-	// send notification to at users
-	for _, atUser := range req.WorkMoment.AtUserList {
-		workMomentNotificationMsg := &pbOffice.WorkMomentNotificationMsg{
-			NotificationMsgType: constant.WorkMomentAtUserNotification,
-			WorkMomentID:        workMoment.WorkMomentID,
-			WorkMomentContent:   workMoment.Content,
-			UserID:              workMoment.UserID,
-			FaceURL:             createUser.FaceURL,
-			UserName:            createUser.Nickname,
-			CreateTime:          workMoment.CreateTime,
-		}
-		msg.WorkMomentSendNotification(req.OperationID, atUser.UserID, workMomentNotificationMsg)
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) DeleteComment(_ context.Context, req *pbOffice.DeleteCommentReq) (resp *pbOffice.DeleteCommentResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.DeleteCommentResp{CommonResp: &pbOffice.CommonResp{}}
-	err = db.DB.DeleteComment(req.WorkMomentID, req.ContentID, req.OpUserID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetWorkMomentByID failed", err.Error())
-		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-// count and distinct permission users
-func (s *officeServer) getPermissionUserIDList(operationID string, groupList []*pbOffice.PermissionGroup, userList []*pbOffice.WorkMomentUser) []string {
-	var permissionUserIDList []string
-	for _, group := range groupList {
-		groupMemberIDList, err := imdb.GetGroupMemberIDListByGroupID(group.GroupID)
-		if err != nil {
-			log.NewError(operationID, utils.GetSelfFuncName(), "GetGroupMemberIDListByGroupID failed", group, err.Error())
-			continue
-		}
-		log.NewDebug(operationID, utils.GetSelfFuncName(), "groupMemberIDList: ", groupMemberIDList)
-		permissionUserIDList = append(permissionUserIDList, groupMemberIDList...)
-	}
-	var userIDList []string
-	for _, user := range userList {
-		userIDList = append(userIDList, user.UserID)
-	}
-	permissionUserIDList = append(permissionUserIDList, userIDList...)
-	permissionUserIDList = utils.RemoveRepeatedStringInList(permissionUserIDList)
-	return permissionUserIDList
-}
-
-func (s *officeServer) DeleteOneWorkMoment(_ context.Context, req *pbOffice.DeleteOneWorkMomentReq) (resp *pbOffice.DeleteOneWorkMomentResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.DeleteOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
-	workMoment, err := db.DB.GetWorkMomentByID(req.WorkMomentID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetWorkMomentByID failed", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "workMoment", workMoment)
-	if workMoment.UserID != req.UserID {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "workMoment.UserID != req.WorkMomentID, delete failed", workMoment, req.WorkMomentID)
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}
-		return resp, nil
-	}
-	err = db.DB.DeleteOneWorkMoment(req.WorkMomentID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DeleteOneWorkMoment", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func isUserCanSeeWorkMoment(userID string, workMoment mongoDB.WorkMoment) bool {
-	if userID != workMoment.UserID {
-		switch workMoment.Permission {
-		case constant.WorkMomentPublic:
-			return true
-		case constant.WorkMomentPrivate:
-			return false
-		case constant.WorkMomentPermissionCanSee:
-			return utils.IsContain(userID, workMoment.PermissionUserIDList)
-		case constant.WorkMomentPermissionCantSee:
-			return !utils.IsContain(userID, workMoment.PermissionUserIDList)
-		}
-		return false
-	}
-	return true
-}
-
-func (s *officeServer) LikeOneWorkMoment(_ context.Context, req *pbOffice.LikeOneWorkMomentReq) (resp *pbOffice.LikeOneWorkMomentResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.LikeOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
-	user, err := imdb.GetUserByUserID(req.UserID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID failed", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	workMoment, like, err := db.DB.LikeOneWorkMoment(req.UserID, user.Nickname, req.WorkMomentID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "LikeOneWorkMoment failed ", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	workMomentNotificationMsg := &pbOffice.WorkMomentNotificationMsg{
-		NotificationMsgType: constant.WorkMomentLikeNotification,
-		WorkMomentID:        workMoment.WorkMomentID,
-		WorkMomentContent:   workMoment.Content,
-		UserID:              user.UserID,
-		FaceURL:             user.FaceURL,
-		UserName:            user.Nickname,
-		CreateTime:          int32(time.Now().Unix()),
-	}
-	// send notification
-	if like && workMoment.UserID != req.UserID {
-		msg.WorkMomentSendNotification(req.OperationID, workMoment.UserID, workMomentNotificationMsg)
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) CommentOneWorkMoment(_ context.Context, req *pbOffice.CommentOneWorkMomentReq) (resp *pbOffice.CommentOneWorkMomentResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.CommentOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
-	commentUser, err := imdb.GetUserByUserID(req.UserID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID commentUserName failed", req.UserID, err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	var replyUserName string
-	if req.ReplyUserID != "" {
-		replyUserName, err = imdb.GetUserNameByUserID(req.ReplyUserID)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID get replyUserName failed", req.ReplyUserID, err.Error())
-			resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-			return resp, nil
-		}
-	}
-	comment := &mongoDB.Comment{
-		UserID:        req.UserID,
-		UserName:      commentUser.Nickname,
-		ReplyUserID:   req.ReplyUserID,
-		ReplyUserName: replyUserName,
-		Content:       req.Content,
-		CreateTime:    int32(time.Now().Unix()),
-	}
-	workMoment, err := db.DB.CommentOneWorkMoment(comment, req.WorkMomentID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CommentOneWorkMoment failed", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	workMomentNotificationMsg := &pbOffice.WorkMomentNotificationMsg{
-		NotificationMsgType: constant.WorkMomentCommentNotification,
-		WorkMomentID:        workMoment.WorkMomentID,
-		WorkMomentContent:   workMoment.Content,
-		UserID:              commentUser.UserID,
-		FaceURL:             commentUser.FaceURL,
-		UserName:            commentUser.Nickname,
-		ReplyUserID:         comment.ReplyUserID,
-		ReplyUserName:       comment.ReplyUserName,
-		ContentID:           comment.ContentID,
-		Content:             comment.Content,
-		CreateTime:          comment.CreateTime,
-	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "msg: ", *workMomentNotificationMsg)
-	if req.UserID != workMoment.UserID {
-		msg.WorkMomentSendNotification(req.OperationID, workMoment.UserID, workMomentNotificationMsg)
-	}
-	if req.ReplyUserID != "" && req.ReplyUserID != workMoment.UserID && req.ReplyUserID != req.UserID {
-		msg.WorkMomentSendNotification(req.OperationID, req.ReplyUserID, workMomentNotificationMsg)
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) GetWorkMomentByID(_ context.Context, req *pbOffice.GetWorkMomentByIDReq) (resp *pbOffice.GetWorkMomentByIDResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.GetWorkMomentByIDResp{
-		WorkMoment: &pbOffice.WorkMoment{},
-		CommonResp: &pbOffice.CommonResp{},
-	}
-	workMoment, err := db.DB.GetWorkMomentByID(req.WorkMomentID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetWorkMomentByID failed", err.Error())
-		return resp, nil
-	}
-	canSee := isUserCanSeeWorkMoment(req.OpUserID, *workMoment)
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), canSee, req.OpUserID, *workMoment)
-	if !canSee {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "workMoments not access to user", canSee, workMoment, req.OpUserID)
-	}
-
-	if err := utils.CopyStructFields(resp.WorkMoment, workMoment); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields", err.Error())
-	}
-	user, err := imdb.GetUserByUserID(workMoment.UserID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID failed", err.Error())
-	}
-	if user != nil {
-		resp.WorkMoment.FaceURL = user.FaceURL
-		resp.WorkMoment.UserName = user.Nickname
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) GetUserWorkMoments(_ context.Context, req *pbOffice.GetUserWorkMomentsReq) (resp *pbOffice.GetUserWorkMomentsResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.GetUserWorkMomentsResp{CommonResp: &pbOffice.CommonResp{}, WorkMoments: []*pbOffice.WorkMoment{}}
-	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
-	var workMoments []mongoDB.WorkMoment
-	if req.UserID == req.OpUserID {
-		workMoments, err = db.DB.GetUserSelfWorkMoments(req.UserID, req.Pagination.ShowNumber, req.Pagination.PageNumber)
-	} else {
-		friendIDList, err := rocksCache.GetFriendIDListFromCache(req.UserID)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserFriendWorkMoments", err.Error())
-			resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}
-			return resp, nil
-		}
-		workMoments, err = db.DB.GetUserWorkMoments(req.OpUserID, req.UserID, req.Pagination.ShowNumber, req.Pagination.PageNumber, friendIDList)
-	}
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserWorkMoments failed", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	if err := utils.CopyStructFields(&resp.WorkMoments, workMoments); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
-	}
-	for _, v := range resp.WorkMoments {
-		user, err := imdb.GetUserByUserID(v.UserID)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-		}
-		if user != nil {
-			v.UserName = user.Nickname
-			v.FaceURL = user.FaceURL
-		}
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) GetUserFriendWorkMoments(_ context.Context, req *pbOffice.GetUserFriendWorkMomentsReq) (resp *pbOffice.GetUserFriendWorkMomentsResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.GetUserFriendWorkMomentsResp{CommonResp: &pbOffice.CommonResp{}, WorkMoments: []*pbOffice.WorkMoment{}}
-	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
-	var friendIDList []string
-	if config.Config.WorkMoment.OnlyFriendCanSee {
-		friendIDList, err = rocksCache.GetFriendIDListFromCache(req.UserID)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserFriendWorkMoments", err.Error())
-			resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}
-			return resp, nil
-		}
-	}
-	workMoments, err := db.DB.GetUserFriendWorkMoments(req.Pagination.ShowNumber, req.Pagination.PageNumber, req.UserID, friendIDList)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserFriendWorkMoments", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	if err := utils.CopyStructFields(&resp.WorkMoments, workMoments); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
-	}
-	for _, v := range resp.WorkMoments {
-		user, err := rocksCache.GetUserInfoFromCache(v.UserID)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-		}
-		if user != nil {
-			v.UserName = user.Nickname
-			v.FaceURL = user.FaceURL
-		}
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) SetUserWorkMomentsLevel(_ context.Context, req *pbOffice.SetUserWorkMomentsLevelReq) (resp *pbOffice.SetUserWorkMomentsLevelResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.SetUserWorkMomentsLevelResp{CommonResp: &pbOffice.CommonResp{}}
-	if err := db.DB.SetUserWorkMomentsLevel(req.UserID, req.Level); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetUserWorkMomentsLevel failed", err.Error())
-		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-
-func (s *officeServer) ChangeWorkMomentPermission(_ context.Context, req *pbOffice.ChangeWorkMomentPermissionReq) (resp *pbOffice.ChangeWorkMomentPermissionResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp = &pbOffice.ChangeWorkMomentPermissionResp{CommonResp: &pbOffice.CommonResp{}}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}

internal/rpc/user/user.go

@@ -13,13 +13,10 @@ import (
 	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
-	"Open_IM/pkg/proto/group"
-	pbgroup "Open_IM/pkg/proto/group"
 	"Open_IM/pkg/proto/sdkws"
 	pbuser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
-	"github.com/golang/protobuf/ptypes/wrappers"
 	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
 
 	"google.golang.org/grpc"
@@ -28,12 +25,12 @@ import (
 type userServer struct {
 	rpcPort         int
 	rpcRegisterName string
-	*rpc_server.RpcServer
+	*rpcserver.RpcServer
 	controller.UserInterface
 }
 
 func NewUserServer(port int) *userServer {
-	r, err := rpc_server.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImUserName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImUserName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
 	if err != nil {
 		panic(err)
 	}
@@ -55,7 +52,7 @@ func NewUserServer(port int) *userServer {
 func (s *userServer) Run() {
 	operationID := utils.OperationIDGenerator()
 	log.NewInfo(operationID, "rpc user start...")
-	listener, address, err := rpc_server.GetTcpListen(config.Config.ListenIP, s.Port)
+	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
 	if err != nil {
 		panic(err)
 	}
@@ -86,87 +83,103 @@ func (s *userServer) Run() {
 }
 
 // ok
-func (s *userServer) SyncJoinedGroupMemberFaceURL(ctx context.Context, userID string, faceURL string, operationID string, opUserID string) {
-	members, err := s.GetJoinedGroupMembers(ctx, userID)
-	if err != nil {
-		return
-	}
-	groupIDs := make([]string, 0)
-	for _, v := range members {
-		groupIDs = append(groupIDs, v.GroupID)
-	}
-	if s.SetGroupMemberInfo(ctx, "", faceURL, "", 0, groupIDs, userID) != nil {
-		return
-	}
-	for _, v := range groupIDs {
-		chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
-	}
-}
+//func (s *userServer) SyncJoinedGroupMemberFaceURL(ctx context.Context, userID string, faceURL string, operationID string, opUserID string) {
+//	members, err := s.GetJoinedGroupMembers(ctx, userID)
+//	if err != nil {
+//		return
+//	}
+//	groupIDs := make([]string, 0)
+//	for _, v := range members {
+//		groupIDs = append(groupIDs, v.GroupID)
+//	}
+//	if s.SetGroupMemberInfo(ctx, "", faceURL, "", 0, groupIDs, userID) != nil {
+//		return
+//	}
+//	for _, v := range groupIDs {
+//		chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
+//	}
+//}
 
 // ok
-func (s *userServer) SyncJoinedGroupMemberNickname(ctx context.Context, userID string, newNickname, oldNickname string, operationID string, opUserID string) {
-	members, err := s.GetJoinedGroupMembers(ctx, userID)
-	if err != nil {
-		return
-	}
-	groupIDs := make([]string, 0)
-	for _, v := range members {
-		if v.Nickname == oldNickname {
-			groupIDs = append(groupIDs, v.GroupID)
-		}
-	}
-	s.SetGroupMemberInfo(ctx, newNickname, "", "", 0, groupIDs, userID)
-	for _, v := range groupIDs {
-		chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
-	}
-}
+//func (s *userServer) SyncJoinedGroupMemberNickname(ctx context.Context, userID string, newNickname, oldNickname string, operationID string, opUserID string) {
+//	members, err := s.GetJoinedGroupMembers(ctx, userID)
+//	if err != nil {
+//		return
+//	}
+//	groupIDs := make([]string, 0)
+//	for _, v := range members {
+//		if v.Nickname == oldNickname {
+//			groupIDs = append(groupIDs, v.GroupID)
+//		}
+//	}
+//	s.SetGroupMemberInfo(ctx, newNickname, "", "", 0, groupIDs, userID)
+//	for _, v := range groupIDs {
+//		chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
+//	}
+//}
 
-// 设置群昵称
-//func (s *userServer) SetGroupMemberNickname(ctx context.Context, nickname string, groupID string, userID string) (err error) {
+// 设置群头像
+//func (s *userServer) SetGroupMemberInfo(ctx context.Context, nickname, faceURL, ex string, roleLevel int32, groupIDs []string, userID string) (err error) {
+//
+//	req := pbgroup.SetGroupMemberInfo{UserID: userID}
+//	if nickname != "" {
+//		req.Nickname = &wrappers.StringValue{Value: nickname}
+//	}
+//	if faceURL != "" {
+//		req.FaceURL = &wrappers.StringValue{Value: faceURL}
+//	}
+//	if ex != "" {
+//		req.Ex = &wrappers.StringValue{Value: ex}
+//	}
+//	if roleLevel != 0 {
+//		req.RoleLevel = &wrappers.Int32Value{Value: roleLevel}
+//	}
+//
+//	setGroupMemberInfoReq := &pbgroup.SetGroupMemberInfoReq{}
+//	for _, v := range groupIDs {
+//		req.GroupID = v
+//		setGroupMemberInfoReq.Members = append(setGroupMemberInfoReq.Members, &req)
+//	}
 //	conn, err := s.RegisterCenter.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
 //	if err != nil {
 //		return err
 //	}
 //	client := group.NewGroupClient(conn)
-//	req := &pbgroup.SetGroupMemberNicknameReq{GroupID: groupID, Nickname: nickname, UserID: userID}
-//	_, err = client.SetGroupMemberNickname(ctx, req)
+//	_, err = client.SetGroupMemberInfo(ctx, setGroupMemberInfoReq)
 //	return
 //}
 
-// 设置群头像
-func (s *userServer) SetGroupMemberInfo(ctx context.Context, nickname, faceURL, ex string, roleLevel int32, groupIDs []string, userID string) (err error) {
-	conn, err := s.RegisterCenter.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
-	if err != nil {
-		return err
-	}
-	req := pbgroup.SetGroupMemberInfo{UserID: userID}
-	if nickname != "" {
-		req.Nickname = &wrappers.StringValue{Value: nickname}
-	}
-	if faceURL != "" {
-		req.FaceURL = &wrappers.StringValue{Value: faceURL}
-	}
-	if ex != "" {
-		req.Ex = &wrappers.StringValue{Value: ex}
-	}
-	if roleLevel != 0 {
-		req.RoleLevel = &wrappers.Int32Value{Value: roleLevel}
-	}
-
-	setGroupMemberInfoReq := &pbgroup.SetGroupMemberInfoReq{}
-	for _, v := range groupIDs {
-		req.GroupID = v
-		setGroupMemberInfoReq.Members = append(setGroupMemberInfoReq.Members, &req)
-	}
-	client := group.NewGroupClient(conn)
-	_, err = client.SetGroupMemberInfo(ctx, setGroupMemberInfoReq)
-	return
-}
-
 // 获取加入的群成员信息
-func (s *userServer) GetJoinedGroupMembers(ctx context.Context, userID string) (members []*sdkws.GroupMemberFullInfo, err error) {
-	return
-}
+//func (s *userServer) GetJoinedGroupMembers(ctx context.Context, userID string) (members []*sdkws.GroupMemberFullInfo, err error) {
+//	conn, err := s.RegisterCenter.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+//	if err != nil {
+//		return nil, err
+//	}
+//
+//	client := group.NewGroupClient(conn)
+//	for {
+//		idx := int32(0)
+//		req := pbgroup.GetJoinedGroupListReq{FromUserID: userID, Pagination: &sdkws.RequestPagination{PageNumber: idx, ShowNumber: constant.ShowNumber}}
+//		resp, err := client.GetJoinedGroupList(ctx, &req)
+//		if err != nil {
+//			return nil, err
+//		}
+//		groupIDs := make([]string, 0)
+//
+//		for _, v := range resp.Groups {
+//			groupIDs = append(groupIDs, v.GroupID)
+//		}
+//
+//		client.GetGroupMembersInfo()
+//
+//		if len(resp.Groups) < constant.ShowNumber {
+//			break
+//		}
+//		idx++
+//	}
+//
+//	return
+//}
 
 // ok
 func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbuser.GetDesignateUsersReq) (resp *pbuser.GetDesignateUsersResp, err error) {
@@ -193,14 +206,14 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 	if err != nil {
 		return nil, err
 	}
-	oldNickname := ""
-	if req.UserInfo.Nickname != "" {
-		u, err := s.FindWithError(ctx, []string{req.UserInfo.UserID})
-		if err != nil {
-			return nil, err
-		}
-		oldNickname = u[0].Nickname
-	}
+	//oldNickname := ""
+	//if req.UserInfo.Nickname != "" {
+	//	u, err := s.FindWithError(ctx, []string{req.UserInfo.UserID})
+	//	if err != nil {
+	//		return nil, err
+	//	}
+	//	oldNickname = u[0].Nickname
+	//}
 	user, err := convert.NewPBUser(req.UserInfo).Convert()
 	if err != nil {
 		return nil, err
@@ -220,12 +233,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 	}()
 
 	chat.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
-	if req.UserInfo.FaceURL != "" {
-		go s.SyncJoinedGroupMemberFaceURL(ctx, req.UserInfo.UserID, req.UserInfo.FaceURL, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
-	}
-	if req.UserInfo.Nickname != "" {
-		go s.SyncJoinedGroupMemberNickname(ctx, req.UserInfo.UserID, req.UserInfo.Nickname, oldNickname, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
-	}
+
 	return resp, nil
 }
 
@@ -296,7 +304,6 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 	for _, v := range req.Users {
 		userIDs = append(userIDs, v.UserID)
 	}
-
 	exist, err := s.IsExist(ctx, userIDs)
 	if err != nil {
 		return nil, err