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

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/group/callback.go

@@ -1,92 +1,105 @@
 package group
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
+	"Open_IM/pkg/apistruct"
+	"Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tracelog"
-	pbGroup "Open_IM/pkg/proto/group"
+	"Open_IM/pkg/proto/group"
 	"Open_IM/pkg/utils"
 	"context"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 )
 
-func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
-	}()
+func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (err error) {
 	if !config.Config.Callback.CallbackBeforeCreateGroup.Enable {
 		return nil
 	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), req.String())
-	commonCallbackReq := &cbApi.CallbackBeforeCreateGroupReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
+	}()
+	operationID := tracelog.GetOperationID(ctx)
+	commonCallbackReq := &callbackstruct.CallbackBeforeCreateGroupReq{
 		CallbackCommand: constant.CallbackBeforeCreateGroupCommand,
-		OperationID:     req.OperationID,
+		OperationID:     operationID,
 		GroupInfo:       *req.GroupInfo,
-		InitMemberList:  req.InitMemberList,
 	}
-	callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
-	resp := &cbApi.CallbackBeforeCreateGroupResp{
-		CommonCallbackResp: &callbackResp,
+	commonCallbackReq.InitMemberList = append(commonCallbackReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+		UserID:    req.OwnerUserID,
+		RoleLevel: constant.GroupOwner,
+	})
+	for _, userID := range req.AdminUserIDs {
+		commonCallbackReq.InitMemberList = append(commonCallbackReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+			UserID:    userID,
+			RoleLevel: constant.GroupAdmin,
+		})
 	}
-	//utils.CopyStructFields(req, msg.MsgData)
-	defer log.NewDebug(req.OperationID, utils.GetSelfFuncName(), commonCallbackReq, *resp)
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeCreateGroupCommand, commonCallbackReq,
-		resp, config.Config.Callback.CallbackBeforeCreateGroup)
-	if err == nil {
-		if resp.GroupID != nil {
-			req.GroupInfo.GroupID = *resp.GroupID
-		}
-		if resp.GroupName != nil {
-			req.GroupInfo.GroupName = *resp.GroupName
-		}
-		if resp.Notification != nil {
-			req.GroupInfo.Notification = *resp.Notification
-		}
-		if resp.Introduction != nil {
-			req.GroupInfo.Introduction = *resp.Introduction
-		}
-		if resp.FaceURL != nil {
-			req.GroupInfo.FaceURL = *resp.FaceURL
-		}
-		if resp.OwnerUserID != nil {
-			req.GroupInfo.OwnerUserID = *resp.OwnerUserID
-		}
-		if resp.Ex != nil {
-			req.GroupInfo.Ex = *resp.Ex
-		}
-		if resp.Status != nil {
-			req.GroupInfo.Status = *resp.Status
-		}
-		if resp.CreatorUserID != nil {
-			req.GroupInfo.CreatorUserID = *resp.CreatorUserID
-		}
-		if resp.GroupType != nil {
-			req.GroupInfo.GroupType = *resp.GroupType
-		}
-		if resp.NeedVerification != nil {
-			req.GroupInfo.NeedVerification = *resp.NeedVerification
-		}
-		if resp.LookMemberInfo != nil {
-			req.GroupInfo.LookMemberInfo = *resp.LookMemberInfo
-		}
+	for _, userID := range req.AdminUserIDs {
+		commonCallbackReq.InitMemberList = append(commonCallbackReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+			UserID:    userID,
+			RoleLevel: constant.GroupOrdinaryUsers,
+		})
 	}
-	return err
+	resp := &callbackstruct.CallbackBeforeCreateGroupResp{
+		CommonCallbackResp: &callbackstruct.CommonCallbackResp{OperationID: operationID},
+	}
+	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeCreateGroupCommand, commonCallbackReq, resp, config.Config.Callback.CallbackBeforeCreateGroup)
+	if err != nil {
+		return err
+	}
+
+	if resp.GroupID != nil {
+		req.GroupInfo.GroupID = *resp.GroupID
+	}
+	if resp.GroupName != nil {
+		req.GroupInfo.GroupName = *resp.GroupName
+	}
+	if resp.Notification != nil {
+		req.GroupInfo.Notification = *resp.Notification
+	}
+	if resp.Introduction != nil {
+		req.GroupInfo.Introduction = *resp.Introduction
+	}
+	if resp.FaceURL != nil {
+		req.GroupInfo.FaceURL = *resp.FaceURL
+	}
+	if resp.OwnerUserID != nil {
+		req.GroupInfo.OwnerUserID = *resp.OwnerUserID
+	}
+	if resp.Ex != nil {
+		req.GroupInfo.Ex = *resp.Ex
+	}
+	if resp.Status != nil {
+		req.GroupInfo.Status = *resp.Status
+	}
+	if resp.CreatorUserID != nil {
+		req.GroupInfo.CreatorUserID = *resp.CreatorUserID
+	}
+	if resp.GroupType != nil {
+		req.GroupInfo.GroupType = *resp.GroupType
+	}
+	if resp.NeedVerification != nil {
+		req.GroupInfo.NeedVerification = *resp.NeedVerification
+	}
+	if resp.LookMemberInfo != nil {
+		req.GroupInfo.LookMemberInfo = *resp.LookMemberInfo
+	}
+	return nil
 }
 
-func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
-	}()
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+func CallbackBeforeMemberJoinGroup(ctx context.Context, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
 	if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable {
 		return nil
 	}
-	log.NewDebug(operationID, "args: ", *groupMember)
-	callbackReq := cbApi.CallbackBeforeMemberJoinGroupReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
+	}()
+	operationID := tracelog.GetOperationID(ctx)
+	callbackResp := callbackstruct.CommonCallbackResp{OperationID: operationID}
+	callbackReq := callbackstruct.CallbackBeforeMemberJoinGroupReq{
 		CallbackCommand: constant.CallbackBeforeMemberJoinGroupCommand,
 		OperationID:     operationID,
 		GroupID:         groupMember.GroupID,
@@ -94,42 +107,44 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, grou
 		Ex:              groupMember.Ex,
 		GroupEx:         groupEx,
 	}
-	resp := &cbApi.CallbackBeforeMemberJoinGroupResp{
+	resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{
 		CommonCallbackResp: &callbackResp,
 	}
 	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeMemberJoinGroupCommand, callbackReq,
 		resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
-	if err == nil {
-		if resp.MuteEndTime != nil {
-			groupMember.MuteEndTime = utils.UnixSecondToTime(*resp.MuteEndTime)
-		}
-		if resp.FaceURL != nil {
-			groupMember.FaceURL = *resp.FaceURL
-		}
-		if resp.Ex != nil {
-			groupMember.Ex = *resp.Ex
-		}
-		if resp.NickName != nil {
-			groupMember.Nickname = *resp.NickName
-		}
-		if resp.RoleLevel != nil {
-			groupMember.RoleLevel = *resp.RoleLevel
-		}
+	if err != nil {
+		return err
 	}
-	return err
+	if resp.MuteEndTime != nil {
+		groupMember.MuteEndTime = utils.UnixSecondToTime(*resp.MuteEndTime)
+	}
+	if resp.FaceURL != nil {
+		groupMember.FaceURL = *resp.FaceURL
+	}
+	if resp.Ex != nil {
+		groupMember.Ex = *resp.Ex
+	}
+	if resp.NickName != nil {
+		groupMember.Nickname = *resp.NickName
+	}
+	if resp.RoleLevel != nil {
+		groupMember.RoleLevel = *resp.RoleLevel
+	}
+	return nil
 }
 
-func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfo) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
-	}()
-	callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
+func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *group.SetGroupMemberInfo) (err error) {
 	if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable {
 		return nil
 	}
-	callbackReq := cbApi.CallbackBeforeSetGroupMemberInfoReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
+	}()
+	operationID := tracelog.GetOperationID(ctx)
+	callbackResp := callbackstruct.CommonCallbackResp{OperationID: operationID}
+	callbackReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{
 		CallbackCommand: constant.CallbackBeforeSetGroupMemberInfoCommand,
-		OperationID:     req.OperationID,
+		OperationID:     operationID,
 		GroupID:         req.GroupID,
 		UserID:          req.UserID,
 	}
@@ -145,24 +160,24 @@ func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroup
 	if req.Ex != nil {
 		callbackReq.Ex = req.Ex.Value
 	}
-	resp := &cbApi.CallbackBeforeSetGroupMemberInfoResp{
+	resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{
 		CommonCallbackResp: &callbackResp,
 	}
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetGroupMemberInfoCommand, callbackReq,
-		resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSetGroupMemberInfo.CallbackFailedContinue)
-	if err == nil {
-		if resp.FaceURL != nil {
-			req.FaceURL = &wrapperspb.StringValue{Value: *resp.FaceURL}
-		}
-		if resp.Nickname != nil {
-			req.Nickname = &wrapperspb.StringValue{Value: *resp.Nickname}
-		}
-		if resp.RoleLevel != nil {
-			req.RoleLevel = &wrapperspb.Int32Value{Value: *resp.RoleLevel}
-		}
-		if resp.Ex != nil {
-			req.Ex = &wrapperspb.StringValue{Value: *resp.Ex}
-		}
+	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetGroupMemberInfoCommand, callbackReq, resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo)
+	if err != nil {
+		return err
+	}
+	if resp.FaceURL != nil {
+		req.FaceURL = &wrapperspb.StringValue{Value: *resp.FaceURL}
+	}
+	if resp.Nickname != nil {
+		req.Nickname = &wrapperspb.StringValue{Value: *resp.Nickname}
+	}
+	if resp.RoleLevel != nil {
+		req.RoleLevel = &wrapperspb.Int32Value{Value: *resp.RoleLevel}
+	}
+	if resp.Ex != nil {
+		req.Ex = &wrapperspb.StringValue{Value: *resp.Ex}
 	}
 	return 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/g.go

@@ -1,94 +0,0 @@
-package group
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/tracelog"
-	pbConversation "Open_IM/pkg/proto/conversation"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"errors"
-	"math/big"
-	"strconv"
-	"strings"
-	"time"
-)
-
-func GetPublicUserInfoOne(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
-	users, err := GetUsersInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	return utils.SliceToMap(users, func(e *sdkws.UserInfo) string {
-		return e.UserID
-	}), nil
-}
-
-func GetPublicUserInfo(ctx context.Context, userIDs []string) ([]*sdkws.PublicUserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetPublicUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.PublicUserInfo, error) {
-	users, err := GetPublicUserInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	return utils.SliceToMap(users, func(e *sdkws.PublicUserInfo) string {
-		return e.UserID
-	}), nil
-}
-
-func GetUsername(ctx context.Context, userIDs []string) (map[string]string, error) {
-	if len(userIDs) == 0 {
-		return map[string]string{}, nil
-	}
-	users, err := GetPublicUserInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	if ids := utils.Single(userIDs, utils.Slice(users, func(e *sdkws.PublicUserInfo) string {
-		return e.UserID
-	})); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
-	return utils.SliceToMapAny(users, func(e *sdkws.PublicUserInfo) (string, string) {
-		return e.UserID, e.Nickname
-	}), nil
-}
-
-func GroupNotification(ctx context.Context, groupID string) {
-	var conversationReq pbConversation.ModifyConversationFieldReq
-	conversation := pbConversation.Conversation{
-		OwnerUserID:      tracelog.GetOpUserID(ctx),
-		ConversationID:   utils.GetConversationIDBySessionType(groupID, constant.GroupChatType),
-		ConversationType: constant.GroupChatType,
-		GroupID:          groupID,
-	}
-	conversationReq.Conversation = &conversation
-	conversationReq.OperationID = tracelog.GetOperationID(ctx)
-	conversationReq.FieldType = constant.FieldGroupAtType
-	conversation.GroupAtType = constant.GroupNotification
-	conversationReq.UserIDList = cacheResp.UserIDList
-
-	_, err = pbConversation.NewConversationClient(s.etcdConn.GetConn("", config.Config.RpcRegisterName.OpenImConversationName)).ModifyConversationField(ctx, &conversationReq)
-	tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
-}
-
-func genGroupID(ctx context.Context, groupID string) string {
-	if groupID != "" {
-		return groupID
-	}
-	groupID = utils.Md5(tracelog.GetOperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
-	bi := big.NewInt(0)
-	bi.SetString(groupID[0:8], 16)
-	groupID = bi.String()
-	return groupID
-}

internal/rpc/group/group.go

@@ -1,6 +1,7 @@
 package group
 
 import (
+	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/network"
 	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/config"
@@ -17,11 +18,14 @@ 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"
 	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
+	"gorm.io/gorm"
+	"math/big"
+	"math/rand"
 	"net"
 	"strconv"
 	"strings"
@@ -38,6 +42,7 @@ type groupServer struct {
 	zkAddr          []string
 	GroupInterface  controller.GroupInterface
 	registerCenter  discoveryRegistry.SvcDiscoveryRegistry
+	user            *check.UserCheck
 }
 
 func NewGroupServer(port int) *groupServer {
@@ -72,8 +77,8 @@ func NewGroupServer(port int) *groupServer {
 	}
 
 	//conns, err := g.registerCenter.GetConns(config.Config.RpcRegisterName.OpenImConversationName)
-
 	g.GroupInterface = controller.NewGroupInterface(mysql.GormConn(), redis.GetClient(), mongo.GetClient())
+	g.user = check.NewUserCheck()
 	return &g
 }
 
@@ -132,8 +137,71 @@ func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
 	return nil
 }
 
+func (s *groupServer) GetUsernameMap(ctx context.Context, userIDs []string, complete bool) (map[string]string, error) {
+	if len(userIDs) == 0 {
+		return map[string]string{}, nil
+	}
+	users, err := s.user.GetPublicUserInfos(ctx, userIDs, complete)
+	if err != nil {
+		return nil, err
+	}
+	return utils.SliceToMapAny(users, func(e *open_im_sdk.PublicUserInfo) (string, string) {
+		return e.UserID, e.Nickname
+	}), nil
+}
+
+func (s *groupServer) GroupNotification(ctx context.Context, groupID string) {
+	// todo 群公告修改通知
+	//var conversationReq pbConversation.ModifyConversationFieldReq
+	//conversation := pbConversation.Conversation{
+	//	OwnerUserID:      tracelog.GetOpUserID(ctx),
+	//	ConversationID:   utils.GetConversationIDBySessionType(groupID, constant.GroupChatType),
+	//	ConversationType: constant.GroupChatType,
+	//	GroupID:          groupID,
+	//}
+	//conversationReq.Conversation = &conversation
+	//conversationReq.FieldType = constant.FieldGroupAtType
+	//conversation.GroupAtType = constant.GroupNotification
+	//conversationReq.UserIDList = userIDs
+	//_, err := pbConversation.NewConversationClient(s.etcdConn.GetConn("", config.Config.RpcRegisterName.OpenImConversationName)).ModifyConversationField(ctx, &conversationReq)
+	//tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
+}
+
+func (s *groupServer) IsNotFound(err error) bool {
+	return utils.Unwrap(err) == gorm.ErrRecordNotFound
+}
+
+func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
+	if *groupID != "" {
+		_, err := s.GroupInterface.TakeGroup(ctx, *groupID)
+		if err == nil {
+			return constant.ErrGroupIDExisted.Wrap("group id existed " + *groupID)
+		} else if s.IsNotFound(err) {
+			return nil
+		} else {
+			return err
+		}
+	}
+	for i := 0; i < 10; i++ {
+		id := utils.Md5(strings.Join([]string{tracelog.GetOperationID(ctx), strconv.FormatInt(time.Now().UnixNano(), 10), strconv.Itoa(rand.Int())}, ",;,"))
+		bi := big.NewInt(0)
+		bi.SetString(id[0:8], 16)
+		id = bi.String()
+		_, err := s.GroupInterface.TakeGroup(ctx, id)
+		if err == nil {
+			continue
+		} else if s.IsNotFound(err) {
+			*groupID = id
+			return nil
+		} else {
+			return err
+		}
+	}
+	return constant.ErrData.Wrap("group id gen 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
 	}
@@ -144,19 +212,18 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if utils.Duplicate(userIDs) {
 		return nil, constant.ErrArgs.Wrap("group member repeated")
 	}
-	userMap, err := GetUserInfoMap(ctx, userIDs)
+	userMap, err := s.user.GetUsersInfoMap(ctx, userIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(userIDs, utils.Keys(userMap)); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
-	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
+	if err := CallbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
 	var groupMembers []*relationTb.GroupMemberModel
 	group := PbToDBGroupInfo(req.GroupInfo)
-	group.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
+	if err := s.GenGroupID(ctx, &group.GroupID); err != nil {
+		return nil, err
+	}
 	joinGroup := func(userID string, roleLevel int32) error {
 		groupMember := PbToDbGroupMember(userMap[userID])
 		groupMember.Nickname = ""
@@ -165,7 +232,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
 		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
-		if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
+		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil {
 			return err
 		}
 		groupMembers = append(groupMembers, groupMember)
@@ -240,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
@@ -271,13 +338,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
 		return nil, constant.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
 	}
-	userMap, err := GetUserInfoMap(ctx, req.InvitedUserIDs)
+	userMap, err := s.user.GetUsersInfoMap(ctx, req.InvitedUserIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(userMap)); len(ids) > 0 {
-		return nil, constant.ErrArgs.Wrap("user not found " + strings.Join(ids, ","))
-	}
 	if group.NeedVerification == constant.AllNeedVerification {
 		if !tokenverify.IsAppManagerUid(ctx) {
 			opUserID := tracelog.GetOpUserID(ctx)
@@ -328,7 +392,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			member.OperatorUserID = opUserID
 			member.InviterUserID = opUserID
 			member.JoinSource = constant.JoinByInvitation
-			if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), member, group.Ex); err != nil {
+			if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil {
 				return nil, err
 			}
 			groupMembers = append(groupMembers, member)
@@ -354,13 +418,13 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	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]
 		}
@@ -376,13 +440,13 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 		return nil, err
 	}
 	resp.Total = total
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	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]
 		}
@@ -470,13 +534,13 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	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]
 		}
@@ -505,13 +569,10 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	}
 	userIDs = utils.Distinct(userIDs)
 	groupIDs = utils.Distinct(groupIDs)
-	userMap, err := GetPublicUserInfoMap(ctx, userIDs)
+	userMap, err := s.user.GetPublicUserInfoMap(ctx, userIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(utils.Keys(userMap), userIDs); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
 	groups, err := s.GroupInterface.FindGroup(ctx, utils.Distinct(groupIDs))
 	if err != nil {
 		return nil, err
@@ -533,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
@@ -559,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
@@ -590,19 +651,18 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 	if groupRequest.HandleResult != 0 {
 		return nil, constant.ErrArgs.Wrap("group request already processed")
 	}
-	if _, err := s.GroupInterface.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err != nil {
-		if !IsNotFound(err) {
-			return nil, err
-		}
-	} else {
-		return nil, constant.ErrArgs.Wrap("already in group")
+	var join bool
+	if _, err = s.GroupInterface.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil {
+		join = true // 已经在群里了
+	} else if !s.IsNotFound(err) {
+		return nil, err
 	}
-	user, err := GetPublicUserInfoOne(ctx, req.FromUserID)
+	user, err := s.user.GetPublicUserInfo(ctx, req.FromUserID)
 	if err != nil {
 		return nil, err
 	}
 	var member *relationTb.GroupMemberModel
-	if req.HandleResult == constant.GroupResponseAgree {
+	if (!join) && req.HandleResult == constant.GroupResponseAgree {
 		member = &relationTb.GroupMemberModel{
 			GroupID:        req.GroupID,
 			UserID:         user.UserID,
@@ -615,25 +675,27 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 			OperatorUserID: tracelog.GetOpUserID(ctx),
 			Ex:             groupRequest.Ex,
 		}
-		if err = CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), member, group.Ex); err != nil {
+		if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil {
 			return nil, err
 		}
 	}
 	if err := s.GroupInterface.HandlerGroupRequest(ctx, req.GroupID, req.FromUserID, req.HandledMsg, req.HandleResult, member); err != nil {
 		return nil, err
 	}
-	if req.HandleResult == constant.GroupResponseAgree {
-		chat.GroupApplicationAcceptedNotification(req)
-		chat.MemberEnterNotification(req)
-	} else if req.HandleResult == constant.GroupResponseRefuse {
-		chat.GroupApplicationRejectedNotification(req)
+	if !join {
+		if req.HandleResult == constant.GroupResponseAgree {
+			chat.GroupApplicationAcceptedNotification(req)
+			chat.MemberEnterNotification(ctx, req)
+		} else if req.HandleResult == constant.GroupResponseRefuse {
+			chat.GroupApplicationRejectedNotification(req)
+		}
 	}
 	return resp, nil
 }
 
 func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
 	resp := &pbGroup.JoinGroupResp{}
-	if _, err := GetPublicUserInfoOne(ctx, tracelog.GetOpUserID(ctx)); err != nil {
+	if _, err := s.user.GetPublicUserInfo(ctx, tracelog.GetOpUserID(ctx)); err != nil {
 		return nil, err
 	}
 	group, err := s.GroupInterface.TakeGroup(ctx, req.GroupID)
@@ -657,7 +719,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
 		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
-		if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
+		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil {
 			return nil, err
 		}
 		if err := s.GroupInterface.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil {
@@ -732,7 +794,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	}
 	chat.GroupInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupInfoForSet.GroupID, group.GroupName, group.Notification, group.Introduction, group.FaceURL, req.GroupInfoForSet.NeedVerification)
 	if req.GroupInfoForSet.Notification != "" {
-		GroupNotification(ctx, group.GroupID)
+		s.GroupNotification(ctx, group.GroupID)
 	}
 	return resp, nil
 }
@@ -830,13 +892,13 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 		return nil, err
 	}
 	resp.Total = total
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	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]
 		}
@@ -847,7 +909,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 
 func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGroup.GetUserReqApplicationListReq) (*pbGroup.GetUserReqApplicationListResp, error) {
 	resp := &pbGroup.GetUserReqApplicationListResp{}
-	user, err := GetPublicUserInfoOne(ctx, req.UserID)
+	user, err := s.user.GetPublicUserInfo(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -886,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
@@ -1105,13 +1167,13 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.Ge
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	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/group/utils.go

@@ -1,13 +0,0 @@
-package group
-
-import (
-	"Open_IM/pkg/common/tracelog"
-	"gorm.io/gorm"
-)
-
-func IsNotFound(err error) bool {
-	if err == nil {
-		return false
-	}
-	return tracelog.Unwrap(err) == gorm.ErrRecordNotFound
-}

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(ctx context.Context, 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(ctx context.Context, sendID, recvID stri
 // 会话改变
 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(context context.Context, 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
-}