v3 - main to cut out

internal/api/auth/auth.go

@@ -0,0 +1,91 @@
+package apiAuth
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	rpc "Open_IM/pkg/proto/auth"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func UserRegister(c *gin.Context) {
+	params := api.UserRegisterReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	if params.Secret != config.Config.Secret {
+		log.NewError(params.OperationID, "params.Secret != config.Config.Secret", params.Secret, config.Config.Secret)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "not authorized"})
+		return
+	}
+	req := &rpc.UserRegisterReq{UserInfo: &open_im_sdk.UserInfo{}}
+	utils.CopyStructFields(req.UserInfo, &params)
+	//copier.Copy(req.UserInfo, &params)
+	req.OperationID = params.OperationID
+	log.NewInfo(req.OperationID, "UserRegister args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
+	client := rpc.NewAuthClient(etcdConn)
+	reply, err := client.UserRegister(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "call rpc err ", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "internal service err"})
+		return
+	}
+	if reply.CommonResp.ErrCode != 0 {
+		log.NewError(req.OperationID, "UserRegister failed ", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": reply.CommonResp.ErrMsg})
+		return
+
+	}
+
+	pbDataToken := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
+	replyToken, err := client.UserToken(context.Background(), pbDataToken)
+	if err != nil {
+		log.NewError(req.OperationID, "UserToken failed ", err.Error(), pbDataToken)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+	resp := api.UserRegisterResp{CommResp: api.CommResp{ErrCode: replyToken.CommonResp.ErrCode, ErrMsg: replyToken.CommonResp.ErrMsg},
+		UserToken: api.UserTokenInfo{UserID: req.UserInfo.UserID, Token: replyToken.Token, ExpiredTime: replyToken.ExpiredTime}}
+	log.NewInfo(req.OperationID, "UserRegister return ", resp)
+	c.JSON(http.StatusOK, resp)
+
+}
+
+func UserToken(c *gin.Context) {
+	params := api.UserTokenReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	if params.Secret != config.Config.Secret {
+		log.NewError(params.OperationID, "params.Secret != config.Config.Secret", params.Secret, config.Config.Secret)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "not authorized"})
+		return
+	}
+	req := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
+	log.NewInfo(req.OperationID, "UserToken args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
+	client := rpc.NewAuthClient(etcdConn)
+	reply, err := client.UserToken(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "UserToken failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+	resp := api.UserTokenResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg},
+		UserToken: api.UserTokenInfo{UserID: req.FromUserID, Token: reply.Token, ExpiredTime: reply.ExpiredTime}}
+	log.NewInfo(req.OperationID, "UserRegister return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/chat/del_msg.go

@@ -0,0 +1,43 @@
+package apiChat
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func DelMsg(c *gin.Context) {
+	var (
+		req   api.DelMsgReq
+		resp  api.DelMsgResp
+		reqPb pbCommon.DelMsgListReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, &req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	msgClient := pbChat.NewChatClient(grpcConn)
+	respPb, err := msgClient.DelMsgList(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelMsgList failed", err.Error(), reqPb)
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.ErrServer.ErrCode, "errMsg": constant.ErrServer.ErrMsg + err.Error()})
+		return
+	}
+	resp.ErrCode = respPb.ErrCode
+	resp.ErrMsg = respPb.ErrMsg
+	c.JSON(http.StatusOK, resp)
+}

internal/api/chat/get_max_min_seq.go

@@ -0,0 +1,61 @@
+package apiChat
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbMsg "Open_IM/pkg/proto/chat"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsUserNewestSeq struct {
+	ReqIdentifier int    `json:"reqIdentifier" binding:"required"`
+	SendID        string `json:"sendID" binding:"required"`
+	OperationID   string `json:"operationID" binding:"required"`
+	MsgIncr       int    `json:"msgIncr" binding:"required"`
+}
+
+func GetSeq(c *gin.Context) {
+	params := paramsUserNewestSeq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	token := c.Request.Header.Get("token")
+	if ok, err := token_verify.VerifyToken(token, params.SendID); !ok {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
+		return
+	}
+	pbData := pbMsg.GetMaxAndMinSeqReq{}
+	pbData.UserID = params.SendID
+	pbData.OperationID = params.OperationID
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+
+	if grpcConn == nil {
+		log.ErrorByKv("get grpcConn err", pbData.OperationID, "args", params)
+	}
+	msgClient := pbMsg.NewChatClient(grpcConn)
+	reply, err := msgClient.GetMaxAndMinSeq(context.Background(), &pbData)
+	if err != nil {
+		log.NewError(params.OperationID, "UserGetSeq rpc failed, ", params, err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "UserGetSeq rpc failed, " + err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode":       reply.ErrCode,
+		"errMsg":        reply.ErrMsg,
+		"msgIncr":       params.MsgIncr,
+		"reqIdentifier": params.ReqIdentifier,
+		"data": gin.H{
+			"maxSeq": reply.MaxSeq,
+			"minSeq": reply.MinSeq,
+		},
+	})
+
+}

internal/api/chat/pull_msg.go

@@ -0,0 +1,68 @@
+package apiChat
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	"Open_IM/pkg/proto/chat"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsUserPullMsg struct {
+	ReqIdentifier *int   `json:"reqIdentifier" binding:"required"`
+	SendID        string `json:"sendID" binding:"required"`
+	OperationID   string `json:"operationID" binding:"required"`
+	Data          struct {
+		SeqBegin *int64 `json:"seqBegin" binding:"required"`
+		SeqEnd   *int64 `json:"seqEnd" binding:"required"`
+	}
+}
+
+type paramsUserPullMsgBySeqList struct {
+	ReqIdentifier int      `json:"reqIdentifier" binding:"required"`
+	SendID        string   `json:"sendID" binding:"required"`
+	OperationID   string   `json:"operationID" binding:"required"`
+	SeqList       []uint32 `json:"seqList"`
+}
+
+func PullMsgBySeqList(c *gin.Context) {
+	params := paramsUserPullMsgBySeqList{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	token := c.Request.Header.Get("token")
+	if ok, err := token_verify.VerifyToken(token, params.SendID); !ok {
+		if err != nil {
+			log.NewError(params.OperationID, utils.GetSelfFuncName(), err.Error(), token, params.SendID)
+		}
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"})
+		return
+	}
+	pbData := open_im_sdk.PullMessageBySeqListReq{}
+	pbData.UserID = params.SendID
+	pbData.OperationID = params.OperationID
+	pbData.SeqList = params.SeqList
+
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	msgClient := pbChat.NewChatClient(grpcConn)
+	reply, err := msgClient.PullMessageBySeqList(context.Background(), &pbData)
+	if err != nil {
+		log.ErrorByKv("PullMessageBySeqList error", pbData.OperationID, "err", err.Error())
+		return
+	}
+	log.InfoByKv("rpc call success to PullMessageBySeqList", pbData.OperationID, "ReplyArgs", reply.String(), len(reply.List))
+	c.JSON(http.StatusOK, gin.H{
+		"errCode":       reply.ErrCode,
+		"errMsg":        reply.ErrMsg,
+		"reqIdentifier": params.ReqIdentifier,
+		"data":          reply.List,
+	})
+}

internal/api/chat/send_msg.go

@@ -0,0 +1,99 @@
+package apiChat
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	pbChat "Open_IM/pkg/proto/chat"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"context"
+
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsUserSendMsg struct {
+	SenderPlatformID int32  `json:"senderPlatformID" binding:"required"`
+	SendID           string `json:"sendID" binding:"required"`
+	SenderNickName   string `json:"senderNickName"`
+	SenderFaceURL    string `json:"senderFaceUrl"`
+	OperationID      string `json:"operationID" binding:"required"`
+	Data             struct {
+		SessionType int32                        `json:"sessionType" binding:"required"`
+		MsgFrom     int32                        `json:"msgFrom" binding:"required"`
+		ContentType int32                        `json:"contentType" binding:"required"`
+		RecvID      string                       `json:"recvID" `
+		GroupID     string                       `json:"groupID" `
+		ForceList   []string                     `json:"forceList"`
+		Content     []byte                       `json:"content" binding:"required"`
+		Options     map[string]bool              `json:"options" `
+		ClientMsgID string                       `json:"clientMsgID" binding:"required"`
+		CreateTime  int64                        `json:"createTime" binding:"required"`
+		OffLineInfo *open_im_sdk.OfflinePushInfo `json:"offlineInfo" `
+	}
+}
+
+func newUserSendMsgReq(token string, params *paramsUserSendMsg) *pbChat.SendMsgReq {
+	pbData := pbChat.SendMsgReq{
+		Token:       token,
+		OperationID: params.OperationID,
+		MsgData: &open_im_sdk.MsgData{
+			SendID:           params.SendID,
+			RecvID:           params.Data.RecvID,
+			GroupID:          params.Data.GroupID,
+			ClientMsgID:      params.Data.ClientMsgID,
+			SenderPlatformID: params.SenderPlatformID,
+			SenderNickname:   params.SenderNickName,
+			SenderFaceURL:    params.SenderFaceURL,
+			SessionType:      params.Data.SessionType,
+			MsgFrom:          params.Data.MsgFrom,
+			ContentType:      params.Data.ContentType,
+			Content:          params.Data.Content,
+			CreateTime:       params.Data.CreateTime,
+			Options:          params.Data.Options,
+			OfflinePushInfo:  params.Data.OffLineInfo,
+		},
+	}
+	return &pbData
+}
+
+func SendMsg(c *gin.Context) {
+	params := paramsUserSendMsg{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		log.ErrorByKv("json unmarshal err", "", "err", err.Error(), "data", c.PostForm("data"))
+		return
+	}
+
+	token := c.Request.Header.Get("token")
+
+	log.InfoByKv("api call success to sendMsgReq", params.OperationID, "Parameters", params)
+
+	pbData := newUserSendMsgReq(token, &params)
+	log.Info("", "", "api SendMsg call start..., [data: %s]", pbData.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	client := pbChat.NewChatClient(etcdConn)
+
+	log.Info("", "", "api SendMsg call, api call rpc...")
+
+	reply, err := client.SendMsg(context.Background(), pbData)
+	if err != nil {
+		log.NewError(params.OperationID, "SendMsg rpc failed, ", params, err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "SendMsg rpc failed, " + err.Error()})
+		return
+	}
+	log.Info("", "", "api SendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode": reply.ErrCode,
+		"errMsg":  reply.ErrMsg,
+		"data": gin.H{
+			"clientMsgID": reply.ClientMsgID,
+			"serverMsgID": reply.ServerMsgID,
+			"sendTime":    reply.SendTime,
+		},
+	})
+
+}

internal/api/conversation/conversation.go

@@ -0,0 +1,218 @@
+package conversation
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbUser "Open_IM/pkg/proto/user"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func SetConversation(c *gin.Context) {
+	var (
+		req   api.SetConversationReq
+		resp  api.SetConversationResp
+		reqPb pbUser.SetConversationReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	reqPb.Conversation = &pbUser.Conversation{}
+	err := utils.CopyStructFields(&reqPb, req)
+	err = utils.CopyStructFields(reqPb.Conversation, req.Conversation)
+	if err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", reqPb.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.SetConversation(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		return
+	}
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func BatchSetConversations(c *gin.Context) {
+	var (
+		req   api.BatchSetConversationsReq
+		resp  api.BatchSetConversationsResp
+		reqPb pbUser.BatchSetConversationsReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", reqPb.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.BatchSetConversations(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp.Data, respPb); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetAllConversations(c *gin.Context) {
+	var (
+		req   api.GetAllConversationsReq
+		resp  api.GetAllConversationsResp
+		reqPb pbUser.GetAllConversationsReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", reqPb.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.GetAllConversations(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		return
+	}
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	if err := utils.CopyStructFields(&resp.Conversations, respPb.Conversations); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed, ", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetConversation(c *gin.Context) {
+	var (
+		req   api.GetConversationReq
+		resp  api.GetConversationResp
+		reqPb pbUser.GetConversationReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", reqPb.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.GetConversation(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetConversation rpc failed, ", reqPb.String(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		return
+	}
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	if err := utils.CopyStructFields(&resp.Conversation, respPb.Conversation); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetConversations(c *gin.Context) {
+	var (
+		req   api.GetConversationsReq
+		resp  api.GetConversationsResp
+		reqPb pbUser.GetConversationsReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", reqPb.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.GetConversations(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		return
+	}
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	if err := utils.CopyStructFields(&resp.Conversations, respPb.Conversations); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func SetRecvMsgOpt(c *gin.Context) {
+	var (
+		req   api.SetRecvMsgOptReq
+		resp  api.SetRecvMsgOptResp
+		reqPb pbUser.SetRecvMsgOptReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", reqPb.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.SetRecvMsgOpt(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetRecvMsgOpt rpc failed, ", reqPb.String(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		return
+	}
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+//Deprecated
+func SetReceiveMessageOpt(c *gin.Context) {
+
+}
+
+//Deprecated
+func GetReceiveMessageOpt(c *gin.Context) {
+
+}
+
+//Deprecated
+func GetAllConversationMessageOpt(c *gin.Context) {
+
+}

internal/api/friend/friend.go

@@ -0,0 +1,456 @@
+package friend
+
+import (
+	jsonData "Open_IM/internal/utils"
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	rpc "Open_IM/pkg/proto/friend"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func AddBlack(c *gin.Context) {
+	params := api.AddBlacklistReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.AddBlacklistReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params)
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "AddBlacklist args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.AddBlacklist(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "AddBlacklist failed ", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add blacklist rpc server failed"})
+		return
+	}
+	resp := api.AddBlacklistResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	log.NewInfo(req.CommID.OperationID, "AddBlacklist api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func ImportFriend(c *gin.Context) {
+	params := api.ImportFriendReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.ImportFriendReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "ImportFriend args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.ImportFriend(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "ImportFriend failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "ImportFriend failed "})
+		return
+	}
+	resp := api.ImportFriendResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	if resp.ErrCode == 0 {
+		for _, v := range RpcResp.UserIDResultList {
+			resp.UserIDResultList = append(resp.UserIDResultList, api.UserIDResult{UserID: v.UserID, Result: v.Result})
+		}
+	}
+	if len(resp.UserIDResultList) == 0 {
+		resp.UserIDResultList = []api.UserIDResult{}
+	}
+	log.NewInfo(req.OperationID, "ImportFriend api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func AddFriend(c *gin.Context) {
+	params := api.AddFriendReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.AddFriendReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
+	req.ReqMsg = params.ReqMsg
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.CommID.OperationID, "AddFriend args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.AddFriend(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "AddFriend failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call AddFriend rpc server failed"})
+		return
+	}
+
+	resp := api.AddFriendResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	log.NewInfo(req.CommID.OperationID, "AddFriend api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func AddFriendResponse(c *gin.Context) {
+	params := api.AddFriendResponseReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.AddFriendResponseReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
+	req.HandleMsg = params.HandleMsg
+	req.HandleResult = params.Flag
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	utils.CopyStructFields(req, &params)
+	log.NewInfo(req.CommID.OperationID, "AddFriendResponse args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.AddFriendResponse(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "AddFriendResponse failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add_friend_response rpc server failed"})
+		return
+	}
+
+	resp := api.AddFriendResponseResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	log.NewInfo(req.CommID.OperationID, "AddFriendResponse api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func DeleteFriend(c *gin.Context) {
+	params := api.DeleteFriendReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.DeleteFriendReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.CommID.OperationID, "DeleteFriend args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.DeleteFriend(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "DeleteFriend failed ", err, req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call delete_friend rpc server failed"})
+		return
+	}
+
+	resp := api.DeleteFriendResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	log.NewInfo(req.CommID.OperationID, "DeleteFriend api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetBlacklist(c *gin.Context) {
+	params := api.GetBlackListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetBlacklistReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params)
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.CommID.OperationID, "GetBlacklist args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.GetBlacklist(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetBlacklist failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get blacklist rpc server failed"})
+		return
+	}
+
+	resp := api.GetBlackListResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	for _, v := range RpcResp.BlackUserInfoList {
+		black := open_im_sdk.PublicUserInfo{}
+		utils.CopyStructFields(&black, v)
+		resp.BlackUserInfoList = append(resp.BlackUserInfoList, &black)
+	}
+	resp.Data = jsonData.JsonDataList(resp.BlackUserInfoList)
+	log.NewInfo(req.CommID.OperationID, "GetBlacklist api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func SetFriendRemark(c *gin.Context) {
+	params := api.SetFriendRemarkReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.SetFriendRemarkReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
+	req.Remark = params.Remark
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.CommID.OperationID, "SetFriendComment args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.SetFriendRemark(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "SetFriendComment failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call set friend comment rpc server failed"})
+		return
+	}
+	resp := api.SetFriendRemarkResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+
+	log.NewInfo(req.CommID.OperationID, "SetFriendComment api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func RemoveBlack(c *gin.Context) {
+	params := api.RemoveBlackListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.RemoveBlacklistReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+
+	log.NewInfo(req.CommID.OperationID, "RemoveBlacklist args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.RemoveBlacklist(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "RemoveBlacklist failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call remove blacklist rpc server failed"})
+		return
+	}
+	resp := api.RemoveBlackListResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	log.NewInfo(req.CommID.OperationID, "RemoveBlacklist api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func IsFriend(c *gin.Context) {
+	params := api.IsFriendReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.IsFriendReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.CommID.OperationID, "IsFriend args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.IsFriend(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "IsFriend failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add friend rpc server failed"})
+		return
+	}
+	resp := api.IsFriendResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	resp.Response.Friend = RpcResp.Response
+
+	log.NewInfo(req.CommID.OperationID, "IsFriend api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+//
+//func GetFriendsInfo(c *gin.Context) {
+//	params := api.GetFriendsInfoReq{}
+//	if err := c.BindJSON(&params); err != nil {
+//		log.NewError("0", "BindJSON failed ", err.Error())
+//		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+//		return
+//	}
+//	req := &rpc.GetFriendsInfoReq{}
+//	utils.CopyStructFields(req.CommID, params)
+//	var ok bool
+//	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+//	if !ok {
+//		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+//		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+//		return
+//	}
+//	log.NewInfo(req.CommID.OperationID, "GetFriendsInfo args ", req.String())
+//
+//	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+//	client := rpc.NewFriendClient(etcdConn)
+//	RpcResp, err := client.GetFriendsInfo(context.Background(), req)
+//	if err != nil {
+//		log.NewError(req.CommID.OperationID, "GetFriendsInfo failed ", err.Error(), req.String())
+//		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call search friend rpc server failed"})
+//		return
+//	}
+//
+//	resp := api.GetFriendsInfoResp{CommResp:api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+//	utils.CopyStructFields(&resp, RpcResp)
+//	c.JSON(http.StatusOK, resp)
+//	log.NewInfo(req.CommID.OperationID, "GetFriendsInfo api return ", resp)
+//}
+
+func GetFriendList(c *gin.Context) {
+	params := api.GetFriendListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetFriendListReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params)
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.CommID.OperationID, "GetFriendList args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.GetFriendList(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetFriendList failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get friend list rpc server failed"})
+		return
+	}
+
+	resp := api.GetFriendListResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, FriendInfoList: RpcResp.FriendInfoList}
+	resp.Data = jsonData.JsonDataList(resp.FriendInfoList)
+	log.NewInfo(req.CommID.OperationID, "GetFriendList api return ", resp)
+	c.JSON(http.StatusOK, resp)
+	//c.JSON(http.StatusOK, resp)
+}
+
+func GetFriendApplyList(c *gin.Context) {
+	params := api.GetFriendApplyListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetFriendApplyListReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params)
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.CommID.OperationID, "GetFriendApplyList args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+
+	RpcResp, err := client.GetFriendApplyList(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetFriendApplyList failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get friend apply list rpc server failed"})
+		return
+	}
+
+	resp := api.GetFriendApplyListResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, FriendRequestList: RpcResp.FriendRequestList}
+	resp.Data = jsonData.JsonDataList(resp.FriendRequestList)
+	log.NewInfo(req.CommID.OperationID, "GetFriendApplyList api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetSelfFriendApplyList(c *gin.Context) {
+	params := api.GetSelfApplyListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetSelfApplyListReq{CommID: &rpc.CommID{}}
+	utils.CopyStructFields(req.CommID, &params)
+	var ok bool
+	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.CommID.OperationID, "GetSelfApplyList args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	RpcResp, err := client.GetSelfApplyList(context.Background(), req)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetSelfApplyList failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get self apply list rpc server failed"})
+		return
+	}
+	resp := api.GetSelfApplyListResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, FriendRequestList: RpcResp.FriendRequestList}
+	resp.Data = jsonData.JsonDataList(resp.FriendRequestList)
+	log.NewInfo(req.CommID.OperationID, "GetSelfApplyList api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/group/group.go

@@ -0,0 +1,698 @@
+package group
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	rpc "Open_IM/pkg/proto/group"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+
+	"github.com/gin-gonic/gin"
+
+	"net/http"
+	"strings"
+
+	jsonData "Open_IM/internal/utils"
+)
+
+func KickGroupMember(c *gin.Context) {
+	params := api.KickGroupMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.KickGroupMemberReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+
+	log.NewInfo(req.OperationID, "KickGroupMember args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.KickGroupMember(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupMemberList failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	var memberListResp api.KickGroupMemberResp
+	memberListResp.ErrMsg = RpcResp.ErrMsg
+	memberListResp.ErrCode = RpcResp.ErrCode
+	for _, v := range RpcResp.Id2ResultList {
+		memberListResp.UserIDResultList = append(memberListResp.UserIDResultList, &api.UserIDResult{UserID: v.UserID, Result: v.Result})
+	}
+	if len(memberListResp.UserIDResultList) == 0 {
+		memberListResp.UserIDResultList = []*api.UserIDResult{}
+	}
+
+	log.NewInfo(req.OperationID, "KickGroupMember api return ", memberListResp)
+	c.JSON(http.StatusOK, memberListResp)
+}
+
+func GetGroupMembersInfo(c *gin.Context) {
+	params := api.GetGroupMembersInfoReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetGroupMembersInfoReq{}
+	utils.CopyStructFields(req, params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		//c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		api.SetErrCodeMsg(c, http.StatusInternalServerError)
+		return
+	}
+	log.NewInfo(req.OperationID, "GetGroupMembersInfo args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+
+	RpcResp, err := client.GetGroupMembersInfo(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupMemberList failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	memberListResp := api.GetGroupMembersInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, MemberList: RpcResp.MemberList}
+	memberListResp.Data = jsonData.JsonDataList(RpcResp.MemberList)
+	log.NewInfo(req.OperationID, "GetGroupMembersInfo api return ", memberListResp)
+	c.JSON(http.StatusOK, memberListResp)
+}
+
+func GetGroupMemberList(c *gin.Context) {
+	params := api.GetGroupMemberListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetGroupMemberListReq{}
+	utils.CopyStructFields(req, params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "GetGroupMemberList args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+
+	RpcResp, err := client.GetGroupMemberList(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupMemberList failed, ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	memberListResp := api.GetGroupMemberListResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, MemberList: RpcResp.MemberList, NextSeq: RpcResp.NextSeq}
+	memberListResp.Data = jsonData.JsonDataList(memberListResp.MemberList)
+
+	log.NewInfo(req.OperationID, "GetGroupMemberList api return ", memberListResp)
+	c.JSON(http.StatusOK, memberListResp)
+}
+
+func GetGroupAllMemberList(c *gin.Context) {
+	params := api.GetGroupAllMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetGroupAllMemberReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "GetGroupAllMember args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.GetGroupAllMember(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupAllMember failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	memberListResp := api.GetGroupAllMemberResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, MemberList: RpcResp.MemberList}
+	memberListResp.Data = jsonData.JsonDataList(memberListResp.MemberList)
+	log.NewInfo(req.OperationID, "GetGroupAllMember api return ", memberListResp)
+	c.JSON(http.StatusOK, memberListResp)
+}
+
+func GetJoinedGroupList(c *gin.Context) {
+	params := api.GetJoinedGroupListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetJoinedGroupListReq{}
+	utils.CopyStructFields(req, params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "GetJoinedGroupList args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.GetJoinedGroupList(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetJoinedGroupList failed  ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	GroupListResp := api.GetJoinedGroupListResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, GroupInfoList: RpcResp.GroupList}
+	GroupListResp.Data = jsonData.JsonDataList(GroupListResp.GroupInfoList)
+	log.NewInfo(req.OperationID, "GetJoinedGroupList api return ", GroupListResp)
+	c.JSON(http.StatusOK, GroupListResp)
+}
+
+func InviteUserToGroup(c *gin.Context) {
+	params := api.InviteUserToGroupReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.InviteUserToGroupReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "InviteUserToGroup args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.InviteUserToGroup(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "InviteUserToGroup failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.InviteUserToGroupResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	for _, v := range RpcResp.Id2ResultList {
+		resp.UserIDResultList = append(resp.UserIDResultList, &api.UserIDResult{UserID: v.UserID, Result: v.Result})
+	}
+
+	if len(resp.UserIDResultList) == 0 {
+		resp.UserIDResultList = *new([]*api.UserIDResult)
+	}
+
+	log.NewInfo(req.OperationID, "InviteUserToGroup api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func CreateGroup(c *gin.Context) {
+	params := api.CreateGroupReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	//
+	req := &rpc.CreateGroupReq{GroupInfo: &open_im_sdk.GroupInfo{}}
+	utils.CopyStructFields(req.GroupInfo, &params)
+
+	for _, v := range params.MemberList {
+		req.InitMemberList = append(req.InitMemberList, &rpc.GroupAddMemberInfo{UserID: v.UserID, RoleLevel: v.RoleLevel})
+	}
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	req.OwnerUserID = params.OwnerUserID
+	req.OperationID = params.OperationID
+	log.NewInfo(req.OperationID, "CreateGroup args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.CreateGroup(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "CreateGroup failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+
+	resp := api.CreateGroupResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	if RpcResp.ErrCode == 0 {
+		utils.CopyStructFields(&resp.GroupInfo, RpcResp.GroupInfo)
+		resp.Data = jsonData.JsonDataOne(&resp.GroupInfo)
+	}
+	log.NewInfo(req.OperationID, "CreateGroup api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+//  群主或管理员收到的
+func GetRecvGroupApplicationList(c *gin.Context) {
+	params := api.GetGroupApplicationListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetGroupApplicationListReq{}
+	utils.CopyStructFields(req, params)
+	//var ok bool
+	//ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	//if !ok {
+	//	log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+	//	c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+	//	return
+	//}
+	log.NewInfo(req.OperationID, "GetGroupApplicationList args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.GetGroupApplicationList(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupApplicationList failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.GetGroupApplicationListResp{CommResp: api.CommResp{ErrCode: reply.ErrCode, ErrMsg: reply.ErrMsg}, GroupRequestList: reply.GroupRequestList}
+	resp.Data = jsonData.JsonDataList(resp.GroupRequestList)
+	log.NewInfo(req.OperationID, "GetGroupApplicationList api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetUserReqGroupApplicationList(c *gin.Context) {
+	var params api.GetUserReqGroupApplicationListReq
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetUserReqApplicationListReq{}
+	utils.CopyStructFields(req, params)
+	//ok, req.OpUserID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	//if !ok {
+	//	log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+	//	c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+	//	return
+	//}
+	log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.GetUserReqApplicationList(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupsInfo failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, RpcResp)
+	resp := api.GetGroupApplicationListResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, GroupRequestList: RpcResp.GroupRequestList}
+	log.NewInfo(req.OperationID, "GetGroupApplicationList api return ", resp)
+	resp.Data = jsonData.JsonDataList(resp.GroupRequestList)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetGroupsInfo(c *gin.Context) {
+	params := api.GetGroupInfoReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetGroupsInfoReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.GetGroupsInfo(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupsInfo failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+
+	resp := api.GetGroupInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, GroupInfoList: RpcResp.GroupInfoList}
+	resp.Data = jsonData.JsonDataList(resp.GroupInfoList)
+	log.NewInfo(req.OperationID, "GetGroupsInfo api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+//process application
+func ApplicationGroupResponse(c *gin.Context) {
+	params := api.ApplicationGroupResponseReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GroupApplicationResponseReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "ApplicationGroupResponse args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.GroupApplicationResponse(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GroupApplicationResponse failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.ApplicationGroupResponseResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, "ApplicationGroupResponse api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func JoinGroup(c *gin.Context) {
+	params := api.JoinGroupReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.JoinGroupReq{}
+	utils.CopyStructFields(req, params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "JoinGroup args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+
+	RpcResp, err := client.JoinGroup(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "JoinGroup failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	resp := api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}
+	log.NewInfo(req.OperationID, "JoinGroup api return", RpcResp.String())
+	c.JSON(http.StatusOK, resp)
+}
+
+func QuitGroup(c *gin.Context) {
+	params := api.QuitGroupReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.QuitGroupReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "QuitGroup args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.QuitGroup(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "call quit group rpc server failed,err=%s", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	resp := api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}
+	log.NewInfo(req.OperationID, "QuitGroup api return", RpcResp.String())
+	c.JSON(http.StatusOK, resp)
+}
+
+func SetGroupInfo(c *gin.Context) {
+	params := api.SetGroupInfoReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.SetGroupInfoReq{GroupInfo: &open_im_sdk.GroupInfo{}}
+	utils.CopyStructFields(req.GroupInfo, &params)
+	req.OperationID = params.OperationID
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "SetGroupInfo args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	RpcResp, err := client.SetGroupInfo(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "SetGroupInfo failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	resp := api.SetGroupInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	c.JSON(http.StatusOK, resp)
+	log.NewInfo(req.OperationID, "SetGroupInfo api return ", resp)
+}
+
+func TransferGroupOwner(c *gin.Context) {
+	params := api.TransferGroupOwnerReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.TransferGroupOwnerReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "TransferGroupOwner args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.TransferGroupOwner(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "TransferGroupOwner failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.TransferGroupOwnerResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, "TransferGroupOwner api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func DismissGroup(c *gin.Context) {
+	params := api.DismissGroupReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.DismissGroupReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.DismissGroup(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), " failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.DismissGroupResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func MuteGroupMember(c *gin.Context) {
+	params := api.MuteGroupMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.MuteGroupMemberReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.MuteGroupMember(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), " failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.MuteGroupMemberResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func CancelMuteGroupMember(c *gin.Context) {
+	params := api.CancelMuteGroupMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.CancelMuteGroupMemberReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.CancelMuteGroupMember(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), " failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.CancelMuteGroupMemberResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func MuteGroup(c *gin.Context) {
+	params := api.MuteGroupReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.MuteGroupReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.MuteGroup(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), " failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.MuteGroupResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func CancelMuteGroup(c *gin.Context) {
+	params := api.CancelMuteGroupReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.CancelMuteGroupReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.CancelMuteGroup(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), " failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.CancelMuteGroupResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/manage/management_chat.go

@@ -0,0 +1,296 @@
+/*
+** description("").
+** copyright('open-im,www.open-im.io').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/9/15 15:23).
+ */
+package manage
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/proto/sdk_ws"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+	"github.com/golang/protobuf/proto"
+	"github.com/mitchellh/mapstructure"
+	"net/http"
+	"strings"
+)
+
+var validate *validator.Validate
+
+func newUserSendMsgReq(params *ManagementSendMsgReq) *pbChat.SendMsgReq {
+	var newContent string
+	var err error
+	switch params.ContentType {
+	case constant.Text:
+		newContent = params.Content["text"].(string)
+	case constant.Picture:
+		fallthrough
+	case constant.Custom:
+		fallthrough
+	case constant.Voice:
+		fallthrough
+	case constant.File:
+		newContent = utils.StructToJsonString(params.Content)
+	case constant.Revoke:
+		newContent = params.Content["revokeMsgClientID"].(string)
+
+	default:
+	}
+	var options map[string]bool
+	if params.IsOnlineOnly {
+		options = make(map[string]bool, 5)
+		utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
+		utils.SetSwitchFromOptions(options, constant.IsHistory, false)
+		utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
+		utils.SetSwitchFromOptions(options, constant.IsSenderSync, false)
+	}
+	pbData := pbChat.SendMsgReq{
+		OperationID: params.OperationID,
+		MsgData: &open_im_sdk.MsgData{
+			SendID:           params.SendID,
+			RecvID:           params.RecvID,
+			GroupID:          params.GroupID,
+			ClientMsgID:      utils.GetMsgID(params.SendID),
+			SenderPlatformID: params.SenderPlatformID,
+			SenderNickname:   params.SenderNickname,
+			SenderFaceURL:    params.SenderFaceURL,
+			SessionType:      params.SessionType,
+			MsgFrom:          constant.SysMsgType,
+			ContentType:      params.ContentType,
+			Content:          []byte(newContent),
+			//	ForceList:        params.ForceList,
+			CreateTime:      utils.GetCurrentTimestampByMill(),
+			Options:         options,
+			OfflinePushInfo: params.OfflinePushInfo,
+		},
+	}
+	if params.ContentType == constant.OANotification {
+		var tips open_im_sdk.TipsComm
+		tips.JsonDetail = utils.StructToJsonString(params.Content)
+		pbData.MsgData.Content, err = proto.Marshal(&tips)
+		if err != nil {
+			log.Error(params.OperationID, "Marshal failed ", err.Error(), tips.String())
+		}
+	}
+	return &pbData
+}
+func init() {
+	validate = validator.New()
+}
+
+func ManagementSendMsg(c *gin.Context) {
+	var data interface{}
+	params := ManagementSendMsgReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		log.ErrorByKv("json unmarshal err", c.PostForm("operationID"), "err", err.Error(), "content", c.PostForm("content"))
+		return
+	}
+	switch params.ContentType {
+	case constant.Text:
+		data = TextElem{}
+	case constant.Picture:
+		data = PictureElem{}
+	case constant.Voice:
+		data = SoundElem{}
+	case constant.Video:
+		data = VideoElem{}
+	case constant.File:
+		data = FileElem{}
+	//case constant.AtText:
+	//	data = AtElem{}
+	//case constant.Merger:
+	//	data =
+	//case constant.Card:
+	//case constant.Location:
+	case constant.Custom:
+		data = CustomElem{}
+	case constant.Revoke:
+		data = RevokeElem{}
+	case constant.OANotification:
+		data = OANotificationElem{}
+		params.SessionType = constant.NotificationChatType
+	//case constant.HasReadReceipt:
+	//case constant.Typing:
+	//case constant.Quote:
+	default:
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 404, "errMsg": "contentType err"})
+		log.ErrorByKv("contentType err", c.PostForm("operationID"), "content", c.PostForm("content"))
+		return
+	}
+	if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": err.Error()})
+		log.ErrorByKv("content to Data struct  err", "", "err", err.Error())
+		return
+	} else if err := validate.Struct(data); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 403, "errMsg": err.Error()})
+		log.ErrorByKv("data args validate  err", "", "err", err.Error())
+		return
+	}
+	log.NewInfo("", data, params)
+	token := c.Request.Header.Get("token")
+	claims, err := token_verify.ParseToken(token, params.OperationID)
+	if err != nil {
+		log.NewError(params.OperationID, "parse token failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "parse token failed", "sendTime": 0, "MsgID": ""})
+		return
+	}
+	if !utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "not authorized", "sendTime": 0, "MsgID": ""})
+		return
+
+	}
+	switch params.SessionType {
+	case constant.SingleChatType:
+		if len(params.RecvID) == 0 {
+			log.NewError(params.OperationID, "recvID is a null string")
+			c.JSON(http.StatusBadRequest, gin.H{"errCode": 405, "errMsg": "recvID is a null string", "sendTime": 0, "MsgID": ""})
+			return
+		}
+	case constant.GroupChatType:
+		if len(params.GroupID) == 0 {
+			log.NewError(params.OperationID, "groupID is a null string")
+			c.JSON(http.StatusBadRequest, gin.H{"errCode": 405, "errMsg": "groupID is a null string", "sendTime": 0, "MsgID": ""})
+			return
+		}
+
+	}
+	log.InfoByKv("Ws call success to ManagementSendMsgReq", params.OperationID, "Parameters", params)
+
+	pbData := newUserSendMsgReq(&params)
+	log.Info("", "", "api ManagementSendMsg call start..., [data: %s]", pbData.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	client := pbChat.NewChatClient(etcdConn)
+
+	log.Info("", "", "api ManagementSendMsg call, api call rpc...")
+
+	RpcResp, err := client.SendMsg(context.Background(), pbData)
+	if err != nil {
+		log.NewError(params.OperationID, "call delete UserSendMsg rpc server failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call UserSendMsg  rpc server failed"})
+		return
+	}
+	log.Info("", "", "api ManagementSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), RpcResp.String())
+	resp := api.ManagementSendMsgResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, ResultList: server_api_params.UserSendMsgResp{ServerMsgID: RpcResp.ServerMsgID, ClientMsgID: RpcResp.ClientMsgID, SendTime: RpcResp.SendTime}}
+	log.Info(params.OperationID, "ManagementSendMsg return", resp)
+	c.JSON(http.StatusOK, resp)
+
+}
+
+//
+//type MergeElem struct {
+//	Title        string       `json:"title"`
+//	AbstractList []string     `json:"abstractList"`
+//	MultiMessage []*MsgStruct `json:"multiMessage"`
+//}
+//
+//type QuoteElem struct {
+//	Text         string     `json:"text"`
+//	QuoteMessage *MsgStruct `json:"quoteMessage"`
+//}
+type ManagementSendMsgReq struct {
+	OperationID      string                       `json:"operationID" binding:"required"`
+	SendID           string                       `json:"sendID" binding:"required"`
+	RecvID           string                       `json:"recvID" `
+	GroupID          string                       `json:"groupID" `
+	SenderNickname   string                       `json:"senderNickname" `
+	SenderFaceURL    string                       `json:"senderFaceURL" `
+	SenderPlatformID int32                        `json:"senderPlatformID"`
+	ForceList        []string                     `json:"forceList" `
+	Content          map[string]interface{}       `json:"content" binding:"required"`
+	ContentType      int32                        `json:"contentType" binding:"required"`
+	SessionType      int32                        `json:"sessionType" binding:"required"`
+	IsOnlineOnly     bool                         `json:"isOnlineOnly"`
+	OfflinePushInfo  *open_im_sdk.OfflinePushInfo `json:"offlinePushInfo"`
+}
+
+type PictureBaseInfo struct {
+	UUID   string `mapstructure:"uuid"`
+	Type   string `mapstructure:"type" `
+	Size   int64  `mapstructure:"size" `
+	Width  int32  `mapstructure:"width" `
+	Height int32  `mapstructure:"height"`
+	Url    string `mapstructure:"url" `
+}
+
+type PictureElem struct {
+	SourcePath      string          `mapstructure:"sourcePath"`
+	SourcePicture   PictureBaseInfo `mapstructure:"sourcePicture"`
+	BigPicture      PictureBaseInfo `mapstructure:"bigPicture" `
+	SnapshotPicture PictureBaseInfo `mapstructure:"snapshotPicture"`
+}
+type SoundElem struct {
+	UUID      string `mapstructure:"uuid"`
+	SoundPath string `mapstructure:"soundPath"`
+	SourceURL string `mapstructure:"sourceUrl"`
+	DataSize  int64  `mapstructure:"dataSize"`
+	Duration  int64  `mapstructure:"duration"`
+}
+type VideoElem struct {
+	VideoPath      string `mapstructure:"videoPath"`
+	VideoUUID      string `mapstructure:"videoUUID"`
+	VideoURL       string `mapstructure:"videoUrl"`
+	VideoType      string `mapstructure:"videoType"`
+	VideoSize      int64  `mapstructure:"videoSize"`
+	Duration       int64  `mapstructure:"duration"`
+	SnapshotPath   string `mapstructure:"snapshotPath"`
+	SnapshotUUID   string `mapstructure:"snapshotUUID"`
+	SnapshotSize   int64  `mapstructure:"snapshotSize"`
+	SnapshotURL    string `mapstructure:"snapshotUrl"`
+	SnapshotWidth  int32  `mapstructure:"snapshotWidth"`
+	SnapshotHeight int32  `mapstructure:"snapshotHeight"`
+}
+type FileElem struct {
+	FilePath  string `mapstructure:"filePath"`
+	UUID      string `mapstructure:"uuid"`
+	SourceURL string `mapstructure:"sourceUrl"`
+	FileName  string `mapstructure:"fileName"`
+	FileSize  int64  `mapstructure:"fileSize"`
+}
+type AtElem struct {
+	Text       string   `mapstructure:"text"`
+	AtUserList []string `mapstructure:"atUserList"`
+	IsAtSelf   bool     `mapstructure:"isAtSelf"`
+}
+type LocationElem struct {
+	Description string  `mapstructure:"description"`
+	Longitude   float64 `mapstructure:"longitude"`
+	Latitude    float64 `mapstructure:"latitude"`
+}
+type CustomElem struct {
+	Data        string `mapstructure:"data" validate:"required"`
+	Description string `mapstructure:"description"`
+	Extension   string `mapstructure:"extension"`
+}
+type TextElem struct {
+	Text string `mapstructure:"text" validate:"required"`
+}
+
+type RevokeElem struct {
+	RevokeMsgClientID string `mapstructure:"revokeMsgClientID" validate:"required"`
+}
+type OANotificationElem struct {
+	NotificationName    string      `mapstructure:"notificationName" validate:"required"`
+	NotificationFaceURL string      `mapstructure:"notificationFaceURL" validate:"required"`
+	NotificationType    int32       `mapstructure:"notificationType" validate:"required"`
+	Text                string      `mapstructure:"text" validate:"required"`
+	Url                 string      `mapstructure:"url"`
+	MixType             int32       `mapstructure:"mixType"`
+	PictureElem         PictureElem `mapstructure:"pictureElem"`
+	SoundElem           SoundElem   `mapstructure:"soundElem"`
+	VideoElem           VideoElem   `mapstructure:"videoElem"`
+	FileElem            FileElem    `mapstructure:"fileElem"`
+	Ex                  string      `mapstructure:"ex"`
+}

internal/api/manage/management_user.go

@@ -0,0 +1,180 @@
+/*
+** description("").
+** copyright('open-im,www.open-im.io').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/9/15 10:28).
+ */
+package manage
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbRelay "Open_IM/pkg/proto/relay"
+	rpc "Open_IM/pkg/proto/user"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func DeleteUser(c *gin.Context) {
+	params := api.DeleteUsersReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.DeleteUsersReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "DeleteUser args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := rpc.NewUserClient(etcdConn)
+
+	RpcResp, err := client.DeleteUsers(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "call delete users rpc server failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call delete users rpc server failed"})
+		return
+	}
+	resp := api.DeleteUsersResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, FailedUserIDList: RpcResp.FailedUserIDList}
+	if len(RpcResp.FailedUserIDList) == 0 {
+		resp.FailedUserIDList = []string{}
+	}
+	log.NewInfo(req.OperationID, "DeleteUser api return", resp)
+	c.JSON(http.StatusOK, resp)
+}
+func GetAllUsersUid(c *gin.Context) {
+	params := api.GetAllUsersUidReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetAllUserIDReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "GetAllUsersUid args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := rpc.NewUserClient(etcdConn)
+	RpcResp, err := client.GetAllUserID(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "call GetAllUsersUid users rpc server failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call GetAllUsersUid users rpc server failed"})
+		return
+	}
+	resp := api.GetAllUsersUidResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, UserIDList: RpcResp.UserIDList}
+	if len(RpcResp.UserIDList) == 0 {
+		resp.UserIDList = []string{}
+	}
+	log.NewInfo(req.OperationID, "GetAllUsersUid api return", resp)
+	c.JSON(http.StatusOK, resp)
+
+}
+func AccountCheck(c *gin.Context) {
+	params := api.AccountCheckReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.AccountCheckReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "AccountCheck args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := rpc.NewUserClient(etcdConn)
+
+	RpcResp, err := client.AccountCheck(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "call AccountCheck users rpc server failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call AccountCheck users rpc server failed"})
+		return
+	}
+	resp := api.AccountCheckResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, ResultList: RpcResp.ResultList}
+	if len(RpcResp.ResultList) == 0 {
+		resp.ResultList = []*rpc.AccountCheckResp_SingleUserStatus{}
+	}
+	log.NewInfo(req.OperationID, "AccountCheck api return", resp)
+	c.JSON(http.StatusOK, resp)
+}
+func GetUsersOnlineStatus(c *gin.Context) {
+	params := api.GetUsersOnlineStatusReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbRelay.GetUsersOnlineStatusReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "GetUsersOnlineStatus args ", req.String())
+	var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
+	var respResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
+	flag := false
+	grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
+	for _, v := range grpcCons {
+		client := pbRelay.NewOnlineMessageRelayServiceClient(v)
+		reply, err := client.GetUsersOnlineStatus(context.Background(), req)
+		if err != nil {
+			log.NewError(params.OperationID, "GetUsersOnlineStatus rpc  err", req.String(), err.Error())
+			continue
+		} else {
+			if reply.ErrCode == 0 {
+				wsResult = append(wsResult, reply.SuccessResult...)
+			}
+		}
+	}
+	log.NewInfo(params.OperationID, "call GetUsersOnlineStatus rpc server is success", wsResult)
+	//Online data merge of each node
+	for _, v1 := range params.UserIDList {
+		flag = false
+		temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult)
+		for _, v2 := range wsResult {
+			if v2.UserID == v1 {
+				flag = true
+				temp.UserID = v1
+				temp.Status = constant.OnlineStatus
+				temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, v2.DetailPlatformStatus...)
+			}
+
+		}
+		if !flag {
+			temp.UserID = v1
+			temp.Status = constant.OfflineStatus
+		}
+		respResult = append(respResult, temp)
+	}
+	resp := api.GetUsersOnlineStatusResp{CommResp: api.CommResp{ErrCode: 0, ErrMsg: ""}, SuccessResult: respResult}
+	if len(respResult) == 0 {
+		resp.SuccessResult = []*pbRelay.GetUsersOnlineStatusResp_SuccessResult{}
+	}
+	log.NewInfo(req.OperationID, "GetUsersOnlineStatus api return", resp)
+	c.JSON(http.StatusOK, resp)
+
+}

internal/api/office/tag.go

@@ -0,0 +1,280 @@
+package office
+
+import (
+	apistruct "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbOffice "Open_IM/pkg/proto/office"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func GetUserTags(c *gin.Context) {
+	var (
+		req    apistruct.GetUserTagsReq
+		resp   apistruct.GetUserTagsResp
+		reqPb  pbOffice.GetUserTagsReq
+		respPb *pbOffice.GetUserTagsResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.UserID = userID
+	reqPb.OperationID = req.OperationID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.GetUserTags(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTags failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserTags rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp.CommResp, respPb.CommonResp); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	if respPb.Tags != nil {
+		resp.Data.Tags = respPb.Tags
+	} else {
+		resp.Data.Tags = []*pbOffice.Tag{}
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+func CreateTag(c *gin.Context) {
+	var (
+		req    apistruct.CreateTagReq
+		resp   apistruct.CreateTagResp
+		reqPb  pbOffice.CreateTagReq
+		respPb *pbOffice.CreateTagResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.CreateTag(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTags failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CreateTag rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp.CommResp, respPb.CommonResp); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+func DeleteTag(c *gin.Context) {
+	var (
+		req    apistruct.DeleteTagReq
+		resp   apistruct.DeleteTagResp
+		reqPb  pbOffice.DeleteTagReq
+		respPb *pbOffice.DeleteTagResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.DeleteTag(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTags failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CreateTag rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp.CommResp, respPb.CommonResp); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+func SetTag(c *gin.Context) {
+	var (
+		req    apistruct.SetTagReq
+		resp   apistruct.SetTagResp
+		reqPb  pbOffice.SetTagReq
+		respPb *pbOffice.SetTagResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.SetTag(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTags failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CreateTag rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp.CommResp, respPb.CommonResp); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+func SendMsg2Tag(c *gin.Context) {
+	var (
+		req    apistruct.SendMsg2TagReq
+		resp   apistruct.SendMsg2TagResp
+		reqPb  pbOffice.SendMsg2TagReq
+		respPb *pbOffice.SendMsg2TagResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.SendID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.SendMsg2Tag(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTags failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CreateTag rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp.CommResp, respPb.CommonResp); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetTagSendLogs(c *gin.Context) {
+	var (
+		req    apistruct.GetTagSendLogsReq
+		resp   apistruct.GetTagSendLogsResp
+		reqPb  pbOffice.GetTagSendLogsReq
+		respPb *pbOffice.GetTagSendLogsResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.UserID = userID
+	reqPb.OperationID = req.OperationID
+	reqPb.Pagination = &pbCommon.RequestPagination{
+		PageNumber: req.PageNumber,
+		ShowNumber: req.ShowNumber,
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.GetTagSendLogs(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTags failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CreateTag rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp.CommResp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	if respPb.TagSendLogs != nil {
+		resp.Data.Logs = respPb.TagSendLogs
+	} else {
+		resp.Data.Logs = []*pbOffice.TagSendLog{}
+	}
+	resp.Data.ShowNumber = respPb.Pagination.ShowNumber
+	resp.Data.CurrentPage = respPb.Pagination.CurrentPage
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetUserTagByID(c *gin.Context) {
+	var (
+		req    apistruct.GetUserTagByIDReq
+		resp   apistruct.GetUserTagByIDResp
+		reqPb  pbOffice.GetUserTagByIDReq
+		respPb *pbOffice.GetUserTagByIDResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.UserID = userID
+	reqPb.OperationID = req.OperationID
+	reqPb.TagID = req.TagID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.GetUserTagByID(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserTagByID failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CreateTag rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp.CommResp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	resp.Data.Tag = respPb.Tag
+	c.JSON(http.StatusOK, resp)
+}

internal/api/office/work_moments.go

@@ -0,0 +1,371 @@
+package office
+
+import (
+	apiStruct "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbOffice "Open_IM/pkg/proto/office"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func CreateOneWorkMoment(c *gin.Context) {
+	var (
+		req    apiStruct.CreateOneWorkMomentReq
+		resp   apiStruct.CreateOneWorkMomentResp
+		reqPb  pbOffice.CreateOneWorkMomentReq
+		respPb *pbOffice.CreateOneWorkMomentResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.CreateOneWorkMoment(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CreateOneWorkMoment rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CreateOneWorkMoment rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func DeleteOneWorkMoment(c *gin.Context) {
+	var (
+		req    apiStruct.DeleteOneWorkMomentReq
+		resp   apiStruct.DeleteOneWorkMomentResp
+		reqPb  pbOffice.DeleteOneWorkMomentReq
+		respPb *pbOffice.DeleteOneWorkMomentResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.DeleteOneWorkMoment(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DeleteOneWorkMoment rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "DeleteOneWorkMoment rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func LikeOneWorkMoment(c *gin.Context) {
+	var (
+		req    apiStruct.LikeOneWorkMomentReq
+		resp   apiStruct.LikeOneWorkMomentResp
+		reqPb  pbOffice.LikeOneWorkMomentReq
+		respPb *pbOffice.LikeOneWorkMomentResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.LikeOneWorkMoment(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "LikeOneWorkMoment rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "LikeOneWorkMoment rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func CommentOneWorkMoment(c *gin.Context) {
+	var (
+		req    apiStruct.CommentOneWorkMomentReq
+		resp   apiStruct.CommentOneWorkMomentResp
+		reqPb  pbOffice.CommentOneWorkMomentReq
+		respPb *pbOffice.CommentOneWorkMomentResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.CommentOneWorkMoment(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CommentOneWorkMoment rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CommentOneWorkMoment rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetUserWorkMoments(c *gin.Context) {
+	var (
+		req    apiStruct.GetUserWorkMomentsReq
+		resp   apiStruct.GetUserWorkMomentsResp
+		reqPb  pbOffice.GetUserWorkMomentsReq
+		respPb *pbOffice.GetUserWorkMomentsResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.OperationID = req.OperationID
+	reqPb.Pagination = &pbCommon.RequestPagination{
+		PageNumber: req.PageNumber,
+		ShowNumber: req.ShowNumber,
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.GetUserWorkMoments(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserWorkMoments rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserWorkMoments rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	resp.Data.WorkMoments = respPb.WorkMoments
+	resp.Data.ShowNumber = respPb.Pagination.ShowNumber
+	resp.Data.CurrentPage = respPb.Pagination.CurrentPage
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetUserFriendWorkMoments(c *gin.Context) {
+	var (
+		req    apiStruct.GetUserFriendWorkMomentsReq
+		resp   apiStruct.GetUserFriendWorkMomentsResp
+		reqPb  pbOffice.GetUserFriendWorkMomentsReq
+		respPb *pbOffice.GetUserFriendWorkMomentsResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.OperationID = req.OperationID
+	reqPb.Pagination = &pbCommon.RequestPagination{
+		PageNumber: req.PageNumber,
+		ShowNumber: req.ShowNumber,
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.GetUserFriendWorkMoments(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserFriendWorkMoments rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserFriendWorkMoments rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	resp.Data.WorkMoments = respPb.WorkMoments
+	resp.Data.ShowNumber = respPb.Pagination.ShowNumber
+	resp.Data.CurrentPage = respPb.Pagination.CurrentPage
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetUserWorkMomentsCommentsMsg(c *gin.Context) {
+	var (
+		req    apiStruct.GetUserWorkMomentsCommentsMsgReq
+		resp   apiStruct.GetUserWorkMomentsCommentsMsgResp
+		reqPb  pbOffice.GetUserWorkMomentsCommentsMsgReq
+		respPb *pbOffice.GetUserWorkMomentsCommentsMsgResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.OperationID = req.OperationID
+	reqPb.Pagination = &pbCommon.RequestPagination{
+		PageNumber: req.PageNumber,
+		ShowNumber: req.ShowNumber,
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.GetUserWorkMomentsCommentsMsg(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserWorkMomentsCommentsMsg rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserWorkMomentsCommentsMsg rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	resp.Data.CurrentPage = respPb.Pagination.CurrentPage
+	resp.Data.ShowNumber = respPb.Pagination.ShowNumber
+	resp.Data.CommentMsgs = respPb.CommentsMsgs
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func SetUserWorkMomentsLevel(c *gin.Context) {
+	var (
+		req    apiStruct.SetUserWorkMomentsLevelReq
+		resp   apiStruct.SetUserWorkMomentsLevelResp
+		reqPb  pbOffice.SetUserWorkMomentsLevelReq
+		respPb *pbOffice.SetUserWorkMomentsLevelResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.SetUserWorkMomentsLevel(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetUserWorkMomentsLevel rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "SetUserWorkMomentsLevel rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func ClearUserWorkMomentsCommentsMsg(c *gin.Context) {
+	var (
+		req    apiStruct.ClearUserWorkMomentsCommentsMsgReq
+		resp   apiStruct.ClearUserWorkMomentsCommentsMsgResp
+		reqPb  pbOffice.ClearUserWorkMomentsCommentsMsgReq
+		respPb *pbOffice.ClearUserWorkMomentsCommentsMsgResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.UserID = userID
+	reqPb.OperationID = req.OperationID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.ClearUserWorkMomentsCommentsMsg(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "ClearUserWorkMomentsCommentsMsg rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "ClearUserWorkMomentsCommentsMsg rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/organization/organization.go

@@ -0,0 +1,439 @@
+package organization
+
+import (
+	jsonData "Open_IM/internal/utils"
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	rpc "Open_IM/pkg/proto/organization"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func CreateDepartment(c *gin.Context) {
+	params := api.CreateDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.CreateDepartmentReq{DepartmentInfo: &open_im_sdk.Department{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.DepartmentInfo, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + " " + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.CreateDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc CreateDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.CreateDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, Department: RpcResp.DepartmentInfo}
+	apiResp.Data = jsonData.JsonDataOne(RpcResp.DepartmentInfo)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func UpdateDepartment(c *gin.Context) {
+	params := api.UpdateDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.UpdateDepartmentReq{DepartmentInfo: &open_im_sdk.Department{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.DepartmentInfo, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.UpdateDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc UpdateDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.UpdateDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func GetSubDepartment(c *gin.Context) {
+	params := api.GetSubDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetSubDepartmentReq{}
+	utils.CopyStructFields(req, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.GetSubDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc GetDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.GetSubDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, DepartmentList: RpcResp.DepartmentList}
+	apiResp.Data = jsonData.JsonDataList(RpcResp.DepartmentList)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func DeleteDepartment(c *gin.Context) {
+	params := api.DeleteDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.DeleteDepartmentReq{}
+	utils.CopyStructFields(req, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.DeleteDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc DeleteDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.DeleteDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func CreateOrganizationUser(c *gin.Context) {
+	params := api.CreateOrganizationUserReq{OrganizationUser: &open_im_sdk.OrganizationUser{}}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.CreateOrganizationUserReq{OrganizationUser: &open_im_sdk.OrganizationUser{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.OrganizationUser, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.CreateOrganizationUser(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc CreateOrganizationUser failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.CreateOrganizationUserResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func UpdateOrganizationUser(c *gin.Context) {
+	params := api.UpdateOrganizationUserReq{OrganizationUser: &open_im_sdk.OrganizationUser{}}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.UpdateOrganizationUserReq{OrganizationUser: &open_im_sdk.OrganizationUser{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.OrganizationUser, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.UpdateOrganizationUser(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc UpdateOrganizationUser failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.UpdateOrganizationUserResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func CreateDepartmentMember(c *gin.Context) {
+	params := api.CreateDepartmentMemberReq{UserInDepartment: &open_im_sdk.UserInDepartment{}}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.CreateDepartmentMemberReq{UserInDepartment: &open_im_sdk.UserInDepartment{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.UserInDepartment, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.CreateDepartmentMember(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc CreateDepartmentMember failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.CreateDepartmentMemberResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func GetUserInDepartment(c *gin.Context) {
+	params := api.GetUserInDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.GetUserInDepartmentReq{}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.GetUserInDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc GetUserInDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.GetUserInDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, UserInDepartment: RpcResp.UserInDepartment}
+	apiResp.Data = jsonData.JsonDataOne(RpcResp.UserInDepartment)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func UpdateUserInDepartment(c *gin.Context) {
+	params := api.UpdateUserInDepartmentReq{DepartmentMember: &open_im_sdk.DepartmentMember{}}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.UpdateUserInDepartmentReq{DepartmentMember: &open_im_sdk.DepartmentMember{}}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.UpdateUserInDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc UpdateUserInDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.UpdateUserInDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func DeleteOrganizationUser(c *gin.Context) {
+	params := api.DeleteOrganizationUserReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.DeleteOrganizationUserReq{}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.DeleteOrganizationUser(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc DeleteOrganizationUser failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.DeleteOrganizationUserResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func GetDepartmentMember(c *gin.Context) {
+	params := api.GetDepartmentMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.GetDepartmentMemberReq{}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.GetDepartmentMember(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc GetDepartmentMember failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.GetDepartmentMemberResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, UserInDepartmentList: RpcResp.UserInDepartmentList}
+	apiResp.Data = jsonData.JsonDataList(RpcResp.UserInDepartmentList)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func DeleteUserInDepartment(c *gin.Context) {
+	params := api.DeleteUserInDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.DeleteUserInDepartmentReq{}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.DeleteUserInDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc DeleteUserInDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.GetDepartmentMemberResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}

internal/api/third/ali_oss_credential.go

@@ -0,0 +1,95 @@
+package apiThird
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"fmt"
+	openapi "github.com/alibabacloud-go/darabonba-openapi/client"
+	sts20150401 "github.com/alibabacloud-go/sts-20150401/client"
+	"github.com/alibabacloud-go/tea/tea"
+	"github.com/fatih/structs"
+
+	//"github.com/fatih/structs"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"time"
+)
+
+var stsClient *sts20150401.Client
+
+/**
+ * 使用AK&SK初始化账号Client
+ * @param accessKeyId
+ * @param accessKeySecret
+ * @return Client
+ * @throws Exception
+ */
+func getStsClient() *sts20150401.Client {
+	if stsClient != nil {
+		return stsClient
+	}
+	conf := &openapi.Config{
+		// 您的AccessKey ID
+		AccessKeyId: tea.String(config.Config.Credential.Ali.AccessKeyID),
+		// 您的AccessKey Secret
+		AccessKeySecret: tea.String(config.Config.Credential.Ali.AccessKeySecret),
+		// Endpoint
+		Endpoint: tea.String(config.Config.Credential.Ali.StsEndpoint),
+	}
+	result, err := sts20150401.NewClient(conf)
+	if err != nil {
+		log.NewError("", "alists client初始化失败 ", err)
+	}
+	stsClient = result
+	return stsClient
+}
+
+func AliOSSCredential(c *gin.Context) {
+	req := api.OSSCredentialReq{}
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "AliOSSCredential args ", userID)
+
+	stsResp, err := getStsClient().AssumeRole(&sts20150401.AssumeRoleRequest{
+		DurationSeconds: tea.Int64(config.Config.Credential.Ali.StsDurationSeconds),
+		Policy:          nil,
+		RoleArn:         tea.String(config.Config.Credential.Ali.OssRoleArn),
+		RoleSessionName: tea.String(fmt.Sprintf("%s-%d", userID, time.Now().Unix())),
+	})
+
+	resp := api.OSSCredentialResp{}
+	if err != nil {
+		resp.ErrCode = constant.ErrTencentCredential.ErrCode
+		resp.ErrMsg = err.Error()
+	} else {
+		resp = api.OSSCredentialResp{
+			CommResp: api.CommResp{},
+			OssData: api.OSSCredentialRespData{
+				Endpoint:        config.Config.Credential.Ali.OssEndpoint,
+				AccessKeyId:     *stsResp.Body.Credentials.AccessKeyId,
+				AccessKeySecret: *stsResp.Body.Credentials.AccessKeySecret,
+				Token:           *stsResp.Body.Credentials.SecurityToken,
+				Bucket:          config.Config.Credential.Ali.Bucket,
+				FinalHost:       config.Config.Credential.Ali.FinalHost,
+			},
+			Data: nil,
+		}
+	}
+
+	resp.Data = structs.Map(&resp.OssData)
+	log.NewInfo(req.OperationID, "AliOSSCredential return ", resp)
+
+	c.JSON(http.StatusOK, resp)
+}

internal/api/third/minio_init.go

@@ -0,0 +1,67 @@
+package apiThird
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	url2 "net/url"
+)
+
+var (
+	minioClient *minio.Client
+)
+
+func MinioInit() {
+	operationID := utils.OperationIDGenerator()
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "minio config: ", config.Config.Credential.Minio)
+	var initUrl string
+	if config.Config.Credential.Minio.EndpointInnerEnable {
+		initUrl = config.Config.Credential.Minio.EndpointInner
+	} else {
+		initUrl = config.Config.Credential.Minio.Endpoint
+	}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "use initUrl: ", initUrl)
+	minioUrl, err := url2.Parse(initUrl)
+	if err != nil {
+		log.NewError(operationID, utils.GetSelfFuncName(), "parse failed, please check config/config.yaml", err.Error())
+		return
+	}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "Parse ok ", config.Config.Credential.Minio)
+	minioClient, err = minio.New(minioUrl.Host, &minio.Options{
+		Creds:  credentials.NewStaticV4(config.Config.Credential.Minio.AccessKeyID, config.Config.Credential.Minio.SecretAccessKey, ""),
+		Secure: false,
+	})
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "new ok ", config.Config.Credential.Minio)
+	if err != nil {
+		log.NewError(operationID, utils.GetSelfFuncName(), "init minio client failed", err.Error())
+		return
+	}
+	opt := minio.MakeBucketOptions{
+		Region:        config.Config.Credential.Minio.Location,
+		ObjectLocking: false,
+	}
+	err = minioClient.MakeBucket(context.Background(), config.Config.Credential.Minio.Bucket, opt)
+	if err != nil {
+		log.NewError(operationID, utils.GetSelfFuncName(), "MakeBucket failed ", err.Error())
+		exists, err := minioClient.BucketExists(context.Background(), config.Config.Credential.Minio.Bucket)
+		if err == nil && exists {
+			log.NewWarn(operationID, utils.GetSelfFuncName(), "We already own ", config.Config.Credential.Minio.Bucket)
+		} else {
+			if err != nil {
+				log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
+			}
+			log.NewError(operationID, utils.GetSelfFuncName(), "create bucket failed and bucket not exists")
+			return
+		}
+	}
+	// 自动化桶public的代码
+	//err = minioClient.SetBucketPolicy(context.Background(), config.Config.Credential.Minio.Bucket, policy.BucketPolicyReadWrite)
+	//if err != nil {
+	//	log.NewError("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
+	//	return
+	//}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "minio create and set policy success")
+}

internal/api/third/minio_storage_credential.go

@@ -0,0 +1,138 @@
+package apiThird
+
+import (
+	apiStruct "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	_ "Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"github.com/minio/minio-go/v7"
+	_ "github.com/minio/minio-go/v7"
+	cr "github.com/minio/minio-go/v7/pkg/credentials"
+	"net/http"
+)
+
+func MinioUploadFile(c *gin.Context) {
+	var (
+		req  apiStruct.MinioUploadFileReq
+		resp apiStruct.MinioUploadFileResp
+	)
+	defer func() {
+		if r := recover(); r != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), r)
+			c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "missing file or snapShot args"})
+			return
+		}
+	}()
+	if err := c.Bind(&req); err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	ok, _ := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError("", utils.GetSelfFuncName(), "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
+	switch req.FileType {
+	// videoType upload snapShot
+	case constant.VideoType:
+		snapShotFile, err := c.FormFile("snapShot")
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "missing snapshot arg: " + err.Error()})
+			return
+		}
+		snapShotFileObj, err := snapShotFile.Open()
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "Open file error", err.Error())
+			c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+			return
+		}
+		snapShotNewName, snapShotNewType := utils.GetNewFileNameAndContentType(snapShotFile.Filename, constant.ImageType)
+		log.Debug(req.OperationID, utils.GetSelfFuncName(), snapShotNewName, snapShotNewType)
+		_, err = minioClient.PutObject(context.Background(), config.Config.Credential.Minio.Bucket, snapShotNewName, snapShotFileObj, snapShotFile.Size, minio.PutObjectOptions{ContentType: snapShotNewType})
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "PutObject snapShotFile error", err.Error())
+			c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+			return
+		}
+		resp.SnapshotURL = config.Config.Credential.Minio.Endpoint + "/" + config.Config.Credential.Minio.Bucket + "/" + snapShotNewName
+		resp.SnapshotNewName = snapShotNewName
+	}
+	file, err := c.FormFile("file")
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "missing file arg: " + err.Error()})
+		return
+	}
+	fileObj, err := file.Open()
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "Open file error", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "invalid file path" + err.Error()})
+		return
+	}
+	newName, newType := utils.GetNewFileNameAndContentType(file.Filename, req.FileType)
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), newName, newType)
+	_, err = minioClient.PutObject(context.Background(), config.Config.Credential.Minio.Bucket, newName, fileObj, file.Size, minio.PutObjectOptions{ContentType: newType})
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "open file error")
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "invalid file path" + err.Error()})
+		return
+	}
+	resp.NewName = newName
+	resp.URL = config.Config.Credential.Minio.Endpoint + "/" + config.Config.Credential.Minio.Bucket + "/" + newName
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
+	return
+}
+
+func MinioStorageCredential(c *gin.Context) {
+	var (
+		req  apiStruct.MinioStorageCredentialReq
+		resp apiStruct.MiniostorageCredentialResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	ok, _ := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError("", utils.GetSelfFuncName(), "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	var stsOpts cr.STSAssumeRoleOptions
+	stsOpts.AccessKey = config.Config.Credential.Minio.AccessKeyID
+	stsOpts.SecretKey = config.Config.Credential.Minio.SecretAccessKey
+	stsOpts.DurationSeconds = constant.MinioDurationTimes
+	var endpoint string
+	if config.Config.Credential.Minio.EndpointInnerEnable {
+		endpoint = config.Config.Credential.Minio.EndpointInner
+	} else {
+		endpoint = config.Config.Credential.Minio.Endpoint
+	}
+	li, err := cr.NewSTSAssumeRole(endpoint, stsOpts)
+	if err != nil {
+		log.NewError("", utils.GetSelfFuncName(), "NewSTSAssumeRole failed", err.Error(), stsOpts, config.Config.Credential.Minio.Endpoint)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	v, err := li.Get()
+	if err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "li.Get error", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	resp.SessionToken = v.SessionToken
+	resp.SecretAccessKey = v.SecretAccessKey
+	resp.AccessKeyID = v.AccessKeyID
+	resp.BucketName = config.Config.Credential.Minio.Bucket
+	resp.StsEndpointURL = config.Config.Credential.Minio.Endpoint
+	c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
+}

internal/api/third/tencent_cloud_storage_credential.go

@@ -0,0 +1,72 @@
+package apiThird
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"github.com/fatih/structs"
+
+	//"github.com/fatih/structs"
+	"github.com/gin-gonic/gin"
+	sts "github.com/tencentyun/qcloud-cos-sts-sdk/go"
+	"net/http"
+	"time"
+)
+
+func TencentCloudStorageCredential(c *gin.Context) {
+	req := api.TencentCloudStorageCredentialReq{}
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, "TencentCloudStorageCredential args ", userID)
+
+	cli := sts.NewClient(
+		config.Config.Credential.Tencent.SecretID,
+		config.Config.Credential.Tencent.SecretKey,
+		nil,
+	)
+
+	opt := &sts.CredentialOptions{
+		DurationSeconds: int64(time.Hour.Seconds()),
+		Region:          config.Config.Credential.Tencent.Region,
+		Policy: &sts.CredentialPolicy{
+			Statement: []sts.CredentialPolicyStatement{
+				{
+					Action: []string{
+						"name/cos:PostObject",
+						"name/cos:PutObject",
+					},
+					Effect: "allow",
+					Resource: []string{
+						"qcs::cos:" + config.Config.Credential.Tencent.Region + ":uid/" + config.Config.Credential.Tencent.AppID + ":" + config.Config.Credential.Tencent.Bucket + "/*",
+					},
+				},
+			},
+		},
+	}
+	res, err := cli.GetCredential(opt)
+	resp := api.TencentCloudStorageCredentialResp{}
+	if err != nil {
+		resp.ErrCode = constant.ErrTencentCredential.ErrCode
+		resp.ErrMsg = err.Error()
+	} else {
+		resp.CosData.Bucket = config.Config.Credential.Tencent.Bucket
+		resp.CosData.Region = config.Config.Credential.Tencent.Region
+		resp.CosData.CredentialResult = res
+	}
+
+	resp.Data = structs.Map(&resp.CosData)
+	log.NewInfo(req.OperationID, "TencentCloudStorageCredential return ", resp)
+
+	c.JSON(http.StatusOK, resp)
+}

internal/api/user/user.go

@@ -0,0 +1,129 @@
+package user
+
+import (
+	jsonData "Open_IM/internal/utils"
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	rpc "Open_IM/pkg/proto/user"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func GetUsersInfo(c *gin.Context) {
+	params := api.GetUsersInfoReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetUserInfoReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "GetUserInfo args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := rpc.NewUserClient(etcdConn)
+	RpcResp, err := client.GetUserInfo(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetUserInfo failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	var publicUserInfoList []*open_im_sdk.PublicUserInfo
+	for _, v := range RpcResp.UserInfoList {
+		publicUserInfoList = append(publicUserInfoList,
+			&open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex})
+	}
+
+	resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList}
+	resp.Data = jsonData.JsonDataList(resp.UserInfoList)
+	log.NewInfo(req.OperationID, "GetUserInfo api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func UpdateUserInfo(c *gin.Context) {
+	params := api.UpdateSelfUserInfoReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.UpdateUserInfoReq{UserInfo: &open_im_sdk.UserInfo{}}
+	utils.CopyStructFields(req.UserInfo, &params)
+
+	req.OperationID = params.OperationID
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "UpdateUserInfo args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := rpc.NewUserClient(etcdConn)
+	RpcResp, err := client.UpdateUserInfo(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "UpdateUserInfo failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	resp := api.UpdateUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, "UpdateUserInfo api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetSelfUserInfo(c *gin.Context) {
+	params := api.GetSelfUserInfoReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetUserInfoReq{}
+
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	req.UserIDList = append(req.UserIDList, req.OpUserID)
+	log.NewInfo(params.OperationID, "GetUserInfo args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := rpc.NewUserClient(etcdConn)
+	RpcResp, err := client.GetUserInfo(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetUserInfo failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	if len(RpcResp.UserInfoList) == 1 {
+		resp := api.GetSelfUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, UserInfo: RpcResp.UserInfoList[0]}
+		resp.Data = jsonData.JsonDataOne(resp.UserInfo)
+		log.NewInfo(req.OperationID, "GetUserInfo api return ", resp)
+		c.JSON(http.StatusOK, resp)
+	} else {
+		resp := api.GetSelfUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
+		log.NewInfo(req.OperationID, "GetUserInfo api return ", resp)
+		c.JSON(http.StatusOK, resp)
+	}
+
+}

internal/cms_api/admin/admin.go

@@ -0,0 +1,42 @@
+package admin
+
+import (
+	"Open_IM/pkg/cms_api_struct"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	openIMHttp "Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbAdmin "Open_IM/pkg/proto/admin_cms"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+// register
+func AdminLogin(c *gin.Context) {
+	var (
+		req cms_api_struct.AdminLoginRequest
+		resp cms_api_struct.AdminLoginResponse
+		reqPb pbAdmin.AdminLoginReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewInfo("0", utils.GetSelfFuncName(), err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.Secret = req.Secret
+	reqPb.AdminID = req.AdminName
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAdminCMSName)
+	client := pbAdmin.NewAdminCMSClient(etcdConn)
+	respPb, err := client.AdminLogin(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	resp.Token = respPb.Token
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}

internal/cms_api/group/group.go

@@ -0,0 +1,450 @@
+package group
+
+import (
+	"Open_IM/pkg/cms_api_struct"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	openIMHttp "Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	commonPb "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+
+	pbGroup "Open_IM/pkg/proto/group"
+
+	"github.com/gin-gonic/gin"
+)
+
+func GetGroupById(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetGroupByIdRequest
+		resp  cms_api_struct.GetGroupByIdResponse
+		reqPb pbGroup.GetGroupByIdReq
+	)
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	respPb, err := client.GetGroupById(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupById failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	resp.GroupName = respPb.CMSGroup.GroupInfo.GroupName
+	resp.GroupID = respPb.CMSGroup.GroupInfo.GroupID
+	resp.CreateTime = (utils.UnixSecondToTime(int64(respPb.CMSGroup.GroupInfo.CreateTime))).String()
+	resp.ProfilePhoto = respPb.CMSGroup.GroupInfo.FaceURL
+	resp.GroupMasterName = respPb.CMSGroup.GroupMasterName
+	resp.GroupMasterId = respPb.CMSGroup.GroupMasterId
+	resp.IsBanChat = constant.GroupIsBanChat(respPb.CMSGroup.GroupInfo.Status)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetGroups(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetGroupsRequest
+		resp  cms_api_struct.GetGroupsResponse
+		reqPb pbGroup.GetGroupsReq
+	)
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.Pagination = &commonPb.RequestPagination{}
+	utils.CopyStructFields(&reqPb.Pagination, req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	respPb, err := client.GetGroups(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	for _, v := range respPb.CMSGroups {
+		resp.Groups = append(resp.Groups, cms_api_struct.GroupResponse{
+			GroupName:        v.GroupInfo.GroupName,
+			GroupID:          v.GroupInfo.GroupID,
+			GroupMasterName:  v.GroupMasterName,
+			GroupMasterId:    v.GroupMasterId,
+			CreateTime:       (utils.UnixSecondToTime(int64(v.GroupInfo.CreateTime))).String(),
+			IsBanChat:        constant.GroupIsBanChat(v.GroupInfo.Status),
+			IsBanPrivateChat: false,
+			ProfilePhoto:     v.GroupInfo.FaceURL,
+		})
+	}
+	resp.GroupNums = int(respPb.GroupNum)
+	resp.CurrentPage = int(respPb.Pagination.PageNumber)
+	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetGroupByName(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetGroupRequest
+		resp  cms_api_struct.GetGroupResponse
+		reqPb pbGroup.GetGroupReq
+	)
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupName = req.GroupName
+	reqPb.Pagination = &commonPb.RequestPagination{}
+	utils.CopyStructFields(&reqPb.Pagination, req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	respPb, err := client.GetGroup(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroup failed", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	for _, v := range respPb.CMSGroups {
+		resp.Groups = append(resp.Groups, cms_api_struct.GroupResponse{
+			GroupName:        v.GroupInfo.GroupName,
+			GroupID:          v.GroupInfo.GroupID,
+			GroupMasterName:  v.GroupMasterName,
+			GroupMasterId:    v.GroupMasterId,
+			CreateTime:       (utils.UnixSecondToTime(int64(v.GroupInfo.CreateTime))).String(),
+			IsBanChat:        constant.GroupIsBanChat(v.GroupInfo.Status),
+			IsBanPrivateChat: false,
+			ProfilePhoto:     v.GroupInfo.FaceURL,
+		})
+	}
+	resp.CurrentPage = int(respPb.Pagination.PageNumber)
+	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
+	resp.GroupNums = int(respPb.GroupNums)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func CreateGroup(c *gin.Context) {
+	var (
+		req   cms_api_struct.CreateGroupRequest
+		_     cms_api_struct.CreateGroupResponse
+		reqPb pbGroup.CreateGroupReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupInfo = &commonPb.GroupInfo{}
+	reqPb.GroupInfo.GroupName = req.GroupName
+	reqPb.GroupInfo.CreatorUserID = req.GroupMasterId
+	reqPb.OwnerUserID = req.GroupMasterId
+	reqPb.OpUserID = req.GroupMasterId
+	for _, v := range req.GroupMembers {
+		reqPb.InitMemberList = append(reqPb.InitMemberList, &pbGroup.GroupAddMemberInfo{
+			UserID:    v,
+			RoleLevel: 1,
+		})
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.CreateGroup(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "CreateGroup failed", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func BanGroupChat(c *gin.Context) {
+	var (
+		req   cms_api_struct.BanGroupChatRequest
+		reqPb pbGroup.OperateGroupStatusReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	reqPb.Status = constant.GroupBanChat
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BanGroupChat failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+
+}
+
+func BanPrivateChat(c *gin.Context) {
+	var (
+		req   cms_api_struct.BanPrivateChatRequest
+		reqPb pbGroup.OperateGroupStatusReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	reqPb.Status = constant.GroupBanPrivateChat
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func OpenGroupChat(c *gin.Context) {
+	var (
+		req   cms_api_struct.BanPrivateChatRequest
+		reqPb pbGroup.OperateGroupStatusReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	reqPb.Status = constant.GroupOk
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func OpenPrivateChat(c *gin.Context) {
+	var (
+		req   cms_api_struct.BanPrivateChatRequest
+		reqPb pbGroup.OperateGroupStatusReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OpenPrivateChat failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	reqPb.Status = constant.GroupOk
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func GetGroupMembers(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetGroupMembersRequest
+		reqPb pbGroup.GetGroupMembersCMSReq
+		resp  cms_api_struct.GetGroupMembersResponse
+	)
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.Pagination = &commonPb.RequestPagination{
+		PageNumber: int32(req.PageNumber),
+		ShowNumber: int32(req.ShowNumber),
+	}
+	reqPb.GroupId = req.GroupId
+	reqPb.UserName = req.UserName
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	respPb, err := client.GetGroupMembersCMS(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS failed:", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	resp.ResponsePagination = cms_api_struct.ResponsePagination{
+		CurrentPage: int(respPb.Pagination.CurrentPage),
+		ShowNumber:  int(respPb.Pagination.ShowNumber),
+	}
+	resp.MemberNums = int(respPb.MemberNums)
+	for _, groupMembers := range respPb.Members {
+		resp.GroupMembers = append(resp.GroupMembers, cms_api_struct.GroupMemberResponse{
+			MemberPosition: int(groupMembers.RoleLevel),
+			MemberNickName: groupMembers.Nickname,
+			MemberId:       groupMembers.UserID,
+			JoinTime:       utils.UnixSecondToTime(int64(groupMembers.JoinTime)).String(),
+		})
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func AddGroupMembers(c *gin.Context) {
+	var (
+		req   cms_api_struct.RemoveGroupMembersRequest
+		resp  cms_api_struct.RemoveGroupMembersResponse
+		reqPb pbGroup.AddGroupMembersCMSReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationId, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.UserIds = req.Members
+	reqPb.GroupId = req.GroupId
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	respPb, err := client.AddGroupMembersCMS(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationId, utils.GetSelfFuncName(), "AddGroupMembersCMS failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	resp.Success = respPb.Success
+	resp.Failed = respPb.Failed
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func RemoveGroupMembers(c *gin.Context) {
+	var (
+		req   cms_api_struct.RemoveGroupMembersRequest
+		resp  cms_api_struct.RemoveGroupMembersResponse
+		reqPb pbGroup.RemoveGroupMembersCMSReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.UserIds = req.Members
+	reqPb.GroupId = req.GroupId
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	respPb, err := client.RemoveGroupMembersCMS(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "RemoveGroupMembersCMS failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	resp.Success = respPb.Success
+	resp.Failed = respPb.Failed
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func DeleteGroup(c *gin.Context) {
+	var (
+		req   cms_api_struct.DeleteGroupRequest
+		_     cms_api_struct.DeleteGroupResponse
+		reqPb pbGroup.DeleteGroupReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.DeleteGroup(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func SetGroupMaster(c *gin.Context) {
+	var (
+		req   cms_api_struct.SetGroupMasterRequest
+		_     cms_api_struct.SetGroupMasterResponse
+		reqPb pbGroup.OperateUserRoleReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	reqPb.UserId = req.UserId
+	reqPb.RoleLevel = constant.GroupOwner
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.OperateUserRole(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func SetGroupOrdinaryUsers(c *gin.Context) {
+	var (
+		req   cms_api_struct.SetGroupMemberRequest
+		_     cms_api_struct.AdminLoginResponse
+		reqPb pbGroup.OperateUserRoleReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	reqPb.UserId = req.UserId
+	reqPb.RoleLevel = constant.GroupOrdinaryUsers
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.OperateUserRole(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func AlterGroupInfo(c *gin.Context) {
+	var (
+		req   cms_api_struct.AlterGroupInfoRequest
+		_     cms_api_struct.SetGroupMasterResponse
+		reqPb pbGroup.SetGroupInfoReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.OpUserID = c.MustGet("userID").(string)
+	reqPb.GroupInfo = &commonPb.GroupInfo{
+		GroupID:      req.GroupID,
+		GroupName:    req.GroupName,
+		Introduction: req.Introduction,
+		Notification: req.Notification,
+		FaceURL:      req.ProfilePhoto,
+		GroupType:    int32(req.GroupType),
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.SetGroupInfo(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}

internal/cms_api/message_cms/message.go

@@ -0,0 +1,109 @@
+package messageCMS
+
+import (
+	"Open_IM/pkg/cms_api_struct"
+	"Open_IM/pkg/common/config"
+	openIMHttp "Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbMessage "Open_IM/pkg/proto/message_cms"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+
+	"Open_IM/pkg/common/constant"
+
+	"github.com/gin-gonic/gin"
+)
+
+func BroadcastMessage(c *gin.Context) {
+	var (
+		reqPb pbMessage.BoradcastMessageReq
+	)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName)
+	client := pbMessage.NewMessageCMSClient(etcdConn)
+	_, err := client.BoradcastMessage(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetChatLogs rpc failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func MassSendMassage(c *gin.Context) {
+	var (
+		reqPb pbMessage.MassSendMessageReq
+	)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName)
+	client := pbMessage.NewMessageCMSClient(etcdConn)
+	_, err := client.MassSendMessage(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetChatLogs rpc failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func WithdrawMessage(c *gin.Context) {
+	var (
+		reqPb pbMessage.WithdrawMessageReq
+	)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName)
+	client := pbMessage.NewMessageCMSClient(etcdConn)
+	_, err := client.WithdrawMessage(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetChatLogs rpc failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func GetChatLogs(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetChatLogsRequest
+		resp  cms_api_struct.GetChatLogsResponse
+		reqPb pbMessage.GetChatLogsReq
+	)
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
+		return
+	}
+	reqPb.Pagination = &pbCommon.RequestPagination{
+		PageNumber: int32(req.PageNumber),
+		ShowNumber: int32(req.ShowNumber),
+	}
+	utils.CopyStructFields(&reqPb, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName)
+	client := pbMessage.NewMessageCMSClient(etcdConn)
+	respPb, err := client.GetChatLogs(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetChatLogs rpc failed", err.Error())
+		openIMHttp.RespHttp200(c, err, resp)
+		return
+	}
+	//utils.CopyStructFields(&resp, &respPb)
+	for _, chatLog := range respPb.ChatLogs {
+		resp.ChatLogs = append(resp.ChatLogs, cms_api_struct.ChatLog{
+			SessionType:      int(chatLog.SessionType),
+			ContentType:      int(chatLog.ContentType),
+			SenderNickName:   chatLog.SenderNickName,
+			SenderId:         chatLog.SenderId,
+			SearchContent:    chatLog.SearchContent,
+			WholeContent:     chatLog.WholeContent,
+			ReceiverNickName: chatLog.ReciverNickName,
+			ReceiverID:       chatLog.ReciverId,
+			GroupName:        chatLog.GroupName,
+			GroupId:          chatLog.GroupId,
+			Date:             chatLog.Date,
+		})
+	}
+	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
+	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
+	resp.ChatLogsNum = int(respPb.ChatLogsNum)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}

internal/cms_api/middleware/cors.go

@@ -0,0 +1,23 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+func CorsHandler() gin.HandlerFunc {
+	return func(context *gin.Context) {
+		context.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+		context.Header("Access-Control-Allow-Methods", "*")
+		context.Header("Access-Control-Allow-Headers", "*")
+		context.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers,Cache-Control,Content-Language,Content-Type,Expires,Last-Modified,Pragma,FooBar") // 跨域关键设置 让浏览器可以解析
+		context.Header("Access-Control-Max-Age", "172800")                                                                                                                                                           // 缓存请求信息 单位为秒
+		context.Header("Access-Control-Allow-Credentials", "false")                                                                                                                                                  //  跨域请求是否需要带cookie信息 默认设置为true
+		context.Header("content-type", "application/json")                                                                                                                                                           // 设置返回格式是json
+		//Release all option pre-requests
+		if context.Request.Method == http.MethodOptions {
+			context.JSON(http.StatusOK, "Options Request!")
+		}
+		context.Next()
+	}
+}

internal/cms_api/middleware/jwt_auth.go

@@ -0,0 +1,24 @@
+package middleware
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/utils"
+	"github.com/gin-gonic/gin"
+)
+
+func JWTAuth() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), "")
+		log.NewInfo("0", utils.GetSelfFuncName(), "userID: ", userID)
+		c.Set("userID", userID)
+		if !ok {
+			log.NewError("","GetUserIDFromToken false ", c.Request.Header.Get("token"))
+			c.Abort()
+			http.RespHttp200(c, constant.ErrParseToken, nil)
+			return
+		}
+	}
+}

internal/cms_api/organization/organization.go

@@ -0,0 +1,49 @@
+package organization
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+func GetStaffs(c *gin.Context) {
+
+}
+
+func GetOrganizations(c *gin.Context) {
+
+}
+
+func GetSquads(c *gin.Context) {
+
+}
+
+func AlterStaff(c *gin.Context) {
+
+}
+
+func AddOrganization(c *gin.Context) {
+
+}
+
+func InquireOrganization(g *gin.Context) {
+
+}
+
+func AlterOrganization(c *gin.Context) {
+
+}
+
+func DeleteOrganization(g *gin.Context) {
+
+}
+
+func GetOrganizationSquads(c *gin.Context) {
+
+}
+
+func AlterStaffsInfo(c *gin.Context) {
+
+}
+
+func AddChildOrganization(c *gin.Context) {
+
+}

internal/cms_api/router.go

@@ -0,0 +1,95 @@
+package cms_api
+
+import (
+	"Open_IM/internal/cms_api/admin"
+	"Open_IM/internal/cms_api/group"
+	messageCMS "Open_IM/internal/cms_api/message_cms"
+	"Open_IM/internal/cms_api/middleware"
+	"Open_IM/internal/cms_api/organization"
+	"Open_IM/internal/cms_api/statistics"
+	"Open_IM/internal/cms_api/user"
+
+	"github.com/gin-gonic/gin"
+)
+
+func NewGinRouter() *gin.Engine {
+	gin.SetMode(gin.ReleaseMode)
+	baseRouter := gin.Default()
+	router := baseRouter.Group("/api")
+	router.Use(middleware.CorsHandler())
+	adminRouterGroup := router.Group("/admin")
+	{
+		adminRouterGroup.POST("/login", admin.AdminLogin)
+	}
+	r2 := router.Group("")
+	r2.Use(middleware.JWTAuth())
+	statisticsRouterGroup := r2.Group("/statistics")
+	{
+		statisticsRouterGroup.GET("/get_messages_statistics", statistics.GetMessagesStatistics)
+		statisticsRouterGroup.GET("/get_user_statistics", statistics.GetUserStatistics)
+		statisticsRouterGroup.GET("/get_group_statistics", statistics.GetGroupStatistics)
+		statisticsRouterGroup.GET("/get_active_user", statistics.GetActiveUser)
+		statisticsRouterGroup.GET("/get_active_group", statistics.GetActiveGroup)
+	}
+	organizationRouterGroup := r2.Group("/organization")
+	{
+		organizationRouterGroup.GET("/get_staffs", organization.GetStaffs)
+		organizationRouterGroup.GET("/get_organizations", organization.GetOrganizations)
+		organizationRouterGroup.GET("/get_squad", organization.GetSquads)
+		organizationRouterGroup.POST("/add_organization", organization.AddOrganization)
+		organizationRouterGroup.POST("/alter_staff", organization.AlterStaff)
+		organizationRouterGroup.GET("/inquire_organization", organization.InquireOrganization)
+		organizationRouterGroup.POST("/alter_organization", organization.AlterOrganization)
+		organizationRouterGroup.POST("/delete_organization", organization.DeleteOrganization)
+		organizationRouterGroup.POST("/get_organization_squad", organization.GetOrganizationSquads)
+		organizationRouterGroup.PATCH("/alter_corps_info", organization.AlterStaffsInfo)
+		organizationRouterGroup.POST("/add_child_org", organization.AddChildOrganization)
+	}
+	groupRouterGroup := r2.Group("/group")
+	{
+		groupRouterGroup.GET("/get_group_by_id", group.GetGroupById)
+		groupRouterGroup.GET("/get_groups", group.GetGroups)
+		groupRouterGroup.GET("/get_group_by_name", group.GetGroupByName)
+		groupRouterGroup.GET("/get_group_members", group.GetGroupMembers)
+		groupRouterGroup.POST("/create_group", group.CreateGroup)
+		groupRouterGroup.POST("/add_members", group.AddGroupMembers)
+		groupRouterGroup.POST("/remove_members", group.RemoveGroupMembers)
+		groupRouterGroup.POST("/ban_group_private_chat", group.BanPrivateChat)
+		groupRouterGroup.POST("/open_group_private_chat", group.OpenPrivateChat)
+		groupRouterGroup.POST("/ban_group_chat", group.BanGroupChat)
+		groupRouterGroup.POST("/open_group_chat", group.OpenGroupChat)
+		groupRouterGroup.POST("/delete_group", group.DeleteGroup)
+		groupRouterGroup.POST("/get_members_in_group", group.GetGroupMembers)
+		groupRouterGroup.POST("/set_group_master", group.SetGroupMaster)
+		groupRouterGroup.POST("/set_group_ordinary_user", group.SetGroupOrdinaryUsers)
+		groupRouterGroup.POST("/alter_group_info", group.AlterGroupInfo)
+	}
+	userRouterGroup := r2.Group("/user")
+	{
+		userRouterGroup.POST("/resign", user.ResignUser)
+		userRouterGroup.GET("/get_user", user.GetUserById)
+		userRouterGroup.POST("/alter_user", user.AlterUser)
+		userRouterGroup.GET("/get_users", user.GetUsers)
+		userRouterGroup.POST("/add_user", user.AddUser)
+		userRouterGroup.POST("/unblock_user", user.UnblockUser)
+		userRouterGroup.POST("/block_user", user.BlockUser)
+		userRouterGroup.GET("/get_block_users", user.GetBlockUsers)
+		userRouterGroup.GET("/get_block_user", user.GetBlockUserById)
+		userRouterGroup.POST("/delete_user", user.DeleteUser)
+		userRouterGroup.GET("/get_users_by_name", user.GetUsersByName)
+	}
+	friendRouterGroup := r2.Group("/friend")
+	{
+		friendRouterGroup.POST("/get_friends_by_id")
+		friendRouterGroup.POST("/set_friend")
+		friendRouterGroup.POST("/remove_friend")
+	}
+	messageCMSRouterGroup := r2.Group("/message")
+	{
+		messageCMSRouterGroup.GET("/get_chat_logs", messageCMS.GetChatLogs)
+		messageCMSRouterGroup.POST("/broadcast_message", messageCMS.BroadcastMessage)
+		messageCMSRouterGroup.POST("/mass_send_message", messageCMS.MassSendMassage)
+		messageCMSRouterGroup.POST("/withdraw_message", messageCMS.WithdrawMessage)
+	}
+	return baseRouter
+}

internal/cms_api/statistics/statistics.go

@@ -0,0 +1,224 @@
+package statistics
+
+import (
+	"Open_IM/pkg/cms_api_struct"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	openIMHttp "Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pb "Open_IM/pkg/proto/statistics"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+func GetMessagesStatistics(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetMessageStatisticsRequest
+		resp  cms_api_struct.GetMessageStatisticsResponse
+		reqPb pb.GetMessageStatisticsReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetMessageStatistics(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetMessageStatistics failed", err.Error())
+		openIMHttp.RespHttp200(c, err, resp)
+		return
+	}
+	// utils.CopyStructFields(&resp, respPb)
+	resp.GroupMessageNum = int(respPb.GroupMessageNum)
+	resp.PrivateMessageNum = int(respPb.PrivateMessageNum)
+	for _, v := range respPb.PrivateMessageNumList {
+		resp.PrivateMessageNumList = append(resp.PrivateMessageNumList, struct {
+			Date       string "json:\"date\""
+			MessageNum int    "json:\"message_num\""
+		}{
+			Date:       v.Date,
+			MessageNum: int(v.Num),
+		})
+	}
+	for _, v := range respPb.GroupMessageNumList {
+		resp.GroupMessageNumList = append(resp.GroupMessageNumList, struct {
+			Date       string "json:\"date\""
+			MessageNum int    "json:\"message_num\""
+		}{
+			Date:       v.Date,
+			MessageNum: int(v.Num),
+		})
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetUserStatistics(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetUserStatisticsRequest
+		resp  cms_api_struct.GetUserStatisticsResponse
+		reqPb pb.GetUserStatisticsReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetUserStatistics(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "GetUserStatistics failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	// utils.CopyStructFields(&resp, respPb)
+	resp.ActiveUserNum = int(respPb.ActiveUserNum)
+	resp.IncreaseUserNum = int(respPb.IncreaseUserNum)
+	resp.TotalUserNum = int(respPb.TotalUserNum)
+	for _, v := range respPb.ActiveUserNumList {
+		resp.ActiveUserNumList = append(resp.ActiveUserNumList, struct {
+			Date          string "json:\"date\""
+			ActiveUserNum int    "json:\"active_user_num\""
+		}{
+			Date:          v.Date,
+			ActiveUserNum: int(v.Num),
+		})
+	}
+	for _, v := range respPb.IncreaseUserNumList {
+		resp.IncreaseUserNumList = append(resp.IncreaseUserNumList, struct {
+			Date            string "json:\"date\""
+			IncreaseUserNum int    "json:\"increase_user_num\""
+		}{
+			Date:            v.Date,
+			IncreaseUserNum: int(v.Num),
+		})
+	}
+	for _, v := range respPb.TotalUserNumList {
+		resp.TotalUserNumList = append(resp.TotalUserNumList, struct {
+			Date         string "json:\"date\""
+			TotalUserNum int    "json:\"total_user_num\""
+		}{
+			Date:         v.Date,
+			TotalUserNum: int(v.Num),
+		})
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetGroupStatistics(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetGroupStatisticsRequest
+		resp  cms_api_struct.GetGroupStatisticsResponse
+		reqPb pb.GetGroupStatisticsReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetGroupStatistics(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupStatistics failed", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	// utils.CopyStructFields(&resp, respPb)
+	resp.IncreaseGroupNum = int(respPb.GetIncreaseGroupNum())
+	resp.TotalGroupNum = int(respPb.GetTotalGroupNum())
+	for _, v := range respPb.IncreaseGroupNumList {
+		resp.IncreaseGroupNumList = append(resp.IncreaseGroupNumList,
+			struct {
+				Date             string "json:\"date\""
+				IncreaseGroupNum int    "json:\"increase_group_num\""
+			}{
+				Date:             v.Date,
+				IncreaseGroupNum: int(v.Num),
+			})
+	}
+	for _, v := range respPb.TotalGroupNumList {
+		resp.TotalGroupNumList = append(resp.TotalGroupNumList,
+			struct {
+				Date          string "json:\"date\""
+				TotalGroupNum int    "json:\"total_group_num\""
+			}{
+				Date:          v.Date,
+				TotalGroupNum: int(v.Num),
+			})
+
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetActiveUser(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetActiveUserRequest
+		resp  cms_api_struct.GetActiveUserResponse
+		reqPb pb.GetActiveUserReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetActiveUser(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetActiveUser failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	utils.CopyStructFields(&resp.ActiveUserList, respPb.Users)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetActiveGroup(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetActiveGroupRequest
+		resp  cms_api_struct.GetActiveGroupResponse
+		reqPb pb.GetActiveGroupReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetActiveGroup(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "GetActiveGroup failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	for _, group := range respPb.Groups {
+		resp.ActiveGroupList = append(resp.ActiveGroupList, struct {
+			GroupName  string "json:\"group_name\""
+			GroupId    string "json:\"group_id\""
+			MessageNum int    "json:\"message_num\""
+		}{
+			GroupName:  group.GroupName,
+			GroupId:    group.GroupId,
+			MessageNum: int(group.MessageNum),
+		})
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}

internal/cms_api/user/user.go

@@ -0,0 +1,307 @@
+package user
+
+import (
+	"Open_IM/pkg/cms_api_struct"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	openIMHttp "Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	commonPb "Open_IM/pkg/proto/sdk_ws"
+	pb "Open_IM/pkg/proto/user"
+	"Open_IM/pkg/utils"
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+func GetUserById(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetUserRequest
+		resp  cms_api_struct.GetUserResponse
+		reqPb pb.GetUserByIdReq
+	)
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetUserById(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	if respPb.User.UserId == "" {
+		openIMHttp.RespHttp200(c, constant.OK, nil)
+		return
+	}
+	utils.CopyStructFields(&resp, respPb.User)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetUsersByName(c *gin.Context) {
+	var (
+		req cms_api_struct.GetUsersByNameRequest
+		resp cms_api_struct.GetUsersByNameResponse
+		reqPb pb.GetUsersByNameReq
+	)
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.UserName = req.UserName
+	reqPb.Pagination = &commonPb.RequestPagination{
+		PageNumber: int32(req.PageNumber),
+		ShowNumber: int32(req.ShowNumber),
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetUsersByName(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	utils.CopyStructFields(&resp.Users, respPb.Users)
+	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
+	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
+	resp.UserNums = respPb.UserNums
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetUsers(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetUsersRequest
+		resp  cms_api_struct.GetUsersResponse
+		reqPb pb.GetUsersReq
+	)
+	reqPb.Pagination = &commonPb.RequestPagination{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", "ShouldBindQuery failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.Pagination, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetUsers(context.Background(), &reqPb)
+	if err != nil {
+		openIMHttp.RespHttp200(c, err, resp)
+		return
+	}
+	utils.CopyStructFields(&resp.Users, respPb.User)
+	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
+	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
+	resp.UserNums = respPb.UserNums
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+
+}
+
+func ResignUser(c *gin.Context) {
+	var (
+		req   cms_api_struct.ResignUserRequest
+		resp  cms_api_struct.ResignUserResponse
+		reqPb pb.ResignUserReq
+	)
+	if err := c.ShouldBind(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
+		return
+	}
+	utils.CopyStructFields(&reqPb, &req)
+	fmt.Println(reqPb.UserId)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	_, err := client.ResignUser(context.Background(), &reqPb)
+	if err != nil {
+		openIMHttp.RespHttp200(c, err, resp)
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func AlterUser(c *gin.Context) {
+	var (
+		req   cms_api_struct.AlterUserRequest
+		resp  cms_api_struct.AlterUserResponse
+		reqPb pb.AlterUserReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
+		return
+	}
+	utils.CopyStructFields(&reqPb, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	_, err := client.AlterUser(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError("0", "microserver failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func AddUser(c *gin.Context) {
+	var (
+		req   cms_api_struct.AddUserRequest
+		reqPb pb.AddUserReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	_, err := client.AddUser(context.Background(), &reqPb)
+	if err != nil {
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func BlockUser(c *gin.Context) {
+	var (
+		req   cms_api_struct.BlockUserRequest
+		resp  cms_api_struct.BlockUserResponse
+		reqPb pb.BlockUserReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		fmt.Println(err)
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
+		return
+	}
+	utils.CopyStructFields(&reqPb, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	fmt.Println(reqPb)
+	_, err := client.BlockUser(context.Background(), &reqPb)
+	if err != nil {
+		openIMHttp.RespHttp200(c, err, resp)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func UnblockUser(c *gin.Context) {
+	var (
+		req   cms_api_struct.UnblockUserRequest
+		resp  cms_api_struct.UnBlockUserResponse
+		reqPb pb.UnBlockUserReq
+	)
+	if err := c.ShouldBind(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
+		return
+	}
+	utils.CopyStructFields(&reqPb, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	_, err := client.UnBlockUser(context.Background(), &reqPb)
+	if err != nil {
+		openIMHttp.RespHttp200(c, err, resp)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetBlockUsers(c *gin.Context) {
+	var (
+		req    cms_api_struct.GetBlockUsersRequest
+		resp   cms_api_struct.GetBlockUsersResponse
+		reqPb  pb.GetBlockUsersReq
+		respPb *pb.GetBlockUsersResp
+	)
+	reqPb.Pagination = &commonPb.RequestPagination{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
+		return
+	}
+	utils.CopyStructFields(&reqPb.Pagination, &req)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "blockUsers", reqPb.Pagination, req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetBlockUsers(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetBlockUsers rpc", err.Error())
+		openIMHttp.RespHttp200(c, err, resp)
+		return
+	}
+	for _, v := range respPb.BlockUsers {
+		resp.BlockUsers = append(resp.BlockUsers, cms_api_struct.BlockUser{
+			UserResponse: cms_api_struct.UserResponse{
+				UserId:       v.User.UserId,
+				ProfilePhoto: v.User.ProfilePhoto,
+				Nickname:     v.User.Nickname,
+				IsBlock:      v.User.IsBlock,
+				CreateTime:   v.User.CreateTime,
+			},
+			BeginDisableTime: v.BeginDisableTime,
+			EndDisableTime:   v.EndDisableTime,
+		})
+	}
+	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
+	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
+	resp.UserNums = respPb.UserNums
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func GetBlockUserById(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetBlockUserRequest
+		resp  cms_api_struct.GetBlockUserResponse
+		reqPb pb.GetBlockUserByIdReq
+	)
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.UserId = req.UserId
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetBlockUserById(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError("0", "GetBlockUserById rpc failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	resp.EndDisableTime = respPb.BlockUser.EndDisableTime
+	resp.BeginDisableTime = respPb.BlockUser.BeginDisableTime
+	utils.CopyStructFields(&resp, respPb.BlockUser.User)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
+func DeleteUser(c *gin.Context) {
+	var (
+		req   cms_api_struct.DeleteUserRequest
+		reqPb pb.DeleteUserReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.UserId = req.UserId
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	_, err := client.DeleteUser(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError("0", "DeleteUser rpc failed ", err.Error())
+		openIMHttp.RespHttp200(c, err, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}

internal/demo/register/login.go

@@ -0,0 +1,70 @@
+package register
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	http2 "Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type ParamsLogin struct {
+	Email       string `json:"email"`
+	PhoneNumber string `json:"phoneNumber"`
+	Password    string `json:"password"`
+	Platform    int32  `json:"platform"`
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+func Login(c *gin.Context) {
+	params := ParamsLogin{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
+		return
+	}
+	var account string
+	if params.Email != "" {
+		account = params.Email
+	} else {
+		account = params.PhoneNumber
+	}
+
+	r, err := im_mysql_model.GetRegister(account)
+	if err != nil {
+		log.NewError(params.OperationID, "user have not register", params.Password, account, err.Error())
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.NotRegistered, "errMsg": "Mobile phone number is not registered"})
+		return
+	}
+	if r.Password != params.Password {
+		log.NewError(params.OperationID, "password err", params.Password, account, r.Password, r.Account)
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.PasswordErr, "errMsg": "password err"})
+		return
+	}
+	url := fmt.Sprintf("http://%s:10000/auth/user_token", utils.ServerIP)
+	openIMGetUserToken := api.UserTokenReq{}
+	openIMGetUserToken.OperationID = params.OperationID
+	openIMGetUserToken.Platform = params.Platform
+	openIMGetUserToken.Secret = config.Config.Secret
+	openIMGetUserToken.UserID = account
+	openIMGetUserTokenResp := api.UserTokenResp{}
+	bMsg, err := http2.Post(url, openIMGetUserToken, 2)
+	if err != nil {
+		log.NewError(params.OperationID, "request openIM get user token error", account, "err", err.Error())
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.GetIMTokenErr, "errMsg": err.Error()})
+		return
+	}
+	err = json.Unmarshal(bMsg, &openIMGetUserTokenResp)
+	if err != nil || openIMGetUserTokenResp.ErrCode != 0 {
+		log.NewError(params.OperationID, "request get user token", account, "err", "")
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.GetIMTokenErr, "errMsg": ""})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "", "data": openIMGetUserTokenResp.UserToken})
+
+}

internal/demo/register/reset_password.go

@@ -0,0 +1,56 @@
+package register
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type resetPasswordRequest struct {
+	VerificationCode string `json:"verificationCode" binding:"required"`
+	Email            string `json:"email"`
+	PhoneNumber      string `json:"phoneNumber"`
+	NewPassword string `json:"newPassword" binding:"required"`
+	OperationID string `json:"operationID"`
+}
+
+func ResetPassword(c *gin.Context) {
+	var (
+		req resetPasswordRequest
+	)
+	if err := c.BindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
+		return
+	}
+	var account string
+	if req.Email != "" {
+		account = req.Email
+	} else {
+		account = req.PhoneNumber
+	}
+	if req.VerificationCode != config.Config.Demo.SuperCode {
+		accountKey := account + "_" + constant.VerificationCodeForResetSuffix
+		v, err := db.DB.GetAccountCode(accountKey)
+		if err != nil || v != req.VerificationCode {
+			log.NewError(req.OperationID, "password Verification code error", account, req.VerificationCode, v)
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.CodeInvalidOrExpired, "errMsg": "Verification code error!"})
+			return
+		}
+	}
+	user, err := im_mysql_model.GetRegister(account)
+	if err != nil || user.Account == "" {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "get register error", err.Error())
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.NotRegistered, "errMsg": "user not register!"})
+		return
+	}
+	if err := im_mysql_model.ResetPassword(account, req.NewPassword); err != nil {
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.ResetPasswordFailed, "errMsg": "reset password failed: "+err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "reset password success"})
+}

internal/demo/register/send_code.go

@@ -0,0 +1,130 @@
+package register
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"fmt"
+	openapi "github.com/alibabacloud-go/darabonba-openapi/client"
+	dysmsapi20170525 "github.com/alibabacloud-go/dysmsapi-20170525/v2/client"
+	"github.com/alibabacloud-go/tea/tea"
+	"github.com/gin-gonic/gin"
+	"gopkg.in/gomail.v2"
+	"math/rand"
+	"net/http"
+	"time"
+)
+
+type paramsVerificationCode struct {
+	Email       string `json:"email"`
+	PhoneNumber string `json:"phoneNumber"`
+	OperationID string `json:"operationID" binding:"required"`
+	UsedFor     int `json:"usedFor"`
+}
+
+func SendVerificationCode(c *gin.Context) {
+	params := paramsVerificationCode{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("", "BindJSON failed", "err:", err.Error(), "phoneNumber", params.PhoneNumber, "email", params.Email)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
+		return
+	}
+	var account string
+	if params.Email != "" {
+		account = params.Email
+	} else {
+		account = params.PhoneNumber
+	}
+	var accountKey string
+	if params.UsedFor == 0 {
+		params.UsedFor = constant.VerificationCodeForRegister
+	}
+	switch params.UsedFor {
+	case constant.VerificationCodeForRegister:
+		_, err := im_mysql_model.GetRegister(account)
+		if err == nil {
+			log.NewError(params.OperationID, "The phone number has been registered", params)
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.HasRegistered, "errMsg": "The phone number has been registered"})
+			return
+		}
+		ok, err := db.DB.JudgeAccountEXISTS(account)
+		if ok || err != nil {
+			log.NewError(params.OperationID, "The phone number has been registered", params)
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.RepeatSendCode, "errMsg": "The phone number has been registered"})
+			return
+		}
+		accountKey = account + "_" + constant.VerificationCodeForRegisterSuffix
+
+	case constant.VerificationCodeForReset:
+		accountKey = account + "_" + constant.VerificationCodeForResetSuffix
+	}
+	rand.Seed(time.Now().UnixNano())
+	code := 100000 + rand.Intn(900000)
+	log.NewInfo(params.OperationID, params.UsedFor,"begin store redis", accountKey, code)
+	err := db.DB.SetAccountCode(accountKey, code, config.Config.Demo.CodeTTL)
+	if err != nil {
+		log.NewError(params.OperationID, "set redis error", accountKey, "err", err.Error())
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.SmsSendCodeErr, "errMsg": "Enter the superCode directly in the verification code box, SuperCode can be configured in config.xml"})
+		return
+	}
+	log.NewDebug("", config.Config.Demo)
+	if params.Email != "" {
+		m := gomail.NewMessage()
+		m.SetHeader(`From`, config.Config.Demo.Mail.SenderMail)
+		m.SetHeader(`To`, []string{account}...)
+		m.SetHeader(`Subject`, config.Config.Demo.Mail.Title)
+		m.SetBody(`text/html`, fmt.Sprintf("%d", code))
+		if err := gomail.NewDialer(config.Config.Demo.Mail.SmtpAddr, config.Config.Demo.Mail.SmtpPort, config.Config.Demo.Mail.SenderMail, config.Config.Demo.Mail.SenderAuthorizationCode).DialAndSend(m); err != nil {
+			log.ErrorByKv("send mail error", account, "err", err.Error())
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.MailSendCodeErr, "errMsg": ""})
+			return
+		}
+	} else {
+		client, err := CreateClient(tea.String(config.Config.Demo.AliSMSVerify.AccessKeyID), tea.String(config.Config.Demo.AliSMSVerify.AccessKeySecret))
+		if err != nil {
+			log.NewError(params.OperationID, "create sendSms client err", "err", err.Error())
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.SmsSendCodeErr, "errMsg": "Enter the superCode directly in the verification code box, SuperCode can be configured in config.xml"})
+			return
+		}
+
+		sendSmsRequest := &dysmsapi20170525.SendSmsRequest{
+			PhoneNumbers:  tea.String(account),
+			SignName:      tea.String(config.Config.Demo.AliSMSVerify.SignName),
+			TemplateCode:  tea.String(config.Config.Demo.AliSMSVerify.VerificationCodeTemplateCode),
+			TemplateParam: tea.String(fmt.Sprintf("{\"code\":\"%d\"}", code)),
+		}
+
+		response, err := client.SendSms(sendSmsRequest)
+		if err != nil {
+			log.NewError(params.OperationID, "sendSms error", account, "err", err.Error())
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.SmsSendCodeErr, "errMsg": "Enter the superCode directly in the verification code box, SuperCode can be configured in config.xml"})
+			return
+		}
+		if *response.Body.Code != "OK" {
+			log.NewError(params.OperationID, "alibabacloud sendSms error", account, "err", response.Body.Code, response.Body.Message)
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.SmsSendCodeErr, "errMsg": "Enter the superCode directly in the verification code box, SuperCode can be configured in config.xml"})
+			return
+		}
+	}
+
+	data := make(map[string]interface{})
+	data["account"] = account
+	c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "Verification code has been set!", "data": data})
+}
+
+func CreateClient(accessKeyId *string, accessKeySecret *string) (result *dysmsapi20170525.Client, err error) {
+	c := &openapi.Config{
+		// 您的AccessKey ID
+		AccessKeyId: accessKeyId,
+		// 您的AccessKey Secret
+		AccessKeySecret: accessKeySecret,
+	}
+
+	// 访问的域名
+	c.Endpoint = tea.String("dysmsapi.aliyuncs.com")
+	result = &dysmsapi20170525.Client{}
+	result, err = dysmsapi20170525.NewClient(c)
+	return result, err
+}

internal/demo/register/set_password.go

@@ -0,0 +1,89 @@
+package register
+
+import (
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	http2 "Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type ParamsSetPassword struct {
+	Email            string `json:"email"`
+	Name             string `json:"name"`
+	PhoneNumber      string `json:"phoneNumber"`
+	Password         string `json:"password"`
+	VerificationCode string `json:"verificationCode"`
+	Platform         int32  `json:"platform" binding:"required,min=1,max=7"`
+	Ex               string `json:"ex"`
+	OperationID      string `json:"operationID" binding:"required"`
+}
+
+func SetPassword(c *gin.Context) {
+	params := ParamsSetPassword{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError(params.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
+		return
+	}
+	var account string
+	if params.Email != "" {
+		account = params.Email
+	} else {
+		account = params.PhoneNumber
+	}
+	if params.Name == "" {
+		params.Name = account
+	}
+	if params.VerificationCode != config.Config.Demo.SuperCode {
+		accountKey := account + "_" + constant.VerificationCodeForRegisterSuffix
+		v, err := db.DB.GetAccountCode(accountKey)
+		if err != nil || v != params.VerificationCode {
+			log.NewError(params.OperationID, "password Verification code error", account, params.VerificationCode)
+			data := make(map[string]interface{})
+			data["PhoneNumber"] = account
+			c.JSON(http.StatusOK, gin.H{"errCode": constant.CodeInvalidOrExpired, "errMsg": "Verification code error!", "data": data})
+			return
+		}
+	}
+	url := fmt.Sprintf("http://%s:10000/auth/user_register", utils.ServerIP)
+	openIMRegisterReq := api.UserRegisterReq{}
+	openIMRegisterReq.OperationID = params.OperationID
+	openIMRegisterReq.Platform = params.Platform
+	openIMRegisterReq.UserID = account
+	openIMRegisterReq.Nickname = params.Name
+	openIMRegisterReq.Secret = config.Config.Secret
+	openIMRegisterResp := api.UserRegisterResp{}
+	bMsg, err := http2.Post(url, openIMRegisterReq, 2)
+	if err != nil {
+		log.NewError(params.OperationID, "request openIM register error", account, "err", err.Error())
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterFailed, "errMsg": err.Error()})
+		return
+	}
+	err = json.Unmarshal(bMsg, &openIMRegisterResp)
+	if err != nil || openIMRegisterResp.ErrCode != 0 {
+		log.NewError(params.OperationID, "request openIM register error", account, "err", "resp: ", openIMRegisterResp.ErrCode)
+		if err != nil {
+			log.NewError(params.OperationID, utils.GetSelfFuncName(), err.Error())
+		}
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterFailed, "errMsg": "register failed: " + openIMRegisterResp.ErrMsg})
+		return
+	}
+	log.Info(params.OperationID, "begin store mysql", account, params.Password)
+	err = im_mysql_model.SetPassword(account, params.Password, params.Ex)
+	if err != nil {
+		log.NewError(params.OperationID, "set phone number password error", account, "err", err.Error())
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterFailed, "errMsg": err.Error()})
+		return
+	}
+	log.Info(params.OperationID, "end setPassword", account, params.Password)
+	c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "", "data": openIMRegisterResp.UserToken})
+	return
+}

internal/demo/register/verify.go

@@ -0,0 +1,80 @@
+package register
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type paramsCertification struct {
+	Email            string `json:"email"`
+	PhoneNumber      string `json:"phoneNumber"`
+	VerificationCode string `json:"verificationCode"`
+	OperationID      string `json:"operationID" binding:"required"`
+	UsedFor          int    `json:"usedFor"`
+}
+
+func Verify(c *gin.Context) {
+	params := paramsCertification{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("", "request params json parsing failed", "", "err", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": constant.FormattingError, "errMsg": err.Error()})
+		return
+	}
+	log.NewInfo("recv req: ", params)
+
+	var account string
+	if params.Email != "" {
+		account = params.Email
+	} else {
+		account = params.PhoneNumber
+	}
+
+	if params.VerificationCode == config.Config.Demo.SuperCode {
+		log.InfoByKv("Super Code Verified successfully", account)
+		data := make(map[string]interface{})
+		data["account"] = account
+		data["verificationCode"] = params.VerificationCode
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "Verified successfully!", "data": data})
+		return
+	}
+	log.NewInfo("0", " params.VerificationCode != config.Config.Demo.SuperCode", params.VerificationCode, config.Config.Demo)
+	log.NewInfo(params.OperationID, "begin get form redis", account)
+	if params.UsedFor == 0 {
+		params.UsedFor = constant.VerificationCodeForRegister
+	}
+	var accountKey string
+	switch params.UsedFor {
+	case constant.VerificationCodeForRegister:
+		accountKey = account + "_" + constant.VerificationCodeForRegisterSuffix
+	case constant.VerificationCodeForReset:
+		accountKey = account + "_" + constant.VerificationCodeForResetSuffix
+	}
+
+	code, err := db.DB.GetAccountCode(accountKey)
+	log.NewInfo(params.OperationID, "redis phone number and verificating Code", accountKey, code, params)
+	if err != nil {
+		log.NewError(params.OperationID, "Verification code expired", accountKey, "err", err.Error())
+		data := make(map[string]interface{})
+		data["account"] = account
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.CodeInvalidOrExpired, "errMsg": "Verification code expired!", "data": data})
+		return
+	}
+	if params.VerificationCode == code {
+		log.Info(params.OperationID, "Verified successfully", account)
+		data := make(map[string]interface{})
+		data["account"] = account
+		data["verificationCode"] = params.VerificationCode
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.NoError, "errMsg": "Verified successfully!", "data": data})
+		return
+	} else {
+		log.Info(params.OperationID, "Verification code error", account, params.VerificationCode)
+		data := make(map[string]interface{})
+		data["account"] = account
+		c.JSON(http.StatusOK, gin.H{"errCode": constant.CodeInvalidOrExpired, "errMsg": "Verification code error!", "data": data})
+	}
+}

internal/msg_gateway/gate/init.go

@@ -0,0 +1,35 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+
+	"Open_IM/pkg/statistics"
+	"fmt"
+	"github.com/go-playground/validator/v10"
+	"sync"
+)
+
+var (
+	rwLock       *sync.RWMutex
+	validate     *validator.Validate
+	ws           WServer
+	rpcSvr       RPCServer
+	sendMsgCount uint64
+	userCount    uint64
+)
+
+func Init(rpcPort, wsPort int) {
+	//log initialization
+
+	rwLock = new(sync.RWMutex)
+	validate = validator.New()
+	statistics.NewStatistics(&sendMsgCount, config.Config.ModuleName.LongConnSvrName, fmt.Sprintf("%d second recv to msg_gateway sendMsgCount", sendMsgCount), 300)
+	statistics.NewStatistics(&userCount, config.Config.ModuleName.LongConnSvrName, fmt.Sprintf("%d second add user conn", userCount), 300)
+	ws.onInit(wsPort)
+	rpcSvr.onInit(rpcPort)
+}
+
+func Run() {
+	go ws.run()
+	go rpcSvr.run()
+}

internal/msg_gateway/gate/logic.go

@@ -0,0 +1,297 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	pbRtc "Open_IM/pkg/proto/rtc"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"bytes"
+	"context"
+	"encoding/gob"
+	"github.com/golang/protobuf/proto"
+	"github.com/gorilla/websocket"
+	"google.golang.org/grpc"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
+	//ws online debug data
+	//{"ReqIdentifier":1001,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b","Time":"123","OperationID":"123","MsgIncr":0}
+	//{"ReqIdentifier":1002,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b","Time":"123","OperationID":"123","MsgIncr":0,"SeqBegin":1,"SeqEnd":6}
+	//{"ReqIdentifier":1003,"Token":"123","SendID":"c4ca4238a0b923820dcc509a6f75849b",
+	//"RecvID":"a87ff679a2f3e71d9181a67b7542122c","ClientMsgID":"2343","Time":"147878787","OperationID":
+	//"123","MsgIncr":0,"SubMsgType":101,"MsgType":100,"MsgFrom":1,"Content":"sdfsdf"}
+	b := bytes.NewBuffer(binaryMsg)
+	m := Req{}
+	dec := gob.NewDecoder(b)
+	err := dec.Decode(&m)
+	if err != nil {
+		log.NewError("", "ws Decode  err", err.Error())
+		ws.sendErrMsg(conn, 200, err.Error(), constant.WSDataError, "", "")
+		err = conn.Close()
+		if err != nil {
+			log.NewError("", "ws close err", err.Error())
+		}
+		return
+	}
+	if err := validate.Struct(m); err != nil {
+		log.NewError("", "ws args validate  err", err.Error())
+		ws.sendErrMsg(conn, 201, err.Error(), m.ReqIdentifier, m.MsgIncr, m.OperationID)
+		return
+	}
+	//if !utils.VerifyToken(m.Token, m.SendID) {
+	//	ws.sendErrMsg(conn, 202, "token validate err", m.ReqIdentifier, m.MsgIncr,m.OperationID)
+	//	return
+	//}
+	log.NewInfo(m.OperationID, "Basic Info Authentication Success", m)
+
+	switch m.ReqIdentifier {
+	case constant.WSGetNewestSeq:
+		ws.getSeqReq(conn, &m)
+	case constant.WSSendMsg:
+		ws.sendMsgReq(conn, &m)
+	case constant.WSSendSignalMsg:
+		ws.sendSignalMsgReq(conn, &m)
+	case constant.WSPullMsgBySeqList:
+		ws.pullMsgBySeqListReq(conn, &m)
+	default:
+	}
+	log.NewInfo("", "goroutine num is ", runtime.NumGoroutine())
+}
+func (ws *WServer) getSeqReq(conn *UserConn, m *Req) {
+	log.NewInfo(m.OperationID, "Ws call success to getNewSeq", m.MsgIncr, m.SendID, m.ReqIdentifier, m.Data)
+	rpcReq := pbChat.GetMaxAndMinSeqReq{}
+	nReply := new(pbChat.GetMaxAndMinSeqResp)
+	rpcReq.UserID = m.SendID
+	rpcReq.OperationID = m.OperationID
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	if grpcConn == nil {
+		log.ErrorByKv("get grpcConn err", rpcReq.OperationID, "args", m)
+	}
+	msgClient := pbChat.NewChatClient(grpcConn)
+	rpcReply, err := msgClient.GetMaxAndMinSeq(context.Background(), &rpcReq)
+	if err != nil {
+		log.Error(rpcReq.OperationID, "rpc call failed to getSeqReq", err, rpcReq.String())
+		nReply.ErrCode = 500
+		nReply.ErrMsg = err.Error()
+		ws.getSeqResp(conn, m, nReply)
+	} else {
+		log.InfoByKv("rpc call success to getSeqReq", rpcReq.OperationID, "replyData", rpcReply.String())
+		ws.getSeqResp(conn, m, rpcReply)
+	}
+}
+func (ws *WServer) getSeqResp(conn *UserConn, m *Req, pb *pbChat.GetMaxAndMinSeqResp) {
+	var mReplyData sdk_ws.GetMaxAndMinSeqResp
+	mReplyData.MaxSeq = pb.GetMaxSeq()
+	mReplyData.MinSeq = pb.GetMinSeq()
+	b, _ := proto.Marshal(&mReplyData)
+	mReply := Resp{
+		ReqIdentifier: m.ReqIdentifier,
+		MsgIncr:       m.MsgIncr,
+		ErrCode:       pb.GetErrCode(),
+		ErrMsg:        pb.GetErrMsg(),
+		OperationID:   m.OperationID,
+		Data:          b,
+	}
+	ws.sendMsg(conn, mReply)
+}
+
+func (ws *WServer) pullMsgBySeqListReq(conn *UserConn, m *Req) {
+	log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq start", m.SendID, m.ReqIdentifier, m.MsgIncr, m.Data)
+	nReply := new(sdk_ws.PullMessageBySeqListResp)
+	isPass, errCode, errMsg, data := ws.argsValidate(m, constant.WSPullMsgBySeqList)
+	if isPass {
+		rpcReq := sdk_ws.PullMessageBySeqListReq{}
+		rpcReq.SeqList = data.(sdk_ws.PullMessageBySeqListReq).SeqList
+		rpcReq.UserID = m.SendID
+		rpcReq.OperationID = m.OperationID
+		log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq middle", m.SendID, m.ReqIdentifier, m.MsgIncr, data.(sdk_ws.PullMessageBySeqListReq).SeqList)
+		grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+		msgClient := pbChat.NewChatClient(grpcConn)
+		reply, err := msgClient.PullMessageBySeqList(context.Background(), &rpcReq)
+		if err != nil {
+			log.NewError(rpcReq.OperationID, "pullMsgBySeqListReq err", err.Error())
+			nReply.ErrCode = 200
+			nReply.ErrMsg = err.Error()
+			ws.pullMsgBySeqListResp(conn, m, nReply)
+		} else {
+			log.NewInfo(rpcReq.OperationID, "rpc call success to pullMsgBySeqListReq", reply.String(), len(reply.List))
+			ws.pullMsgBySeqListResp(conn, m, reply)
+		}
+	} else {
+		nReply.ErrCode = errCode
+		nReply.ErrMsg = errMsg
+		ws.pullMsgBySeqListResp(conn, m, nReply)
+	}
+}
+func (ws *WServer) pullMsgBySeqListResp(conn *UserConn, m *Req, pb *sdk_ws.PullMessageBySeqListResp) {
+	log.NewInfo(m.OperationID, "pullMsgBySeqListResp come  here ", pb.String())
+	c, _ := proto.Marshal(pb)
+	mReply := Resp{
+		ReqIdentifier: m.ReqIdentifier,
+		MsgIncr:       m.MsgIncr,
+		ErrCode:       pb.GetErrCode(),
+		ErrMsg:        pb.GetErrMsg(),
+		OperationID:   m.OperationID,
+		Data:          c,
+	}
+	log.NewInfo(m.OperationID, "pullMsgBySeqListResp all data  is ", mReply.ReqIdentifier, mReply.MsgIncr, mReply.ErrCode, mReply.ErrMsg,
+		len(mReply.Data))
+
+	ws.sendMsg(conn, mReply)
+
+}
+func (ws *WServer) sendMsgReq(conn *UserConn, m *Req) {
+	sendMsgCount++
+	log.NewInfo(m.OperationID, "Ws call success to sendMsgReq start", m.MsgIncr, m.ReqIdentifier, m.SendID, m.Data)
+	nReply := new(pbChat.SendMsgResp)
+	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendMsg)
+	if isPass {
+		data := pData.(sdk_ws.MsgData)
+		pbData := pbChat.SendMsgReq{
+			Token:       m.Token,
+			OperationID: m.OperationID,
+			MsgData:     &data,
+		}
+		log.NewInfo(m.OperationID, "Ws call success to sendMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, data)
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+		client := pbChat.NewChatClient(etcdConn)
+		reply, err := client.SendMsg(context.Background(), &pbData)
+		if err != nil {
+			log.NewError(pbData.OperationID, "UserSendMsg err", err.Error())
+			nReply.ErrCode = 200
+			nReply.ErrMsg = err.Error()
+			ws.sendMsgResp(conn, m, nReply)
+		} else {
+			log.NewInfo(pbData.OperationID, "rpc call success to sendMsgReq", reply.String())
+			ws.sendMsgResp(conn, m, reply)
+		}
+
+	} else {
+		nReply.ErrCode = errCode
+		nReply.ErrMsg = errMsg
+		ws.sendMsgResp(conn, m, nReply)
+	}
+
+}
+func (ws *WServer) sendMsgResp(conn *UserConn, m *Req, pb *pbChat.SendMsgResp) {
+	// := make(map[string]interface{})
+
+	var mReplyData sdk_ws.UserSendMsgResp
+	mReplyData.ClientMsgID = pb.GetClientMsgID()
+	mReplyData.ServerMsgID = pb.GetServerMsgID()
+	mReplyData.SendTime = pb.GetSendTime()
+	b, _ := proto.Marshal(&mReplyData)
+	mReply := Resp{
+		ReqIdentifier: m.ReqIdentifier,
+		MsgIncr:       m.MsgIncr,
+		ErrCode:       pb.GetErrCode(),
+		ErrMsg:        pb.GetErrMsg(),
+		OperationID:   m.OperationID,
+		Data:          b,
+	}
+	ws.sendMsg(conn, mReply)
+}
+
+func (ws *WServer) sendSignalMsgReq(conn *UserConn, m *Req) {
+	log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq start", m.MsgIncr, m.ReqIdentifier, m.SendID, m.Data)
+	nReply := new(pbChat.SendMsgResp)
+	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendSignalMsg)
+	if isPass {
+		signalResp := pbRtc.SignalResp{}
+		//isPass2, errCode2, errMsg2, signalResp, msgData := ws.signalMessageAssemble(pData.(*sdk_ws.SignalReq), m.OperationID)
+		connGrpc, err := grpc.Dial(config.Config.Rtc.Address+":"+strconv.Itoa(config.Config.Rtc.Port), grpc.WithInsecure())
+		if err != nil {
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), "grpc.Dial failed", err.Error())
+			ws.sendSignalMsgResp(conn, 204, "create grpc failed"+err.Error(), m, nil)
+			return
+		}
+		rtcClient := pbRtc.NewRtcServiceClient(connGrpc)
+		req := &pbRtc.SignalMessageAssembleReq{
+			SignalReq:   pData.(*pbRtc.SignalReq),
+			OperationID: m.OperationID,
+		}
+		respPb, err := rtcClient.SignalMessageAssemble(context.Background(), req)
+		if err != nil {
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), "SignalMessageAssemble", err.Error(), config.Config.Rtc.Address+":"+strconv.Itoa(config.Config.Rtc.Port))
+			ws.sendSignalMsgResp(conn, 204, "grpc SignalMessageAssemble failed: "+err.Error(), m, &signalResp)
+			return
+		}
+		signalResp.Payload = respPb.SignalResp.Payload
+		msgData := sdk_ws.MsgData{}
+		utils.CopyStructFields(&msgData, respPb.MsgData)
+		log.NewInfo(m.OperationID, utils.GetSelfFuncName(), respPb.String())
+		if respPb.IsPass {
+			pbData := pbChat.SendMsgReq{
+				Token:       m.Token,
+				OperationID: m.OperationID,
+				MsgData:     &msgData,
+			}
+			log.NewInfo(m.OperationID, utils.GetSelfFuncName(), "pbData: ", pbData)
+			log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, msgData)
+			etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+			client := pbChat.NewChatClient(etcdConn)
+			reply, err := client.SendMsg(context.Background(), &pbData)
+			if err != nil {
+				log.NewError(pbData.OperationID, utils.GetSelfFuncName(), "rpc sendMsg err", err.Error())
+				nReply.ErrCode = 200
+				nReply.ErrMsg = err.Error()
+				ws.sendSignalMsgResp(conn, 200, err.Error(), m, &signalResp)
+			} else {
+				log.NewInfo(pbData.OperationID, "rpc call success to sendMsgReq", reply.String())
+				ws.sendSignalMsgResp(conn, 0, "", m, &signalResp)
+			}
+		} else {
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), respPb.IsPass, respPb.CommonResp.ErrCode, respPb.CommonResp.ErrMsg)
+			ws.sendSignalMsgResp(conn, respPb.CommonResp.ErrCode, respPb.CommonResp.ErrMsg, m, &signalResp)
+		}
+	} else {
+		ws.sendSignalMsgResp(conn, errCode, errMsg, m, nil)
+	}
+
+}
+func (ws *WServer) sendSignalMsgResp(conn *UserConn, errCode int32, errMsg string, m *Req, pb *pbRtc.SignalResp) {
+	// := make(map[string]interface{})
+	log.Debug(m.OperationID, "SignalMsgResp is", pb.String())
+	b, _ := proto.Marshal(pb)
+	mReply := Resp{
+		ReqIdentifier: m.ReqIdentifier,
+		MsgIncr:       m.MsgIncr,
+		ErrCode:       errCode,
+		ErrMsg:        errMsg,
+		OperationID:   m.OperationID,
+		Data:          b,
+	}
+	ws.sendMsg(conn, mReply)
+}
+func (ws *WServer) sendMsg(conn *UserConn, mReply interface{}) {
+	var b bytes.Buffer
+	enc := gob.NewEncoder(&b)
+	err := enc.Encode(mReply)
+	if err != nil {
+		uid, platform := ws.getUserUid(conn)
+		log.NewError(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "Encode Msg error", conn.RemoteAddr().String(), uid, platform, err.Error())
+		return
+	}
+	err = ws.writeMsg(conn, websocket.BinaryMessage, b.Bytes())
+	if err != nil {
+		uid, platform := ws.getUserUid(conn)
+		log.NewError(mReply.(Resp).OperationID, mReply.(Resp).ReqIdentifier, mReply.(Resp).ErrCode, mReply.(Resp).ErrMsg, "WS WriteMsg error", conn.RemoteAddr().String(), uid, platform, err.Error())
+	}
+}
+func (ws *WServer) sendErrMsg(conn *UserConn, errCode int32, errMsg string, reqIdentifier int32, msgIncr string, operationID string) {
+	mReply := Resp{
+		ReqIdentifier: reqIdentifier,
+		MsgIncr:       msgIncr,
+		ErrCode:       errCode,
+		ErrMsg:        errMsg,
+		OperationID:   operationID,
+	}
+	ws.sendMsg(conn, mReply)
+}

internal/msg_gateway/gate/open_im_media/room.go

@@ -0,0 +1,58 @@
+package open_im_media
+
+const (
+	// Address gRPC服务地址
+	Address = "127.0.0.1:11300"
+)
+
+//var roomClient *lksdk.RoomServiceClient
+
+type Media struct {
+}
+
+func NewMedia() *Media {
+	return &Media{}
+}
+
+//func (m *Media) GetJoinToken(room, identity string, operationID string, data *open_im_sdk.ParticipantMetaData) (string, string, error) {
+//	var newData pbRtc.ParticipantMetaData
+//	copier.Copy(&newData, data)
+//	conn, err := grpc.Dial(Address, grpc.WithInsecure())
+//	if err != nil {
+//		return "", "", err
+//	}
+//	defer conn.Close()
+//	c := pbRtc.NewRtcServiceClient(conn)
+//	req := &pbRtc.GetJoinTokenReq{Room: room, OperationID: operationID, Identity: identity, MetaData: &newData}
+//	resp, err := c.GetJoinToken(context.Background(), req)
+//	if err != nil {
+//		return "", "", err
+//	}
+//	if resp.CommonResp.ErrCode != 0 {
+//		return "", "", errors.New(resp.CommonResp.ErrMsg)
+//	}
+//	return resp.Jwt, resp.LiveURL, nil
+//	//at := auth.NewAccessToken(m.ApiKey, m.ApiSecret)
+//	//grant := &auth.VideoGrant{
+//	//	RoomJoin: true,
+//	//	Room:     room,
+//	//}
+//	//at.AddGrant(grant).
+//	//	SetIdentity(identity).
+//	//	SetValidFor(time.Hour)
+//	//
+//	//return at.ToJWT()
+//}
+
+func init() {
+	//roomClient = lksdk.NewRoomServiceClient(MediaAddress, ApiKey, ApiSecret)
+}
+
+func (m *Media) CreateRoom(roomName string) (error, error) {
+	return nil, nil
+	//return roomClient.CreateRoom(context.Background(), &livekit.CreateRoomRequest{
+	//	Name:         roomName,
+	//	EmptyTimeout: 60 * 3,
+	//})
+
+}

internal/msg_gateway/gate/rpc_server.go

@@ -0,0 +1,149 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbRelay "Open_IM/pkg/proto/relay"
+	"Open_IM/pkg/utils"
+	"bytes"
+	"context"
+	"encoding/gob"
+	"fmt"
+	"github.com/golang/protobuf/proto"
+	"net"
+	"strings"
+
+	"github.com/gorilla/websocket"
+	"google.golang.org/grpc"
+)
+
+type RPCServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func (r *RPCServer) onInit(rpcPort int) {
+	r.rpcPort = rpcPort
+	r.rpcRegisterName = config.Config.RpcRegisterName.OpenImOnlineMessageRelayName
+	r.etcdSchema = config.Config.Etcd.EtcdSchema
+	r.etcdAddr = config.Config.Etcd.EtcdAddr
+}
+func (r *RPCServer) run() {
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + utils.IntToString(r.rpcPort)
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.ErrorByArgs(fmt.Sprintf("fail to listening consumer, err:%v\n", err))
+		return
+	}
+	defer listener.Close()
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	pbRelay.RegisterOnlineMessageRelayServiceServer(srv, r)
+	err = getcdv3.RegisterEtcd4Unique(r.etcdSchema, strings.Join(r.etcdAddr, ","), ip, r.rpcPort, r.rpcRegisterName, 10)
+	if err != nil {
+		log.ErrorByKv("register push message rpc to etcd err", "", "err", err.Error())
+	}
+	err = srv.Serve(listener)
+	if err != nil {
+		log.ErrorByKv("push message rpc listening err", "", "err", err.Error())
+		return
+	}
+}
+func (r *RPCServer) OnlinePushMsg(_ context.Context, in *pbRelay.OnlinePushMsgReq) (*pbRelay.OnlinePushMsgResp, error) {
+	log.InfoByKv("PushMsgToUser is arriving", in.OperationID, "args", in.String())
+	var resp []*pbRelay.SingleMsgToUser
+	msgBytes, _ := proto.Marshal(in.MsgData)
+	mReply := Resp{
+		ReqIdentifier: constant.WSPushMsg,
+		OperationID:   in.OperationID,
+		Data:          msgBytes,
+	}
+	var replyBytes bytes.Buffer
+	enc := gob.NewEncoder(&replyBytes)
+	err := enc.Encode(mReply)
+	if err != nil {
+		log.NewError(in.OperationID, "data encode err", err.Error())
+	}
+	var tag bool
+	recvID := in.PushToUserID
+	platformList := genPlatformArray()
+	for _, v := range platformList {
+		if conn := ws.getUserConn(recvID, v); conn != nil {
+			tag = true
+			resultCode := sendMsgToUser(conn, replyBytes.Bytes(), in, v, recvID)
+			temp := &pbRelay.SingleMsgToUser{
+				ResultCode:     resultCode,
+				RecvID:         recvID,
+				RecvPlatFormID: constant.PlatformNameToID(v),
+			}
+			resp = append(resp, temp)
+		} else {
+			temp := &pbRelay.SingleMsgToUser{
+				ResultCode:     -1,
+				RecvID:         recvID,
+				RecvPlatFormID: constant.PlatformNameToID(v),
+			}
+			resp = append(resp, temp)
+		}
+	}
+	if !tag {
+		log.NewError(in.OperationID, "push err ,no matched ws conn not in map", in.String())
+	}
+	return &pbRelay.OnlinePushMsgResp{
+		Resp: resp,
+	}, nil
+}
+func (r *RPCServer) GetUsersOnlineStatus(_ context.Context, req *pbRelay.GetUsersOnlineStatusReq) (*pbRelay.GetUsersOnlineStatusResp, error) {
+	log.NewInfo(req.OperationID, "rpc GetUsersOnlineStatus arrived server", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "no permission GetUsersOnlineStatus ", req.OpUserID)
+		return &pbRelay.GetUsersOnlineStatusResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	var resp pbRelay.GetUsersOnlineStatusResp
+	for _, userID := range req.UserIDList {
+		platformList := genPlatformArray()
+		temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult)
+		temp.UserID = userID
+		for _, platform := range platformList {
+			if conn := ws.getUserConn(userID, platform); conn != nil {
+				ps := new(pbRelay.GetUsersOnlineStatusResp_SuccessDetail)
+				ps.Platform = platform
+				ps.Status = constant.OnlineStatus
+				temp.Status = constant.OnlineStatus
+				temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, ps)
+
+			}
+		}
+		if temp.Status == constant.OnlineStatus {
+			resp.SuccessResult = append(resp.SuccessResult, temp)
+		}
+	}
+	log.NewInfo(req.OperationID, "GetUsersOnlineStatus rpc return ", resp.String())
+	return &resp, nil
+}
+func sendMsgToUser(conn *UserConn, bMsg []byte, in *pbRelay.OnlinePushMsgReq, RecvPlatForm, RecvID string) (ResultCode int64) {
+	err := ws.writeMsg(conn, websocket.BinaryMessage, bMsg)
+	if err != nil {
+		log.ErrorByKv("PushMsgToUser is failed By Ws", "", "Addr", conn.RemoteAddr().String(),
+			"error", err, "senderPlatform", constant.PlatformIDToName(in.MsgData.SenderPlatformID), "recvPlatform", RecvPlatForm, "args", in.String(), "recvID", RecvID)
+		ResultCode = -2
+		return ResultCode
+	} else {
+		log.InfoByKv("PushMsgToUser is success By Ws", in.OperationID, "args", in.String(), "recvPlatForm", RecvPlatForm, "recvID", RecvID)
+		ResultCode = 0
+		return ResultCode
+	}
+
+}
+func genPlatformArray() (array []string) {
+	for i := 1; i <= constant.LinuxPlatformID; i++ {
+		array = append(array, constant.PlatformIDToName(int32(i)))
+	}
+	return array
+}

internal/msg_gateway/gate/validate.go

@@ -0,0 +1,253 @@
+/*
+** description("").
+** copyright('Open_IM,www.Open_IM.io').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/5/21 15:29).
+ */
+package gate
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	pbRtc "Open_IM/pkg/proto/rtc"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"github.com/golang/protobuf/proto"
+)
+
+type Req struct {
+	ReqIdentifier int32  `json:"reqIdentifier" validate:"required"`
+	Token         string `json:"token" `
+	SendID        string `json:"sendID" validate:"required"`
+	OperationID   string `json:"operationID" validate:"required"`
+	MsgIncr       string `json:"msgIncr" validate:"required"`
+	Data          []byte `json:"data"`
+}
+type Resp struct {
+	ReqIdentifier int32  `json:"reqIdentifier"`
+	MsgIncr       string `json:"msgIncr"`
+	OperationID   string `json:"operationID"`
+	ErrCode       int32  `json:"errCode"`
+	ErrMsg        string `json:"errMsg"`
+	Data          []byte `json:"data"`
+}
+
+type SeqData struct {
+	SeqBegin int64 `mapstructure:"seqBegin" validate:"required"`
+	SeqEnd   int64 `mapstructure:"seqEnd" validate:"required"`
+}
+type MsgData struct {
+	PlatformID  int32                  `mapstructure:"platformID" validate:"required"`
+	SessionType int32                  `mapstructure:"sessionType" validate:"required"`
+	MsgFrom     int32                  `mapstructure:"msgFrom" validate:"required"`
+	ContentType int32                  `mapstructure:"contentType" validate:"required"`
+	RecvID      string                 `mapstructure:"recvID" validate:"required"`
+	ForceList   []string               `mapstructure:"forceList"`
+	Content     string                 `mapstructure:"content" validate:"required"`
+	Options     map[string]interface{} `mapstructure:"options" validate:"required"`
+	ClientMsgID string                 `mapstructure:"clientMsgID" validate:"required"`
+	OfflineInfo map[string]interface{} `mapstructure:"offlineInfo" validate:"required"`
+	Ext         map[string]interface{} `mapstructure:"ext"`
+}
+type MaxSeqResp struct {
+	MaxSeq int64 `json:"maxSeq"`
+}
+type PullMessageResp struct {
+}
+type SeqListData struct {
+	SeqList []int64 `mapstructure:"seqList" validate:"required"`
+}
+
+func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, errMsg string, returnData interface{}) {
+	switch r {
+	case constant.WSSendMsg:
+		data := open_im_sdk.MsgData{}
+		if err := proto.Unmarshal(m.Data, &data); err != nil {
+			log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 203, err.Error(), nil
+		}
+		if err := validate.Struct(data); err != nil {
+			log.ErrorByKv("data args validate  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 204, err.Error(), nil
+
+		}
+		return true, 0, "", data
+	case constant.WSSendSignalMsg:
+		data := pbRtc.SignalReq{}
+		if err := proto.Unmarshal(m.Data, &data); err != nil {
+			log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 203, err.Error(), nil
+		}
+		if err := validate.Struct(data); err != nil {
+			log.ErrorByKv("data args validate  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 204, err.Error(), nil
+
+		}
+		return true, 0, "", &data
+	case constant.WSPullMsgBySeqList:
+		data := open_im_sdk.PullMessageBySeqListReq{}
+		if err := proto.Unmarshal(m.Data, &data); err != nil {
+			log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 203, err.Error(), nil
+		}
+		if err := validate.Struct(data); err != nil {
+			log.ErrorByKv("data args validate  err", "", "err", err.Error(), "reqIdentifier", r)
+			return false, 204, err.Error(), nil
+
+		}
+		return true, 0, "", data
+
+	default:
+	}
+
+	return false, 204, "args err", nil
+
+	//b := bytes.NewBuffer(m.Data)
+	//dec := gob.NewDecoder(b)
+	//err := dec.Decode(&data)
+	//if err != nil {
+	//	log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+	//	return false, 203, err.Error(), nil
+	//}
+	//if err := mapstructure.WeakDecode(m.Data, &data); err != nil {
+	//	log.ErrorByKv("map to Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
+	//	return false, 203, err.Error(), nil
+	//} else
+
+}
+
+//func (ws *WServer) signalMessageAssemble(s *open_im_sdk.SignalReq, operationID string) (isPass bool, errCode int32, errMsg string, r *open_im_sdk.SignalResp, msgData *open_im_sdk.MsgData) {
+//	var msg open_im_sdk.MsgData
+//	var resp open_im_sdk.SignalResp
+//	media := open_im_media.NewMedia()
+//	msg.MsgFrom = constant.UserMsgType
+//	msg.ContentType = constant.SignalingNotification
+//	reqData, e := proto.Marshal(s)
+//	if e != nil {
+//		return false, 201, e.Error(), nil, nil
+//	}
+//	msg.Content = reqData
+//	msg.CreateTime = utils.GetCurrentTimestampByMill()
+//	options := make(map[string]bool, 6)
+//	utils.SetSwitchFromOptions(options, constant.IsHistory, false)
+//	utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
+//	utils.SetSwitchFromOptions(options, constant.IsSenderSync, true)
+//	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
+//	utils.SetSwitchFromOptions(options, constant.IsSenderConversationUpdate, false)
+//	utils.SetSwitchFromOptions(options, constant.IsUnreadCount, false)
+//	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, true)
+//	msg.Options = options
+//	switch payload := s.Payload.(type) {
+//	case *open_im_sdk.SignalReq_Invite:
+//		token, liveURL, err2 := media.GetJoinToken(payload.Invite.Invitation.RoomID, payload.Invite.Invitation.InviterUserID, operationID, payload.Invite.Participant)
+//		if err2 != nil {
+//			return false, 202, err2.Error(), nil, nil
+//		}
+//		invite := open_im_sdk.SignalResp_Invite{&open_im_sdk.SignalInviteReply{
+//			Token:   token,
+//			RoomID:  payload.Invite.Invitation.RoomID,
+//			LiveURL: liveURL,
+//		}}
+//		resp.Payload = &invite
+//		msg.SenderPlatformID = payload.Invite.Invitation.PlatformID
+//		msg.SessionType = payload.Invite.Invitation.SessionType
+//		msg.OfflinePushInfo = payload.Invite.OfflinePushInfo
+//		msg.SendID = payload.Invite.Invitation.InviterUserID
+//		if len(payload.Invite.Invitation.InviteeUserIDList) > 0 {
+//			msg.RecvID = payload.Invite.Invitation.InviteeUserIDList[0]
+//		} else {
+//			return false, 203, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Invite.Invitation.InviterUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_InviteInGroup:
+//		token, liveURL, err2 := media.GetJoinToken(payload.InviteInGroup.Invitation.RoomID, payload.InviteInGroup.Invitation.InviterUserID, operationID, payload.InviteInGroup.Participant)
+//		if err2 != nil {
+//			return false, 204, err2.Error(), nil, nil
+//		}
+//		inviteGroup := open_im_sdk.SignalResp_InviteInGroup{&open_im_sdk.SignalInviteInGroupReply{
+//			RoomID:  payload.InviteInGroup.Invitation.RoomID,
+//			Token:   token,
+//			LiveURL: liveURL,
+//		}}
+//		resp.Payload = &inviteGroup
+//		msg.SenderPlatformID = payload.InviteInGroup.Invitation.PlatformID
+//		msg.SessionType = payload.InviteInGroup.Invitation.SessionType
+//		msg.OfflinePushInfo = payload.InviteInGroup.OfflinePushInfo
+//		msg.SendID = payload.InviteInGroup.Invitation.InviterUserID
+//		if len(payload.InviteInGroup.Invitation.InviteeUserIDList) > 0 {
+//			msg.GroupID = payload.InviteInGroup.Invitation.GroupID
+//		} else {
+//			return false, 205, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.InviteInGroup.Invitation.InviterUserID)
+//
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_Cancel:
+//		cancel := open_im_sdk.SignalResp_Cancel{&open_im_sdk.SignalCancelReply{}}
+//		resp.Payload = &cancel
+//		msg.OfflinePushInfo = payload.Cancel.OfflinePushInfo
+//		msg.SendID = payload.Cancel.Invitation.InviterUserID
+//		msg.SenderPlatformID = payload.Cancel.Invitation.PlatformID
+//		msg.SessionType = payload.Cancel.Invitation.SessionType
+//		if len(payload.Cancel.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Cancel.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Cancel.Invitation.InviteeUserIDList[0]
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Cancel.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 206, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Cancel.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_Accept:
+//		token, liveURL, err2 := media.GetJoinToken(payload.Accept.Invitation.RoomID, payload.Accept.OpUserID, operationID, payload.Accept.Participant)
+//		if err2 != nil {
+//			return false, 207, err2.Error(), nil, nil
+//		}
+//		accept := open_im_sdk.SignalResp_Accept{&open_im_sdk.SignalAcceptReply{
+//			Token:   token,
+//			LiveURL: liveURL,
+//			RoomID:  payload.Accept.Invitation.RoomID,
+//		}}
+//		resp.Payload = &accept
+//		msg.OfflinePushInfo = payload.Accept.OfflinePushInfo
+//		msg.SendID = payload.Accept.OpUserID
+//		msg.SenderPlatformID = payload.Accept.Invitation.PlatformID
+//		msg.SessionType = payload.Accept.Invitation.SessionType
+//		if len(payload.Accept.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Accept.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Accept.Invitation.InviterUserID
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Accept.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 208, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Accept.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_HungUp:
+//	case *open_im_sdk.SignalReq_Reject:
+//		reject := open_im_sdk.SignalResp_Reject{&open_im_sdk.SignalRejectReply{}}
+//		resp.Payload = &reject
+//		msg.OfflinePushInfo = payload.Reject.OfflinePushInfo
+//		msg.SendID = payload.Reject.OpUserID
+//		msg.SenderPlatformID = payload.Reject.Invitation.PlatformID
+//		msg.SessionType = payload.Reject.Invitation.SessionType
+//		if len(payload.Reject.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Reject.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Reject.Invitation.InviterUserID
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Reject.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 209, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Reject.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	}
+//	return false, 210, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//}

internal/msg_gateway/gate/ws_server.go

@@ -0,0 +1,285 @@
+package gate
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/utils"
+	"bytes"
+	"encoding/gob"
+	"github.com/garyburd/redigo/redis"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type UserConn struct {
+	*websocket.Conn
+	w *sync.Mutex
+}
+type WServer struct {
+	wsAddr       string
+	wsMaxConnNum int
+	wsUpGrader   *websocket.Upgrader
+	wsConnToUser map[*UserConn]map[string]string
+	wsUserToConn map[string]map[string]*UserConn
+}
+
+func (ws *WServer) onInit(wsPort int) {
+	ws.wsAddr = ":" + utils.IntToString(wsPort)
+	ws.wsMaxConnNum = config.Config.LongConnSvr.WebsocketMaxConnNum
+	ws.wsConnToUser = make(map[*UserConn]map[string]string)
+	ws.wsUserToConn = make(map[string]map[string]*UserConn)
+	ws.wsUpGrader = &websocket.Upgrader{
+		HandshakeTimeout: time.Duration(config.Config.LongConnSvr.WebsocketTimeOut) * time.Second,
+		ReadBufferSize:   config.Config.LongConnSvr.WebsocketMaxMsgLen,
+		CheckOrigin:      func(r *http.Request) bool { return true },
+	}
+}
+
+func (ws *WServer) run() {
+	http.HandleFunc("/", ws.wsHandler)         //Get request from client to handle by wsHandler
+	err := http.ListenAndServe(ws.wsAddr, nil) //Start listening
+	if err != nil {
+		log.ErrorByKv("Ws listening err", "", "err", err.Error())
+	}
+}
+
+func (ws *WServer) wsHandler(w http.ResponseWriter, r *http.Request) {
+	if ws.headerCheck(w, r) {
+		query := r.URL.Query()
+		conn, err := ws.wsUpGrader.Upgrade(w, r, nil) //Conn is obtained through the upgraded escalator
+		if err != nil {
+			log.ErrorByKv("upgrade http conn err", "", "err", err)
+			return
+		} else {
+			//Connection mapping relationship,
+			//userID+" "+platformID->conn
+
+			//Initialize a lock for each user
+			newConn := &UserConn{conn, new(sync.Mutex)}
+			ws.addUserConn(query["sendID"][0], int32(utils.StringToInt64(query["platformID"][0])), newConn, query["token"][0])
+			go ws.readMsg(newConn)
+		}
+	}
+}
+
+func (ws *WServer) readMsg(conn *UserConn) {
+	for {
+		messageType, msg, err := conn.ReadMessage()
+		if messageType == websocket.PingMessage {
+			log.NewInfo("", "this is a  pingMessage")
+		}
+		if err != nil {
+			uid, platform := ws.getUserUid(conn)
+			log.ErrorByKv("WS ReadMsg error", "", "userIP", conn.RemoteAddr().String(), "userUid", uid, "platform", platform, "error", err.Error())
+			ws.delUserConn(conn)
+			return
+		} else {
+			//log.ErrorByKv("test", "", "msgType", msgType, "userIP", conn.RemoteAddr().String(), "userUid", ws.getUserUid(conn))
+		}
+		ws.msgParse(conn, msg)
+		//ws.writeMsg(conn, 1, chat)
+	}
+
+}
+func (ws *WServer) writeMsg(conn *UserConn, a int, msg []byte) error {
+	conn.w.Lock()
+	defer conn.w.Unlock()
+	return conn.WriteMessage(a, msg)
+
+}
+func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int32, newConn *UserConn, token string, operationID string) {
+	switch config.Config.MultiLoginPolicy {
+	case constant.AllLoginButSameTermKick:
+		if oldConnMap, ok := ws.wsUserToConn[uid]; ok { // user->map[platform->conn]
+			if oldConn, ok := oldConnMap[constant.PlatformIDToName(platformID)]; ok {
+				log.NewDebug(operationID, uid, platformID, "kick old conn")
+				ws.sendKickMsg(oldConn, newConn)
+				m, err := db.DB.GetTokenMapByUidPid(uid, constant.PlatformIDToName(platformID))
+				if err != nil && err != redis.ErrNil {
+					log.NewError(operationID, "get token from redis err", err.Error())
+					return
+				}
+				if m == nil {
+					log.NewError(operationID, "get token from redis err", "m is nil")
+					return
+				}
+				for k, _ := range m {
+					if k != token {
+						m[k] = constant.KickedToken
+					}
+				}
+				log.NewDebug(operationID, "get map is ", m)
+				err = db.DB.SetTokenMapByUidPid(uid, platformID, m)
+				if err != nil {
+					log.NewError(operationID, "SetTokenMapByUidPid err", err.Error())
+					return
+				}
+				err = oldConn.Close()
+				delete(oldConnMap, constant.PlatformIDToName(platformID))
+				ws.wsUserToConn[uid] = oldConnMap
+				if len(oldConnMap) == 0 {
+					delete(ws.wsUserToConn, uid)
+				}
+				delete(ws.wsConnToUser, oldConn)
+				if err != nil {
+					log.NewError(operationID, "conn close err", err.Error(), uid, platformID)
+				}
+
+			} else {
+				log.NewWarn(operationID, "abnormal uid-conn  ", uid, platformID, oldConnMap[constant.PlatformIDToName(platformID)])
+			}
+
+		} else {
+			log.NewDebug(operationID, "no other conn", ws.wsUserToConn, uid, platformID)
+		}
+
+	case constant.SingleTerminalLogin:
+	case constant.WebAndOther:
+	}
+}
+func (ws *WServer) sendKickMsg(oldConn, newConn *UserConn) {
+	mReply := Resp{
+		ReqIdentifier: constant.WSKickOnlineMsg,
+		ErrCode:       constant.ErrTokenInvalid.ErrCode,
+		ErrMsg:        constant.ErrTokenInvalid.ErrMsg,
+	}
+	var b bytes.Buffer
+	enc := gob.NewEncoder(&b)
+	err := enc.Encode(mReply)
+	if err != nil {
+		log.NewError(mReply.OperationID, mReply.ReqIdentifier, mReply.ErrCode, mReply.ErrMsg, "Encode Msg error", oldConn.RemoteAddr().String(), newConn.RemoteAddr().String(), err.Error())
+		return
+	}
+	err = ws.writeMsg(oldConn, websocket.BinaryMessage, b.Bytes())
+	if err != nil {
+		log.NewError(mReply.OperationID, mReply.ReqIdentifier, mReply.ErrCode, mReply.ErrMsg, "WS WriteMsg error", oldConn.RemoteAddr().String(), newConn.RemoteAddr().String(), err.Error())
+	}
+}
+func (ws *WServer) addUserConn(uid string, platformID int32, conn *UserConn, token string) {
+	rwLock.Lock()
+	defer rwLock.Unlock()
+	operationID := utils.OperationIDGenerator()
+	ws.MultiTerminalLoginChecker(uid, platformID, conn, token, operationID)
+	if oldConnMap, ok := ws.wsUserToConn[uid]; ok {
+		oldConnMap[constant.PlatformIDToName(platformID)] = conn
+		ws.wsUserToConn[uid] = oldConnMap
+		log.Debug(operationID, "user not first come in, add conn ", uid, platformID, conn, oldConnMap)
+	} else {
+		i := make(map[string]*UserConn)
+		i[constant.PlatformIDToName(platformID)] = conn
+		ws.wsUserToConn[uid] = i
+		log.Debug(operationID, "user first come in, new user, conn", uid, platformID, conn, ws.wsUserToConn[uid])
+	}
+	if oldStringMap, ok := ws.wsConnToUser[conn]; ok {
+		oldStringMap[constant.PlatformIDToName(platformID)] = uid
+		ws.wsConnToUser[conn] = oldStringMap
+	} else {
+		i := make(map[string]string)
+		i[constant.PlatformIDToName(platformID)] = uid
+		ws.wsConnToUser[conn] = i
+	}
+	count := 0
+	for _, v := range ws.wsUserToConn {
+		count = count + len(v)
+	}
+	log.Debug(operationID, "WS Add operation", "", "wsUser added", ws.wsUserToConn, "connection_uid", uid, "connection_platform", constant.PlatformIDToName(platformID), "online_user_num", len(ws.wsUserToConn), "online_conn_num", count)
+	userCount = uint64(len(ws.wsUserToConn))
+
+}
+
+func (ws *WServer) delUserConn(conn *UserConn) {
+	rwLock.Lock()
+	defer rwLock.Unlock()
+	var platform, uid string
+	if oldStringMap, ok := ws.wsConnToUser[conn]; ok {
+		for k, v := range oldStringMap {
+			platform = k
+			uid = v
+		}
+		if oldConnMap, ok := ws.wsUserToConn[uid]; ok {
+			delete(oldConnMap, platform)
+			ws.wsUserToConn[uid] = oldConnMap
+			if len(oldConnMap) == 0 {
+				delete(ws.wsUserToConn, uid)
+			}
+			count := 0
+			for _, v := range ws.wsUserToConn {
+				count = count + len(v)
+			}
+			log.WarnByKv("WS delete operation", "", "wsUser deleted", ws.wsUserToConn, "disconnection_uid", uid, "disconnection_platform", platform, "online_user_num", len(ws.wsUserToConn), "online_conn_num", count)
+		} else {
+			log.WarnByKv("WS delete operation", "", "wsUser deleted", ws.wsUserToConn, "disconnection_uid", uid, "disconnection_platform", platform, "online_user_num", len(ws.wsUserToConn))
+		}
+		userCount = uint64(len(ws.wsUserToConn))
+		delete(ws.wsConnToUser, conn)
+
+	}
+	err := conn.Close()
+	if err != nil {
+		log.ErrorByKv("close err", "", "uid", uid, "platform", platform)
+
+	}
+
+}
+
+func (ws *WServer) getUserConn(uid string, platform string) *UserConn {
+	rwLock.RLock()
+	defer rwLock.RUnlock()
+	if connMap, ok := ws.wsUserToConn[uid]; ok {
+		if conn, flag := connMap[platform]; flag {
+			return conn
+		}
+	}
+	return nil
+}
+func (ws *WServer) getSingleUserAllConn(uid string) map[string]*UserConn {
+	rwLock.RLock()
+	defer rwLock.RUnlock()
+	if connMap, ok := ws.wsUserToConn[uid]; ok {
+		return connMap
+	}
+	return nil
+}
+func (ws *WServer) getUserUid(conn *UserConn) (uid, platform string) {
+	rwLock.RLock()
+	defer rwLock.RUnlock()
+
+	if stringMap, ok := ws.wsConnToUser[conn]; ok {
+		for k, v := range stringMap {
+			platform = k
+			uid = v
+		}
+		return uid, platform
+	}
+	return "", ""
+}
+func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request) bool {
+	status := http.StatusUnauthorized
+	query := r.URL.Query()
+	if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 {
+		if ok, err, msg := token_verify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0]); !ok {
+			e := err.(*constant.ErrInfo)
+			log.ErrorByKv("Token verify failed", "", "query", query, msg)
+			w.Header().Set("Sec-Websocket-Version", "13")
+			http.Error(w, e.ErrMsg, int(e.ErrCode))
+			return false
+		} else {
+			log.InfoByKv("Connection Authentication Success", "", "token", query["token"][0], "userID", query["sendID"][0])
+			return true
+		}
+	} else {
+		log.ErrorByKv("Args err", "", "query", query)
+		w.Header().Set("Sec-Websocket-Version", "13")
+		http.Error(w, http.StatusText(status), status)
+		return false
+	}
+}
+func genMapKey(uid string, platformID int32) string {
+	return uid + " " + constant.PlatformIDToName(platformID)
+}

internal/msg_transfer/logic/db.go

@@ -0,0 +1,23 @@
+package logic
+
+import (
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	pbMsg "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
+)
+
+func saveUserChat(uid string, msg *pbMsg.MsgDataToMQ) error {
+	time := utils.GetCurrentTimestampByMill()
+	seq, err := db.DB.IncrUserSeq(uid)
+	if err != nil {
+		log.NewError(msg.OperationID, "data insert to redis err", err.Error(), msg.String())
+		return err
+	}
+	msg.MsgData.Seq = uint32(seq)
+	pbSaveData := pbMsg.MsgDataToDB{}
+	pbSaveData.MsgData = msg.MsgData
+	log.NewInfo(msg.OperationID, "IncrUserSeq cost time", utils.GetCurrentTimestampByMill()-time)
+	return db.DB.SaveUserChatMongo2(uid, pbSaveData.MsgData.SendTime, &pbSaveData)
+//	return db.DB.SaveUserChatMongo2(uid, pbSaveData.MsgData.SendTime, &pbSaveData)
+}

internal/msg_transfer/logic/history_msg_handler.go

@@ -0,0 +1,142 @@
+package logic
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	kfk "Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbMsg "Open_IM/pkg/proto/chat"
+	pbPush "Open_IM/pkg/proto/push"
+	"Open_IM/pkg/statistics"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/Shopify/sarama"
+	"github.com/golang/protobuf/proto"
+	"strings"
+)
+
+type fcb func(msg []byte, msgKey string)
+
+type HistoryConsumerHandler struct {
+	msgHandle            map[string]fcb
+	historyConsumerGroup *kfk.MConsumerGroup
+	singleMsgCount       uint64
+	groupMsgCount        uint64
+}
+
+func (mc *HistoryConsumerHandler) Init() {
+	statistics.NewStatistics(&mc.singleMsgCount, config.Config.ModuleName.MsgTransferName, "singleMsgCount insert to mongo ", 300)
+	statistics.NewStatistics(&mc.groupMsgCount, config.Config.ModuleName.MsgTransferName, "groupMsgCount insert to mongo ", 300)
+
+	mc.msgHandle = make(map[string]fcb)
+	mc.msgHandle[config.Config.Kafka.Ws2mschat.Topic] = mc.handleChatWs2Mongo
+	mc.historyConsumerGroup = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V0_10_2_0,
+		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.Ws2mschat.Topic},
+		config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.ConsumerGroupID.MsgToMongo)
+
+}
+
+func (mc *HistoryConsumerHandler) handleChatWs2Mongo(msg []byte, msgKey string) {
+	time := utils.GetCurrentTimestampByNano()
+	msgFromMQ := pbMsg.MsgDataToMQ{}
+	err := proto.Unmarshal(msg, &msgFromMQ)
+	if err != nil {
+		log.Error("msg_transfer Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
+		return
+	}
+	operationID := msgFromMQ.OperationID
+	log.NewInfo(operationID, "msg come mongo!!!", "", "msg", string(msg))
+	//Control whether to store offline messages (mongo)
+	isHistory := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsHistory)
+	//Control whether to store history messages (mysql)
+	isPersist := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsPersistent)
+	isSenderSync := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsSenderSync)
+	switch msgFromMQ.MsgData.SessionType {
+	case constant.SingleChatType:
+		log.NewDebug(msgFromMQ.OperationID, "msg_transfer msg type = SingleChatType", isHistory, isPersist)
+		if isHistory {
+			err := saveUserChat(msgKey, &msgFromMQ)
+			if err != nil {
+				log.NewError(operationID, "single data insert to mongo err", err.Error(), msgFromMQ.String())
+				return
+			}
+			mc.singleMsgCount++
+			log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", utils.GetCurrentTimestampByNano()-time)
+		}
+		if !isSenderSync && msgKey == msgFromMQ.MsgData.SendID {
+		} else {
+			go sendMessageToPush(&msgFromMQ, msgKey)
+		}
+		log.NewDebug(operationID, "saveUserChat cost time ", utils.GetCurrentTimestampByNano()-time)
+	case constant.GroupChatType:
+		log.NewDebug(msgFromMQ.OperationID, "msg_transfer msg type = GroupChatType", isHistory, isPersist)
+		if isHistory {
+			err := saveUserChat(msgFromMQ.MsgData.RecvID, &msgFromMQ)
+			if err != nil {
+				log.NewError(operationID, "group data insert to mongo err", msgFromMQ.String(), msgFromMQ.MsgData.RecvID, err.Error())
+				return
+			}
+			mc.groupMsgCount++
+		}
+		go sendMessageToPush(&msgFromMQ, msgFromMQ.MsgData.RecvID)
+	case constant.NotificationChatType:
+		log.NewDebug(msgFromMQ.OperationID, "msg_transfer msg type = NotificationChatType", isHistory, isPersist)
+		if isHistory {
+			err := saveUserChat(msgKey, &msgFromMQ)
+			if err != nil {
+				log.NewError(operationID, "single data insert to mongo err", err.Error(), msgFromMQ.String())
+				return
+			}
+			mc.singleMsgCount++
+			log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", utils.GetCurrentTimestampByNano()-time)
+		}
+		if !isSenderSync && msgKey == msgFromMQ.MsgData.SendID {
+		} else {
+			go sendMessageToPush(&msgFromMQ, msgKey)
+		}
+		log.NewDebug(operationID, "saveUserChat cost time ", utils.GetCurrentTimestampByNano()-time)
+	default:
+		log.NewError(msgFromMQ.OperationID, "SessionType error", msgFromMQ.String())
+		return
+	}
+	log.NewDebug(msgFromMQ.OperationID, "msg_transfer handle topic data to database success...", msgFromMQ.String())
+}
+
+func (HistoryConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
+func (HistoryConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
+func (mc *HistoryConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
+	claim sarama.ConsumerGroupClaim) error {
+	for msg := range claim.Messages() {
+		log.InfoByKv("kafka get info to mongo", "", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value))
+		mc.msgHandle[msg.Topic](msg.Value, string(msg.Key))
+		sess.MarkMessage(msg, "")
+	}
+	return nil
+}
+func sendMessageToPush(message *pbMsg.MsgDataToMQ, pushToUserID string) {
+	log.Info(message.OperationID, "msg_transfer send message to push", "message", message.String())
+	rpcPushMsg := pbPush.PushMsgReq{OperationID: message.OperationID, MsgData: message.MsgData, PushToUserID: pushToUserID}
+	mqPushMsg := pbMsg.PushMsgDataToMQ{OperationID: message.OperationID, MsgData: message.MsgData, PushToUserID: pushToUserID}
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImPushName)
+	if grpcConn == nil {
+		log.Error(rpcPushMsg.OperationID, "rpc dial failed", "push data", rpcPushMsg.String())
+		pid, offset, err := producer.SendMessage(&mqPushMsg)
+		if err != nil {
+			log.Error(mqPushMsg.OperationID, "kafka send failed", "send data", message.String(), "pid", pid, "offset", offset, "err", err.Error())
+		}
+		return
+	}
+	msgClient := pbPush.NewPushMsgServiceClient(grpcConn)
+	_, err := msgClient.PushMsg(context.Background(), &rpcPushMsg)
+	if err != nil {
+		log.Error(rpcPushMsg.OperationID, "rpc send failed", rpcPushMsg.OperationID, "push data", rpcPushMsg.String(), "err", err.Error())
+		pid, offset, err := producer.SendMessage(&mqPushMsg)
+		if err != nil {
+			log.Error("kafka send failed", mqPushMsg.OperationID, "send data", mqPushMsg.String(), "pid", pid, "offset", offset, "err", err.Error())
+		}
+	} else {
+		log.Info("rpc send success", rpcPushMsg.OperationID, "push data", rpcPushMsg.String())
+
+	}
+}

internal/msg_transfer/logic/init.go

@@ -0,0 +1,25 @@
+package logic
+
+import (
+	"Open_IM/pkg/common/config"
+
+	"Open_IM/pkg/common/kafka"
+)
+
+var (
+	persistentCH PersistentConsumerHandler
+	historyCH    HistoryConsumerHandler
+	producer     *kafka.Producer
+)
+
+func Init() {
+
+	persistentCH.Init()
+	historyCH.Init()
+	producer = kafka.NewKafkaProducer(config.Config.Kafka.Ms2pschat.Addr, config.Config.Kafka.Ms2pschat.Topic)
+}
+func Run() {
+	//register mysqlConsumerHandler to
+	go persistentCH.persistentConsumerGroup.RegisterHandleAndConsumer(&persistentCH)
+	go historyCH.historyConsumerGroup.RegisterHandleAndConsumer(&historyCH)
+}

internal/msg_transfer/logic/persistent_msg_handler.go

@@ -0,0 +1,78 @@
+/*
+** description("").
+** copyright('tuoyun,www.tuoyun.net').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/5/11 15:37).
+ */
+package logic
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/mysql_model/im_mysql_msg_model"
+	kfk "Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/common/log"
+	pbMsg "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
+	"github.com/Shopify/sarama"
+	"github.com/golang/protobuf/proto"
+)
+
+type PersistentConsumerHandler struct {
+	msgHandle               map[string]fcb
+	persistentConsumerGroup *kfk.MConsumerGroup
+}
+
+func (pc *PersistentConsumerHandler) Init() {
+	pc.msgHandle = make(map[string]fcb)
+	pc.msgHandle[config.Config.Kafka.Ws2mschat.Topic] = pc.handleChatWs2Mysql
+	pc.persistentConsumerGroup = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V0_10_2_0,
+		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.Ws2mschat.Topic},
+		config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.ConsumerGroupID.MsgToMySql)
+
+}
+
+func (pc *PersistentConsumerHandler) handleChatWs2Mysql(msg []byte, msgKey string) {
+	log.NewInfo("msg come here mysql!!!", "", "msg", string(msg))
+	var tag bool
+	msgFromMQ := pbMsg.MsgDataToMQ{}
+	err := proto.Unmarshal(msg, &msgFromMQ)
+	if err != nil {
+		log.NewError(msgFromMQ.OperationID, "msg_transfer Unmarshal msg err", "msg", string(msg), "err", err.Error())
+		return
+	}
+	//Control whether to store history messages (mysql)
+	isPersist := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsPersistent)
+	//Only process receiver data
+	if isPersist {
+		switch msgFromMQ.MsgData.SessionType {
+		case constant.SingleChatType, constant.NotificationChatType:
+			if msgKey == msgFromMQ.MsgData.RecvID {
+				tag = true
+			}
+		case constant.GroupChatType:
+			if msgKey == msgFromMQ.MsgData.SendID || utils.IsContain(msgFromMQ.MsgData.SendID, config.Config.Manager.AppManagerUid) {
+				tag = true
+			}
+		}
+		if tag {
+			log.NewInfo(msgFromMQ.OperationID, "msg_transfer msg persisting", string(msg))
+			if err = im_mysql_msg_model.InsertMessageToChatLog(msgFromMQ); err != nil {
+				log.NewError(msgFromMQ.OperationID, "Message insert failed", "err", err.Error(), "msg", msgFromMQ.String())
+				return
+			}
+		}
+
+	}
+}
+func (PersistentConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
+func (PersistentConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
+func (pc *PersistentConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
+	claim sarama.ConsumerGroupClaim) error {
+	for msg := range claim.Messages() {
+		log.InfoByKv("kafka get info to mysql", "", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value))
+		pc.msgHandle[msg.Topic](msg.Value, string(msg.Key))
+		sess.MarkMessage(msg, "")
+	}
+	return nil
+}

internal/push/content_struct/content.go

@@ -0,0 +1,85 @@
+/*
+** description("").
+** copyright('open-im,www.open-im.io').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/5/27 11:24).
+ */
+package content_struct
+
+import (
+	"encoding/json"
+)
+
+type Content struct {
+	IsDisplay int32  `json:"isDisplay"`
+	ID        string `json:"id"`
+	Text      string `json:"text"`
+}
+
+func NewContentStructString(isDisplay int32, ID string, text string) string {
+	c := Content{IsDisplay: isDisplay, ID: ID, Text: text}
+	return c.contentToString()
+}
+
+func (c *Content) contentToString() string {
+	data, _ := json.Marshal(c)
+	dataString := string(data)
+	return dataString
+}
+
+type groupMemberFullInfo struct {
+	GroupId  string `json:"groupID"`
+	UserId   string `json:"userId"`
+	Role     int    `json:"role"`
+	JoinTime uint64 `json:"joinTime"`
+	NickName string `json:"nickName"`
+	FaceUrl  string `json:"faceUrl"`
+}
+
+type AgreeOrRejectGroupMember struct {
+	GroupId  string `json:"groupID"`
+	UserId   string `json:"userId"`
+	Role     int    `json:"role"`
+	JoinTime uint64 `json:"joinTime"`
+	NickName string `json:"nickName"`
+	FaceUrl  string `json:"faceUrl"`
+	Reason   string `json:"reason"`
+}
+type AtTextContent struct {
+	Text       string   `json:"text"`
+	AtUserList []string `json:"atUserList"`
+	IsAtSelf   bool     `json:"isAtSelf"`
+}
+
+type CreateGroupSysMsg struct {
+	uIdCreator     string                `creatorUid`
+	initMemberList []groupMemberFullInfo `json: initMemberList`
+	CreateTime     uint64                `json:"CreateTime"`
+	Text           string                `json:"text"`
+}
+
+type NotificationContent struct {
+	IsDisplay   int32  `json:"isDisplay"`
+	DefaultTips string `json:"defaultTips"`
+	Detail      string `json:"detail"`
+}
+
+func (c *NotificationContent) ContentToString() string {
+	data, _ := json.Marshal(c)
+	dataString := string(data)
+	return dataString
+}
+
+type KickGroupMemberApiReq struct {
+	GroupID     string   `json:"groupID"`
+	UidList     []string `json:"uidList"`
+	Reason      string   `json:"reason"`
+	OperationID string   `json:"operationID"`
+}
+
+func NewCreateGroupSysMsgString(create *CreateGroupSysMsg, text string) string {
+	create.Text = text
+	jstring, _ := json.Marshal(create)
+
+	return string(jstring)
+}

internal/push/getui/push.go

@@ -0,0 +1,222 @@
+package getui
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"bytes"
+	"crypto/sha256"
+	"errors"
+
+	//"crypto/sha512"
+	"encoding/hex"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+var (
+	GetuiClient *Getui
+
+	TokenExpireError = errors.New("token expire")
+)
+
+const (
+	PushURL = "/push/single/alias"
+	AuthURL = "/auth"
+)
+
+func init() {
+	GetuiClient = newGetuiClient()
+}
+
+type Getui struct{}
+
+type GetuiCommonResp struct {
+	Code int         `json:"code"`
+	Msg  string      `json:"msg"`
+	Data interface{} `json:"data"`
+}
+
+type AuthReq struct {
+	Sign      string `json:"sign"`
+	Timestamp string `json:"timestamp"`
+	Appkey    string `json:"appkey"`
+}
+
+type AuthResp struct {
+	ExpireTime string `json:"expire_time"`
+	Token      string `json:"token"`
+}
+
+type PushReq struct {
+	RequestID string `json:"request_id"`
+	Audience  struct {
+		Alias []string `json:"alias"`
+	} `json:"audience"`
+	PushMessage struct {
+		Notification Notification `json:"notification,omitempty"`
+		Transmission string       `json:"transmission,omitempty"`
+	} `json:"push_message"`
+	PushChannel struct {
+		Ios     Ios     `json:"ios"`
+		Android Android `json:"android"`
+	} `json:"push_channel"`
+}
+
+type Ios struct {
+	Aps struct {
+		Sound string `json:"sound"`
+		Alert Alert  `json:"alert"`
+	} `json:"aps"`
+}
+
+type Alert struct {
+	Title string `json:"title"`
+	Body  string `json:"body"`
+}
+
+type Android struct {
+	Ups struct {
+		Notification Notification `json:"notification"`
+	} `json:"ups"`
+}
+
+type Notification struct {
+	Title     string `json:"title"`
+	Body      string `json:"body"`
+	ClickType string `json:"click_type"`
+}
+
+type PushResp struct {
+}
+
+func newGetuiClient() *Getui {
+	return &Getui{}
+}
+
+func (g *Getui) Push(userIDList []string, alert, detailContent, operationID string) (resp string, err error) {
+	token, err := db.DB.GetGetuiToken()
+	log.NewDebug(operationID, utils.GetSelfFuncName(), "token：", token)
+	if err != nil {
+		log.NewError(operationID, utils.OperationIDGenerator(), "GetGetuiToken failed", err.Error())
+	}
+	if token == "" || err != nil {
+		token, err = g.getTokenAndSave2Redis(operationID)
+		if err != nil {
+			log.NewError(operationID, utils.GetSelfFuncName(), "getTokenAndSave2Redis failed", err.Error())
+			return "", utils.Wrap(err, "")
+		}
+	}
+	pushReq := PushReq{
+		RequestID: utils.OperationIDGenerator(),
+		Audience: struct {
+			Alias []string `json:"alias"`
+		}{Alias: []string{userIDList[0]}},
+	}
+	pushReq.PushMessage.Notification = Notification{
+		Title:     alert,
+		Body:      alert,
+		ClickType: "startapp",
+	}
+	pushReq.PushChannel.Ios.Aps.Sound = "default"
+	pushReq.PushChannel.Ios.Aps.Alert = Alert{
+		Title: alert,
+		Body:  alert,
+	}
+	pushReq.PushChannel.Android.Ups.Notification = Notification{
+		Title:     alert,
+		Body:      alert,
+		ClickType: "startapp",
+	}
+	pushResp := PushResp{}
+	err = g.request(PushURL, pushReq, token, &pushResp, operationID)
+	switch err {
+	case TokenExpireError:
+		token, err = g.getTokenAndSave2Redis(operationID)
+		if err != nil {
+			log.NewError(operationID, utils.GetSelfFuncName(), "getTokenAndSave2Redis failed, ", err.Error())
+		} else {
+			log.NewInfo(operationID, utils.GetSelfFuncName(), "getTokenAndSave2Redis: ", token)
+		}
+	}
+	if err != nil {
+		return "", utils.Wrap(err, "push failed")
+	}
+	respBytes, err := json.Marshal(pushResp)
+	return string(respBytes), utils.Wrap(err, "")
+}
+
+func (g *Getui) Auth(operationID string, timeStamp int64) (token string, expireTime int64, err error) {
+	log.NewInfo(operationID, utils.GetSelfFuncName(), config.Config.Push.Getui.AppKey, timeStamp, config.Config.Push.Getui.MasterSecret)
+	h := sha256.New()
+	h.Write([]byte(config.Config.Push.Getui.AppKey + strconv.Itoa(int(timeStamp)) + config.Config.Push.Getui.MasterSecret))
+	sum := h.Sum(nil)
+	sign := hex.EncodeToString(sum)
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "sha256 result", sign)
+	reqAuth := AuthReq{
+		Sign:      sign,
+		Timestamp: strconv.Itoa(int(timeStamp)),
+		Appkey:    config.Config.Push.Getui.AppKey,
+	}
+	respAuth := AuthResp{}
+	err = g.request(AuthURL, reqAuth, "", &respAuth, operationID)
+	if err != nil {
+		return "", 0, err
+	}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "result: ", respAuth)
+	expire, err := strconv.Atoi(respAuth.ExpireTime)
+	return respAuth.Token, int64(expire), err
+}
+
+func (g *Getui) request(url string, content interface{}, token string, returnStruct interface{}, operationID string) error {
+	con, err := json.Marshal(content)
+	if err != nil {
+		return err
+	}
+	client := &http.Client{}
+	log.Debug(operationID, utils.GetSelfFuncName(), "json:", string(con))
+	req, err := http.NewRequest("POST", config.Config.Push.Getui.PushUrl+url, bytes.NewBuffer(con))
+	if err != nil {
+		return err
+	}
+	if token != "" {
+		req.Header.Set("token", token)
+	}
+	req.Header.Set("content-type", "application/json")
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	result, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	log.NewInfo(operationID, "getui", utils.GetSelfFuncName(), "resp, ", string(result))
+	commonResp := GetuiCommonResp{}
+	commonResp.Data = returnStruct
+	if err := json.Unmarshal(result, &commonResp); err != nil {
+		return err
+	}
+	if commonResp.Code == 10001 {
+		return TokenExpireError
+	}
+	return nil
+}
+
+func (g *Getui) getTokenAndSave2Redis(operationID string) (token string, err error) {
+	token, expireTime, err := g.Auth(operationID, time.Now().UnixNano()/1e6)
+	if err != nil {
+		return "", utils.Wrap(err, "Auth failed")
+	}
+	log.NewDebug(operationID, "getui", utils.GetSelfFuncName(), token, expireTime, err)
+	err = db.DB.SetGetuiToken(token, 60*60*23)
+	if err != nil {
+		return "", utils.Wrap(err, "Auth failed")
+	}
+	return token, nil
+}

internal/push/jpush/common/JGPlatform.go

@@ -0,0 +1,13 @@
+package common
+
+import (
+	"encoding/base64"
+	"fmt"
+)
+
+func GetAuthorization(Appkey string, MasterSecret string) string {
+	str := fmt.Sprintf("%s:%s", Appkey, MasterSecret)
+	buf := []byte(str)
+	Authorization := fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString(buf))
+	return Authorization
+}

internal/push/jpush/push.go

@@ -0,0 +1,74 @@
+package push
+
+import (
+	"Open_IM/internal/push/jpush/common"
+	"Open_IM/internal/push/jpush/requestBody"
+	"Open_IM/pkg/common/config"
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+)
+
+var (
+	JPushClient *JPush
+)
+
+func init() {
+	JPushClient = newGetuiClient()
+}
+
+type JPush struct{}
+
+func newGetuiClient() *JPush {
+	return &JPush{}
+}
+
+func (j *JPush) Auth(apiKey, secretKey string, timeStamp int64) (token string, err error) {
+	return token, nil
+}
+
+func (j *JPush) SetAlias(cid, alias string) (resp string, err error) {
+	return resp, nil
+}
+
+func (j *JPush) Push(accounts []string, alert, detailContent, operationID string) (string, error) {
+	var pf requestBody.Platform
+	pf.SetAll()
+	var au requestBody.Audience
+	au.SetAlias(accounts)
+	var no requestBody.Notification
+	no.SetAlert(alert)
+	var me requestBody.Message
+	me.SetMsgContent(detailContent)
+	var o requestBody.Options
+	o.SetApnsProduction(false)
+	var po requestBody.PushObj
+	po.SetPlatform(&pf)
+	po.SetAudience(&au)
+	po.SetNotification(&no)
+	po.SetMessage(&me)
+	po.SetOptions(&o)
+
+	con, err := json.Marshal(po)
+	if err != nil {
+		return "", err
+	}
+	client := &http.Client{}
+	req, err := http.NewRequest("POST", config.Config.Push.Jpns.PushUrl, bytes.NewBuffer(con))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Authorization", common.GetAuthorization(config.Config.Push.Jpns.AppKey, config.Config.Push.Jpns.MasterSecret))
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	result, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	return string(result), nil
+}

internal/push/jpush/requestBody/audience.go

@@ -0,0 +1,53 @@
+package requestBody
+
+const (
+	TAG             = "tag"
+	TAG_AND         = "tag_and"
+	TAG_NOT         = "tag_not"
+	ALIAS           = "alias"
+	REGISTRATION_ID = "registration_id"
+	SEGMENT         = "segment"
+	ABTEST          = "abtest"
+)
+
+type Audience struct {
+	Object   interface{}
+	audience map[string][]string
+}
+
+func (a *Audience) set(key string, v []string) {
+	if a.audience == nil {
+		a.audience = make(map[string][]string)
+		a.Object = a.audience
+	}
+
+	//v, ok = this.audience[key]
+	//if ok {
+	//	return
+	//}
+	a.audience[key] = v
+}
+
+func (a *Audience) SetTag(tags []string) {
+	a.set(TAG, tags)
+}
+
+func (a *Audience) SetTagAnd(tags []string) {
+	a.set(TAG_AND, tags)
+}
+
+func (a *Audience) SetTagNot(tags []string) {
+	a.set(TAG_NOT, tags)
+}
+
+func (a *Audience) SetAlias(alias []string) {
+	a.set(ALIAS, alias)
+}
+
+func (a *Audience) SetRegistrationId(ids []string) {
+	a.set(REGISTRATION_ID, ids)
+}
+
+func (a *Audience) SetAll() {
+	a.Object = "all"
+}

internal/push/jpush/requestBody/message.go

@@ -0,0 +1,27 @@
+package requestBody
+
+type Message struct {
+	MsgContent  string                 `json:"msg_content"`
+	Title       string                 `json:"title,omitempty"`
+	ContentType string                 `json:"content_type,omitempty"`
+	Extras      map[string]interface{} `json:"extras,omitempty"`
+}
+
+func (m *Message) SetMsgContent(c string) {
+	m.MsgContent = c
+}
+
+func (m *Message) SetTitle(t string) {
+	m.Title = t
+}
+
+func (m *Message) SetContentType(c string) {
+	m.ContentType = c
+}
+
+func (m *Message) SetExtras(key string, value interface{}) {
+	if m.Extras == nil {
+		m.Extras = make(map[string]interface{})
+	}
+	m.Extras[key] = value
+}

internal/push/jpush/requestBody/notification.go

@@ -0,0 +1,36 @@
+package requestBody
+
+import (
+	"Open_IM/pkg/common/config"
+)
+
+type Notification struct {
+	Alert   string  `json:"alert,omitempty"`
+	Android Android `json:"android,omitempty"`
+	IOS     Ios     `json:"ios,omitempty"`
+}
+
+type Android struct {
+	Alert  string `json:"alert,omitempty"`
+	Intent struct {
+		URL string `json:"url,omitempty"`
+	} `json:"intent,omitempty"`
+}
+type Ios struct {
+	Alert string `json:"alert,omitempty"`
+	Sound string `json:"sound,omitempty"`
+	Badge string `json:"badge,omitempty"`
+}
+
+func (n *Notification) SetAlert(alert string) {
+	n.Alert = alert
+	n.Android.Alert = alert
+	n.SetAndroidIntent()
+	n.IOS.Alert = alert
+	n.IOS.Sound = "default"
+	n.IOS.Badge = "+1"
+
+}
+func (n *Notification) SetAndroidIntent() {
+	n.Android.Intent.URL = config.Config.Push.Jpns.PushIntent
+}

internal/push/jpush/requestBody/options.go

@@ -0,0 +1,9 @@
+package requestBody
+
+type Options struct {
+	ApnsProduction bool `json:"apns_production"`
+}
+
+func (o *Options) SetApnsProduction(c bool) {
+	o.ApnsProduction = c
+}

internal/push/jpush/requestBody/platform.go

@@ -0,0 +1,83 @@
+package requestBody
+
+import (
+	"Open_IM/pkg/common/constant"
+	"errors"
+)
+
+const (
+	ANDROID      = "android"
+	IOS          = "ios"
+	QUICKAPP     = "quickapp"
+	WINDOWSPHONE = "winphone"
+	ALL          = "all"
+)
+
+type Platform struct {
+	Os     interface{}
+	osArry []string
+}
+
+func (p *Platform) Set(os string) error {
+	if p.Os == nil {
+		p.osArry = make([]string, 0, 4)
+	} else {
+		switch p.Os.(type) {
+		case string:
+			return errors.New("platform is all")
+		default:
+		}
+	}
+
+	for _, value := range p.osArry {
+		if os == value {
+			return nil
+		}
+	}
+
+	switch os {
+	case IOS:
+		fallthrough
+	case ANDROID:
+		fallthrough
+	case QUICKAPP:
+		fallthrough
+	case WINDOWSPHONE:
+		p.osArry = append(p.osArry, os)
+		p.Os = p.osArry
+	default:
+		return errors.New("unknow platform")
+	}
+
+	return nil
+}
+func (p *Platform) SetPlatform(platform string) error {
+	switch platform {
+	case constant.AndroidPlatformStr:
+		return p.SetAndroid()
+	case constant.IOSPlatformStr:
+		return p.SetIOS()
+	default:
+		return errors.New("platform err")
+	}
+
+}
+func (p *Platform) SetIOS() error {
+	return p.Set(IOS)
+}
+
+func (p *Platform) SetAndroid() error {
+	return p.Set(ANDROID)
+}
+
+func (p *Platform) SetQuickApp() error {
+	return p.Set(QUICKAPP)
+}
+
+func (p *Platform) SetWindowsPhone() error {
+	return p.Set(WINDOWSPHONE)
+}
+
+func (p *Platform) SetAll() {
+	p.Os = ALL
+}

internal/push/jpush/requestBody/pushObj.go

@@ -0,0 +1,28 @@
+package requestBody
+
+type PushObj struct {
+	Platform     interface{} `json:"platform"`
+	Audience     interface{} `json:"audience"`
+	Notification interface{} `json:"notification,omitempty"`
+	Message      interface{} `json:"message,omitempty"`
+	Options      interface{} `json:"options,omitempty"`
+}
+
+func (p *PushObj) SetPlatform(pf *Platform) {
+	p.Platform = pf.Os
+}
+
+func (p *PushObj) SetAudience(ad *Audience) {
+	p.Audience = ad.Object
+}
+
+func (p *PushObj) SetNotification(no *Notification) {
+	p.Notification = no
+}
+
+func (p *PushObj) SetMessage(m *Message) {
+	p.Message = m
+}
+func (p *PushObj) SetOptions(o *Options) {
+	p.Options = o
+}

internal/push/logic/init.go

@@ -0,0 +1,39 @@
+/*
+** description("").
+** copyright('open-im,www.open-im.io').
+** author("fg,Gordon@open-im.io").
+** time(2021/3/22 15:33).
+ */
+package logic
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/statistics"
+	"fmt"
+)
+
+var (
+	rpcServer    RPCServer
+	pushCh       PushConsumerHandler
+	pushTerminal []int32
+	producer     *kafka.Producer
+	count        uint64
+)
+
+func Init(rpcPort int) {
+
+	rpcServer.Init(rpcPort)
+	pushCh.Init()
+	pushTerminal = []int32{constant.IOSPlatformID, constant.AndroidPlatformID}
+}
+func init() {
+	producer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.Ws2mschat.Topic)
+	statistics.NewStatistics(&count, config.Config.ModuleName.PushName, fmt.Sprintf("%d second push to msg_gateway count", 300), 300)
+}
+
+func Run() {
+	go rpcServer.run()
+	go pushCh.pushConsumerGroup.RegisterHandleAndConsumer(&pushCh)
+}

internal/push/logic/push_handler.go

@@ -0,0 +1,52 @@
+/*
+** description("").
+** copyright('Open_IM,www.Open_IM.io').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/5/13 10:33).
+ */
+package logic
+
+import (
+	"Open_IM/pkg/common/config"
+	kfk "Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/common/log"
+	pbChat "Open_IM/pkg/proto/chat"
+	pbPush "Open_IM/pkg/proto/push"
+	"github.com/Shopify/sarama"
+	"github.com/golang/protobuf/proto"
+)
+
+type fcb func(msg []byte)
+
+type PushConsumerHandler struct {
+	msgHandle         map[string]fcb
+	pushConsumerGroup *kfk.MConsumerGroup
+}
+
+func (ms *PushConsumerHandler) Init() {
+	ms.msgHandle = make(map[string]fcb)
+	ms.msgHandle[config.Config.Kafka.Ms2pschat.Topic] = ms.handleMs2PsChat
+	ms.pushConsumerGroup = kfk.NewMConsumerGroup(&kfk.MConsumerGroupConfig{KafkaVersion: sarama.V0_10_2_0,
+		OffsetsInitial: sarama.OffsetNewest, IsReturnErr: false}, []string{config.Config.Kafka.Ms2pschat.Topic}, config.Config.Kafka.Ms2pschat.Addr,
+		config.Config.Kafka.ConsumerGroupID.MsgToPush)
+}
+func (ms *PushConsumerHandler) handleMs2PsChat(msg []byte) {
+	log.InfoByKv("msg come from kafka  And push!!!", "", "msg", string(msg))
+	msgFromMQ := pbChat.PushMsgDataToMQ{}
+	if err := proto.Unmarshal(msg, &msgFromMQ); err != nil {
+		log.ErrorByKv("push Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
+		return
+	}
+	//Call push module to send message to the user
+	MsgToUser((*pbPush.PushMsgReq)(&msgFromMQ))
+}
+func (PushConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
+func (PushConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
+func (ms *PushConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
+	claim sarama.ConsumerGroupClaim) error {
+	for msg := range claim.Messages() {
+		log.InfoByKv("kafka get info to mysql", "", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value))
+		ms.msgHandle[msg.Topic](msg.Value)
+	}
+	return nil
+}

internal/push/logic/push_rpc_server.go

@@ -0,0 +1,57 @@
+package logic
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	"Open_IM/pkg/proto/push"
+	"Open_IM/pkg/utils"
+	"context"
+	"google.golang.org/grpc"
+	"net"
+	"strings"
+)
+
+type RPCServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func (r *RPCServer) Init(rpcPort int) {
+	r.rpcPort = rpcPort
+	r.rpcRegisterName = config.Config.RpcRegisterName.OpenImPushName
+	r.etcdSchema = config.Config.Etcd.EtcdSchema
+	r.etcdAddr = config.Config.Etcd.EtcdAddr
+}
+func (r *RPCServer) run() {
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + utils.IntToString(r.rpcPort)
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.ErrorByKv("push module rpc listening port err", "", "err", err.Error())
+		return
+	}
+	defer listener.Close()
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	pbPush.RegisterPushMsgServiceServer(srv, r)
+	err = getcdv3.RegisterEtcd(r.etcdSchema, strings.Join(r.etcdAddr, ","), ip, r.rpcPort, r.rpcRegisterName, 10)
+	if err != nil {
+		log.ErrorByKv("register push module  rpc to etcd err", "", "err", err.Error())
+	}
+	err = srv.Serve(listener)
+	if err != nil {
+		log.ErrorByKv("push module rpc start err", "", "err", err.Error())
+		return
+	}
+}
+func (r *RPCServer) PushMsg(_ context.Context, pbData *pbPush.PushMsgReq) (*pbPush.PushMsgResp, error) {
+	//Call push module to send message to the user
+	MsgToUser(pbData)
+	return &pbPush.PushMsgResp{
+		ResultCode: 0,
+	}, nil
+
+}

internal/push/logic/push_to_client.go

@@ -0,0 +1,167 @@
+/*
+** description("").
+** copyright('open-im,www.open-im.io').
+** author("fg,Gordon@open-im.io").
+** time(2021/3/5 14:31).
+ */
+package logic
+
+import (
+	pusher "Open_IM/internal/push"
+	"Open_IM/internal/push/getui"
+	jpush "Open_IM/internal/push/jpush"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbPush "Open_IM/pkg/proto/push"
+	pbRelay "Open_IM/pkg/proto/relay"
+	"Open_IM/pkg/utils"
+	"context"
+	"encoding/json"
+	"strings"
+)
+
+type OpenIMContent struct {
+	SessionType int    `json:"sessionType"`
+	From        string `json:"from"`
+	To          string `json:"to"`
+	Seq         uint32 `json:"seq"`
+}
+type AtContent struct {
+	Text       string   `json:"text"`
+	AtUserList []string `json:"atUserList"`
+	IsAtSelf   bool     `json:"isAtSelf"`
+}
+
+func MsgToUser(pushMsg *pbPush.PushMsgReq) {
+	var wsResult []*pbRelay.SingleMsgToUser
+	isOfflinePush := utils.GetSwitchFromOptions(pushMsg.MsgData.Options, constant.IsOfflinePush)
+	log.Debug("Get msg from msg_transfer And push msg", pushMsg.OperationID, "PushData", pushMsg.String())
+	grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
+	//Online push message
+	log.Debug("test", pushMsg.OperationID, "len  grpc", len(grpcCons), "data", pushMsg.String())
+	for _, v := range grpcCons {
+		msgClient := pbRelay.NewOnlineMessageRelayServiceClient(v)
+		reply, err := msgClient.OnlinePushMsg(context.Background(), &pbRelay.OnlinePushMsgReq{OperationID: pushMsg.OperationID, MsgData: pushMsg.MsgData, PushToUserID: pushMsg.PushToUserID})
+		if err != nil {
+			log.InfoByKv("push data to client rpc err", pushMsg.OperationID, "err", err)
+			continue
+		}
+		if reply != nil && reply.Resp != nil {
+			wsResult = append(wsResult, reply.Resp...)
+		}
+	}
+	log.InfoByKv("push_result", pushMsg.OperationID, "result", wsResult, "sendData", pushMsg.MsgData)
+	count++
+	if isOfflinePush && pushMsg.PushToUserID != pushMsg.MsgData.SendID {
+		for _, v := range wsResult {
+			if v.ResultCode == 0 {
+				continue
+			}
+			if utils.IsContainInt32(v.RecvPlatFormID, pushTerminal) {
+				//Use offline push messaging
+				var UIDList []string
+				UIDList = append(UIDList, v.RecvID)
+				customContent := OpenIMContent{
+					SessionType: int(pushMsg.MsgData.SessionType),
+					From:        pushMsg.MsgData.SendID,
+					To:          pushMsg.MsgData.RecvID,
+					Seq:         pushMsg.MsgData.Seq,
+				}
+				bCustomContent, _ := json.Marshal(customContent)
+				jsonCustomContent := string(bCustomContent)
+				var content string
+				if pushMsg.MsgData.OfflinePushInfo != nil {
+					content = pushMsg.MsgData.OfflinePushInfo.Title
+
+				} else {
+					switch pushMsg.MsgData.ContentType {
+					case constant.Text:
+						content = constant.ContentType2PushContent[constant.Text]
+					case constant.Picture:
+						content = constant.ContentType2PushContent[constant.Picture]
+					case constant.Voice:
+						content = constant.ContentType2PushContent[constant.Voice]
+					case constant.Video:
+						content = constant.ContentType2PushContent[constant.Video]
+					case constant.File:
+						content = constant.ContentType2PushContent[constant.File]
+					case constant.AtText:
+						a := AtContent{}
+						_ = utils.JsonStringToStruct(string(pushMsg.MsgData.Content), &a)
+						if utils.IsContain(v.RecvID, a.AtUserList) {
+							content = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
+						} else {
+							content = constant.ContentType2PushContent[constant.GroupMsg]
+						}
+					default:
+						content = constant.ContentType2PushContent[constant.Common]
+					}
+				}
+				var offlinePusher pusher.OfflinePusher
+				if config.Config.Push.Getui.Enable {
+					log.NewInfo(pushMsg.OperationID, utils.GetSelfFuncName(), config.Config.Push.Getui)
+					offlinePusher = getui.GetuiClient
+				}
+				if config.Config.Push.Jpns.Enable {
+					offlinePusher = jpush.JPushClient
+				}
+				if offlinePusher == nil {
+					offlinePusher = jpush.JPushClient
+				}
+				pushResult, err := offlinePusher.Push(UIDList, content, jsonCustomContent, pushMsg.OperationID)
+				if err != nil {
+					log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error())
+				} else {
+					log.NewDebug(pushMsg.OperationID, "offline push return result is ", pushResult, pushMsg.MsgData)
+				}
+				break
+			}
+
+		}
+
+	}
+}
+
+//func SendMsgByWS(m *pbChat.WSToMsgSvrChatMsg) {
+//	m.MsgID = rpcChat.GetMsgID(m.SendID)
+//	m.ClientMsgID = m.MsgID
+//	switch m.SessionType {
+//	case constant.SingleChatType:
+//		sendMsgToKafka(m, m.SendID, "msgKey--sendID")
+//		sendMsgToKafka(m, m.RecvID, "msgKey--recvID")
+//	case constant.GroupChatType:
+//		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+//		client := pbGroup.NewGroupClient(etcdConn)
+//		req := &pbGroup.Req{
+//			GroupID:     m.RecvID,
+//			Token:       config.Config.Secret,
+//			OperationID: m.OperationID,
+//		}
+//		reply, err := client.(context.Background(), req)
+//		if err != nil {
+//			log.Error(m.Token, m.OperationID, "rpc  getGroupInfo failed, err = %s", err.Error())
+//			return
+//		}
+//		if reply.ErrorCode != 0 {
+//			log.Error(m.Token, m.OperationID, "rpc  getGroupInfo failed, err = %s", reply.ErrorMsg)
+//			return
+//		}
+//		groupID := m.RecvID
+//		for i, v := range reply.MemberList {
+//			m.RecvID = v.UserId + " " + groupID
+//			sendMsgToKafka(m, utils.IntToString(i), "msgKey--recvID+\" \"+groupID")
+//		}
+//	default:
+//
+//	}
+//}
+//
+//func sendMsgToKafka(m *pbChat.WSToMsgSvrChatMsg, key string, flag string) {
+//	pid, offset, err := producer.SendMessage(m, key)
+//	if err != nil {
+//		log.ErrorByKv("kafka send failed", m.OperationID, "send data", m.String(), "pid", pid, "offset", offset, "err", err.Error(), flag, key)
+//	}
+//
+//}

internal/push/logic/tpns.go

@@ -0,0 +1,34 @@
+package logic
+
+import (
+	tpns "Open_IM/internal/push/sdk/tpns-server-sdk-go/go"
+	"Open_IM/internal/push/sdk/tpns-server-sdk-go/go/auth"
+	"Open_IM/internal/push/sdk/tpns-server-sdk-go/go/common"
+	"Open_IM/internal/push/sdk/tpns-server-sdk-go/go/req"
+	"Open_IM/pkg/common/config"
+)
+
+var badgeType = -2
+var iosAcceptId = auth.Auther{AccessID: config.Config.Push.Tpns.Ios.AccessID, SecretKey: config.Config.Push.Tpns.Ios.SecretKey}
+
+func IOSAccountListPush(accounts []string, title, content, jsonCustomContent string) {
+	var iosMessage = tpns.Message{
+		Title:   title,
+		Content: content,
+		IOS: &tpns.IOSParams{
+			Aps: &tpns.Aps{
+				BadgeType: &badgeType,
+				Sound:     "default",
+				Category:  "INVITE_CATEGORY",
+			},
+			CustomContent: jsonCustomContent,
+			//CustomContent: `"{"key\":\"value\"}"`,
+		},
+	}
+	pushReq, reqBody, err := req.NewListAccountPush(accounts, iosMessage)
+	if err != nil {
+		return
+	}
+	iosAcceptId.Auth(pushReq, auth.UseSignAuthored, iosAcceptId, reqBody)
+	common.PushAndGetResult(pushReq)
+}

internal/push/push_interface.go

@@ -0,0 +1,5 @@
+package push
+
+type OfflinePusher interface {
+	Push(userIDList []string, alert, detailContent, operationID string) (resp string, err error)
+}

internal/push/sdk/tpns-server-sdk-go/go/auth/auth.go

@@ -0,0 +1,62 @@
+package auth
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	b64 "encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+type Auther struct {
+	AccessID  string
+	SecretKey string
+}
+
+var UseSignAuthored = true
+
+func (a *Auther) Auth(req *http.Request, useSignAuthored bool, auth Auther, reqBody string) {
+
+	if useSignAuthored {
+		now := time.Now()
+		timeStamp := now.Unix()
+		req.Header.Add("AccessId", auth.AccessID)
+		req.Header.Add("TimeStamp", strconv.Itoa(int(timeStamp)))
+		sign := GenSign(uint64(timeStamp), auth.AccessID, auth.SecretKey, reqBody)
+		req.Header.Add("Sign", sign)
+	} else {
+		author := makeAuthHeader(a.AccessID, a.SecretKey)
+		//log.Printf("author string:%v", author)
+		req.Header.Add("Authorization", author)
+	}
+	//req.Header.Add("Content-Type", "application/json")
+}
+
+func makeAuthHeader(appID, secretKey string) string {
+	base64Str := base64.StdEncoding.EncodeToString(
+		[]byte(
+			fmt.Sprintf("%s:%s", appID, secretKey),
+		),
+	)
+	return fmt.Sprintf("Basic %s", base64Str)
+}
+
+func GenSign(timeStamp uint64, accessId string, secretKey, requestBody string) string {
+	signBody := strconv.Itoa(int(timeStamp)) + accessId + requestBody
+	// Create a new HMAC by defining the hash type and the key (as byte array)
+	h := hmac.New(sha256.New, []byte(secretKey))
+	// Write Data to it
+	h.Write([]byte(signBody))
+
+	// Get result and encode as hexadecimal string
+	sha := hex.EncodeToString(h.Sum(nil))
+	//fmt.Println()
+	//fmt.Println("timeStamp: " + strconv.Itoa(int(timeStamp)) + " accessID:" + accessId + " body:" + requestBody)
+	sEnc := b64.StdEncoding.EncodeToString([]byte(sha))
+	//fmt.Println("final Result " + sEnc)
+	return sEnc
+}

internal/push/sdk/tpns-server-sdk-go/go/client/client.go

@@ -0,0 +1,18 @@
+package client
+
+import (
+	"net/http"
+	"time"
+)
+
+func New() *http.Client {
+	return &http.Client{
+		Transport: &http.Transport{
+			MaxIdleConns:        100,
+			MaxIdleConnsPerHost: 100,
+			IdleConnTimeout:     30 * time.Second,
+			DisableCompression:  false,
+			DisableKeepAlives:   false,
+		},
+	}
+}

internal/push/sdk/tpns-server-sdk-go/go/common/http_helper.go

@@ -0,0 +1,62 @@
+package common
+
+import (
+	tpns "Open_IM/internal/push/sdk/tpns-server-sdk-go/go"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+)
+
+func PushAndGetResult(pushReq *http.Request) {
+	c := &http.Client{}
+	rsp, err := c.Do(pushReq)
+	fmt.Println()
+	if err != nil {
+		//fmt.Printf("http err:%v", err)
+		return
+	}
+	defer rsp.Body.Close()
+	body, err := ioutil.ReadAll(rsp.Body)
+	//fmt.Printf("http ReadAll err:%v, body:%v  ", err, string(body))
+	if err != nil {
+		return
+	}
+	r := &tpns.CommonRsp{}
+	json.Unmarshal(body, r)
+	//fmt.Printf("push result: %+v", r)
+}
+
+func UploadFile(req *http.Request) (int, error) {
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, err
+	}
+
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return 0, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return 0, fmt.Errorf("response error, status: %s, body: %s", resp.Status, string(body))
+	}
+
+	type uploadResponse struct {
+		RetCode  int    `json:"retCode"`
+		ErrMsg   string `json:"errMsg"`
+		UploadId int    `json:"uploadId"`
+	}
+
+	var ur uploadResponse
+	if err := json.Unmarshal(body, &ur); err != nil {
+		return 0, err
+	}
+
+	if ur.RetCode != 0 {
+		return 0, fmt.Errorf("response with %d:%s", ur.RetCode, ur.ErrMsg)
+	}
+	return ur.UploadId, nil
+}

internal/push/sdk/tpns-server-sdk-go/go/common/json_helper.go

@@ -0,0 +1,8 @@
+package common
+
+import "encoding/json"
+
+func ToJson(v interface{}) string {
+	bs, _ := json.Marshal(v)
+	return string(bs)
+}

internal/push/sdk/tpns-server-sdk-go/go/def.go

@@ -0,0 +1,256 @@
+package tpns
+
+type CommonRspEnv string
+
+const (
+	// EnvProd
+	EnvProd CommonRspEnv = "product"
+	// EnvDev
+	EnvDev CommonRspEnv = "dev"
+)
+
+type CommonRsp struct {
+	// TODO: doc this
+	Seq int64 `json:"seq"`
+
+	PushID string `json:"push_id"`
+
+	RetCode int `json:"ret_code"`
+
+	Environment CommonRspEnv `json:"environment"`
+
+	ErrMsg string `json:"err_msg,omitempty"`
+
+	Result map[string]string `json:"result,omitempty"`
+}
+
+type AudienceType string
+
+const (
+	AdAll AudienceType = "all"
+
+	AdTag AudienceType = "tag"
+
+	AdToken AudienceType = "token"
+
+	AdTokenList AudienceType = "token_list"
+
+	AdAccount AudienceType = "account"
+
+	AdAccountList AudienceType = "account_list"
+
+	AdPackageAccount AudienceType = "package_account_push"
+
+	AdPackageToken AudienceType = "package_token_push"
+)
+
+// MessageType push API message_type
+type MessageType string
+
+const (
+	MsgTypeNotify MessageType = "notify"
+
+	MsgTypeMessage MessageType = "message"
+)
+
+type Request struct {
+	AudienceType AudienceType `json:"audience_type"`
+
+	Message Message `json:"message"`
+
+	MessageType MessageType `json:"message_type"`
+
+	Tag []TagRule `json:"tag_rules,omitempty"`
+
+	TokenList []string `json:"token_list,omitempty"`
+
+	AccountList []string `json:"account_list,omitempty"`
+
+	Environment CommonRspEnv `json:"environment,omitempty"`
+
+	UploadId int `json:"upload_id,omitempty"`
+
+	ExpireTime int `json:"expire_time,omitempty"`
+
+	SendTime string `json:"send_time,omitempty"`
+
+	MultiPkg bool `json:"multi_pkg,omitempty"`
+
+	PlanId string `json:"plan_id,omitempty"`
+
+	AccountPushType int `json:"account_push_type,omitempty"`
+
+	PushSpeed int `json:"push_speed,omitempty"`
+
+	CollapseId int `json:"collapse_id"`
+
+	TPNSOnlinePushType int `json:"tpns_online_push_type"`
+
+	ChannelRules []*ChannelDistributeRule `json:"channel_rules,omitempty"`
+
+	LoopParam     *PushLoopParam `json:"loop_param,omitempty"`
+	ForceCollapse bool           `json:"force_collapse"`
+}
+
+type TagListOperation string
+
+type ChannelDistributeRule struct {
+	ChannelName string `json:"channel"`
+	Disable     bool   `json:"disable"`
+}
+
+type PushLoopParam struct {
+	StartDate string `json:"startDate"`
+
+	EndDate string `json:"endDate"`
+
+	LoopType PushLoopType `json:"loopType"`
+
+	LoopDayIndexs []uint32 `json:"loopDayIndexs"`
+
+	DayTimes []string `json:"dayTimes"`
+}
+
+type PushLoopType int32
+
+const (
+	TagListOpAnd TagListOperation = "AND"
+
+	TagListOpOr TagListOperation = "OR"
+)
+
+type TagType string
+
+const (
+	XGAutoProvince      TagType = "xg_auto_province"
+	XGAutoActive        TagType = "xg_auto_active"
+	XGUserDefine        TagType = "xg_user_define"
+	XGAutoVersion       TagType = "xg_auto_version"
+	XGAutoSdkversion    TagType = "xg_auto_sdkversion"
+	XGAutoDevicebrand   TagType = "xg_auto_devicebrand"
+	XGAutoDeviceversion TagType = "xg_auto_deviceversion"
+	XGAutoCountry       TagType = "xg_auto_country"
+)
+
+type TagRule struct {
+	TagItems []TagItem `json:"tag_items"`
+
+	IsNot bool `json:"is_not"`
+
+	Operator TagListOperation `json:"operator"`
+}
+
+type TagItem struct {
+	// 标签
+	Tags          []string         `json:"tags"`
+	IsNot         bool             `json:"is_not"`
+	TagsOperator  TagListOperation `json:"tags_operator"`
+	ItemsOperator TagListOperation `json:"items_operator"`
+	TagType       TagType          `json:"tag_type"`
+}
+
+type Message struct {
+	Title   string `json:"title,omitempty"`
+	Content string `json:"content,omitempty"`
+
+	AcceptTime []AcceptTimeItem `json:"accept_time,omitempty"`
+
+	Android *AndroidParams `json:"android,omitempty"`
+
+	IOS *IOSParams `json:"ios,omitempty"`
+
+	ThreadId string `json:"thread_id,omitempty"`
+
+	ThreadSumtext string `json:"thread_sumtext,omitempty"`
+
+	XGMediaResources string `json:"xg_media_resources,omitempty"`
+
+	XGMediaAudioResources string `json:"xg_media_audio_resources,omitempty"`
+}
+
+type AcceptTimeItem struct {
+	Start HourAndMin `json:"start,omitempty"`
+	End   HourAndMin `json:"end,omitempty"`
+}
+
+type HourAndMin struct {
+	Hour string `json:"hour,omitempty"`
+	Min  string `json:"min,omitempty"`
+}
+
+type AndroidParams struct {
+	BuilderId *int `json:"builder_id,omitempty"`
+
+	Ring *int `json:"ring,omitempty"`
+
+	RingRaw string `json:"ring_raw,omitempty"`
+
+	Vibrate *int `json:"vibrate,omitempty"`
+
+	Lights *int `json:"lights,omitempty"`
+
+	Clearable *int `json:"clearable,omitempty"`
+
+	IconType *int `json:"icon_type"`
+
+	IconRes string `json:"icon_res,omitempty"`
+
+	StyleId *int `json:"style_id,omitempty"`
+
+	SmallIcon string `json:"small_icon,omitempty"`
+
+	Action *Action `json:"action,omitempty"`
+
+	CustomContent string `json:"custom_content,omitempty"`
+
+	ShowType *int `json:"show_type,omitempty"`
+
+	NChId string `json:"n_ch_id,omitempty"`
+
+	NChName string `json:"n_ch_name,omitempty"`
+
+	HwChId string `json:"hw_ch_id,omitempty"`
+
+	XmChId string `json:"xm_ch_id,omitempty"`
+
+	OppoChId string `json:"oppo_ch_id,omitempty"`
+
+	VivoChId string `json:"vivo_ch_id,omitempty"`
+
+	BadgeType *int `json:"badge_type,omitempty"`
+
+	IconColor *int `json:"icon_color,omitempty"`
+}
+
+type Action struct {
+	ActionType *int    `json:"action_type,omitempty"`
+	Activity   string  `json:"activity"`
+	AtyAttr    AtyAttr `json:"aty_attr,omitempty"`
+	Intent     string  `json:"intent"`
+	Browser    Browser `json:"browser,omitempty"`
+}
+
+type Browser struct {
+	Url     string `json:"url,omitempty"`
+	Confirm *int   `json:"confirm,omitempty"`
+}
+
+type AtyAttr struct {
+	AttrIf *int `json:"if,omitempty"`
+	Pf     *int `json:"pf,omitempty"`
+}
+
+type IOSParams struct {
+	Aps *Aps `json:"aps,omitempty"`
+
+	CustomContent string `json:"custom_content,omitempty"`
+}
+
+type Aps struct {
+	Alert               map[string]string `json:"alert,omitempty"`
+	BadgeType           *int              `json:"badge_type,omitempty"`
+	Category            string            `json:"category,omitempty"`
+	ContentAvailableInt *int              `json:"content-available,omitempty"`
+	MutableContent      *int              `json:"mutable-content,omitempty"`
+	Sound               string            `json:"sound,omitempty"`
+}

internal/push/sdk/tpns-server-sdk-go/go/req/req.go

@@ -0,0 +1,403 @@
+package req
+
+import (
+	tpns "Open_IM/internal/push/sdk/tpns-server-sdk-go/go"
+	"bytes"
+	"encoding/json"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+var PushURL = "https://api.tpns.tencent.com/v3/push/app"
+
+//var PushURL = "https://test.api.tpns.tencent.com/v3/push/app"
+
+func URL(url string) {
+	PushURL = url
+}
+
+type ReqOpt func(*tpns.Request)
+
+func NewPush(req *tpns.Request, opts ...ReqOpt) (*http.Request, string, error) {
+	return NewPushReq(req, opts...)
+}
+
+func NewUploadFileRequest(host string, file string) (*http.Request, error) {
+	fp, err := os.Open(file)
+	if err != nil {
+		return nil, err
+	}
+
+	defer fp.Close()
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("file", filepath.Base(fp.Name()))
+	if err != nil {
+		return nil, err
+	}
+
+	io.Copy(part, fp)
+	writer.Close()
+	url := host + "/v3/push/package/upload"
+	req, err := http.NewRequest("POST", url, body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Add("Content-Type", writer.FormDataContentType())
+
+	return req, nil
+}
+
+func NewSingleAccountPush(
+	message tpns.Message,
+	account string,
+	opts ...ReqOpt,
+) (*http.Request, string, error) {
+	req := &tpns.Request{
+		MessageType:  tpns.MsgTypeNotify,
+		AudienceType: tpns.AdAccountList,
+		AccountList:  []string{account},
+		Message:      message,
+	}
+	return NewPushReq(req, opts...)
+}
+
+func NewListAccountPush(
+	accounts []string, message tpns.Message,
+	opts ...ReqOpt,
+) (*http.Request, string, error) {
+	req := &tpns.Request{
+		MessageType:  tpns.MsgTypeNotify,
+		AudienceType: tpns.AdAccountList,
+		AccountList:  accounts,
+		Message:      message,
+		Environment:  tpns.EnvDev,
+	}
+	return NewPushReq(req, opts...)
+}
+
+func NewTokenPush(
+	tokens []string, message tpns.Message,
+	opts ...ReqOpt,
+) (*http.Request, string, error) {
+	req := &tpns.Request{
+		MessageType:  tpns.MsgTypeNotify,
+		AudienceType: tpns.AdTokenList,
+		TokenList:    tokens,
+		Message:      message,
+		Environment:  tpns.EnvProd,
+	}
+	//fmt.Printf("reqBody :%v", common.ToJson(req))
+	//fmt.Println()
+	return NewPushReq(req, opts...)
+}
+
+func NewTagsPush(
+	tagList []tpns.TagRule, message tpns.Message,
+	opts ...ReqOpt,
+) (*http.Request, string, error) {
+	req := &tpns.Request{
+		MessageType:  tpns.MsgTypeNotify,
+		AudienceType: tpns.AdTag,
+		Tag:          tagList,
+		Message:      message,
+	}
+	//fmt.Printf("reqBody :%v", common.ToJson(req))
+	//fmt.Println()
+	return NewPushReq(req, opts...)
+}
+
+func NewAllPush(
+	message tpns.Message,
+	opts ...ReqOpt,
+) (*http.Request, string, error) {
+	req := &tpns.Request{
+		MessageType:  tpns.MsgTypeNotify,
+		AudienceType: tpns.AdAll,
+		Message:      message,
+	}
+	return NewPushReq(req, opts...)
+}
+
+func NewAccountPackagePush(
+	message tpns.Message,
+	opts ...ReqOpt,
+) (*http.Request, string, error) {
+	req := &tpns.Request{
+		MessageType:  tpns.MsgTypeNotify,
+		AudienceType: tpns.AdPackageAccount,
+		Message:      message,
+	}
+	return NewPushReq(req, opts...)
+}
+
+func NewTokenPackagePush(
+	message tpns.Message,
+	opts ...ReqOpt,
+) (*http.Request, string, error) {
+	req := &tpns.Request{
+		MessageType:  tpns.MsgTypeNotify,
+		AudienceType: tpns.AdPackageToken,
+		Message:      message,
+	}
+	return NewPushReq(req, opts...)
+}
+
+func NewPushReq(req *tpns.Request, opts ...ReqOpt) (request *http.Request, reqBody string, err error) {
+	for _, opt := range opts {
+		opt(req)
+	}
+	bodyBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, "", err
+	}
+	reqBody = string(bodyBytes)
+	//fmt.Printf("NewPushReq req:%v", reqBody)
+	request, err = http.NewRequest("POST", PushURL, bytes.NewReader(bodyBytes))
+	if err != nil {
+		return nil, "", err
+	}
+	request.Header.Add("Content-Type", "application/json")
+	return
+}
+
+func EnvProd() ReqOpt {
+	return func(r *tpns.Request) {
+		r.Environment = tpns.EnvProd
+	}
+}
+
+func EnvDev() ReqOpt {
+	return func(r *tpns.Request) {
+		r.Environment = tpns.EnvDev
+	}
+}
+
+func Title(t string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Title = t
+		if r.Message.IOS != nil {
+			if r.Message.IOS.Aps != nil {
+				r.Message.IOS.Aps.Alert["title"] = t
+			} else {
+				r.Message.IOS.Aps = &tpns.Aps{
+					Alert: map[string]string{"title": t},
+				}
+			}
+		} else {
+			r.Message.IOS = &tpns.IOSParams{
+				Aps: &tpns.Aps{
+					Alert: map[string]string{"title": t},
+				},
+			}
+		}
+	}
+}
+
+func Content(c string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Content = c
+		if r.Message.IOS != nil {
+			if r.Message.IOS.Aps != nil {
+				r.Message.IOS.Aps.Alert["body"] = c
+			} else {
+				r.Message.IOS.Aps = &tpns.Aps{
+					Alert: map[string]string{"body": c},
+				}
+			}
+		} else {
+			r.Message.IOS = &tpns.IOSParams{
+				Aps: &tpns.Aps{
+					Alert: map[string]string{"body": c},
+				},
+			}
+		}
+	}
+}
+
+func Ring(ring *int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Android.Ring = ring
+	}
+}
+
+func RingRaw(rr string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Android.RingRaw = rr
+	}
+}
+
+func Vibrate(v *int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Android.Vibrate = v
+	}
+}
+
+func Lights(l *int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Android.Lights = l
+	}
+}
+
+func Clearable(c *int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Android.Clearable = c
+	}
+}
+
+func IconType(it *int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Android.IconType = it
+	}
+}
+
+func IconRes(ir string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Android.IconRes = ir
+	}
+}
+
+func AndroidCustomContent(ct string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.Android.CustomContent = ct
+	}
+}
+
+func Aps(aps *tpns.Aps) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message.IOS.Aps = aps
+	}
+}
+
+func AudienceType(at tpns.AudienceType) ReqOpt {
+	return func(r *tpns.Request) {
+		r.AudienceType = at
+	}
+}
+
+func Message(m tpns.Message) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Message = m
+	}
+}
+
+func TokenList(tl []string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.TokenList = tl
+	}
+}
+
+func TokenListAdd(t string) ReqOpt {
+	return func(r *tpns.Request) {
+		if r.TokenList != nil {
+			r.TokenList = append(r.TokenList, t)
+		} else {
+			r.TokenList = []string{t}
+		}
+	}
+}
+
+func AccountList(al []string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.AccountList = al
+	}
+}
+
+//ChannelDistributeRules
+func AddChannelRules(ChannelRules []*tpns.ChannelDistributeRule) ReqOpt {
+	return func(r *tpns.Request) {
+		r.ChannelRules = ChannelRules
+	}
+}
+
+//ChannelDistributeRules
+func AddLoopParam(loopParam *tpns.PushLoopParam) ReqOpt {
+	return func(r *tpns.Request) {
+		r.LoopParam = loopParam
+	}
+}
+
+func AccountListAdd(a string) ReqOpt {
+	return func(r *tpns.Request) {
+		if r.AccountList != nil {
+			r.AccountList = append(r.AccountList, a)
+		} else {
+			r.AccountList = []string{a}
+		}
+	}
+}
+
+func MessageType(t tpns.MessageType) ReqOpt {
+	return func(r *tpns.Request) {
+		r.MessageType = t
+	}
+}
+
+func AddMultiPkg(multipPkg bool) ReqOpt {
+	return func(r *tpns.Request) {
+		r.MultiPkg = multipPkg
+	}
+}
+
+func AddForceCollapse(forceCollapse bool) ReqOpt {
+	return func(r *tpns.Request) {
+		r.ForceCollapse = forceCollapse
+	}
+}
+
+func AddTPNSOnlinePushType(onlinePushType int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.TPNSOnlinePushType = onlinePushType
+	}
+}
+
+func AddCollapseId(collapseId int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.CollapseId = collapseId
+	}
+}
+
+func AddPushSpeed(pushSpeed int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.PushSpeed = pushSpeed
+	}
+}
+
+func AddAccountPushType(accountPushType int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.AccountPushType = accountPushType
+	}
+}
+
+func AddPlanId(planId string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.PlanId = planId
+	}
+}
+
+func AddSendTime(sendTime string) ReqOpt {
+	return func(r *tpns.Request) {
+		r.SendTime = sendTime
+	}
+}
+
+func AddExpireTime(expireTime int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.ExpireTime = expireTime
+	}
+}
+
+func AddUploadId(UploadId int) ReqOpt {
+	return func(r *tpns.Request) {
+		r.UploadId = UploadId
+	}
+}
+
+func AddEnvironment(Environment tpns.CommonRspEnv) ReqOpt {
+	return func(r *tpns.Request) {
+		r.Environment = Environment
+	}
+}

internal/rpc/admin_cms/admin_cms.go

@@ -0,0 +1,87 @@
+package admin_cms
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	openIMHttp "Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbAdminCMS "Open_IM/pkg/proto/admin_cms"
+	"Open_IM/pkg/utils"
+	"context"
+	"google.golang.org/grpc"
+	"net"
+	"strconv"
+	"strings"
+)
+
+type adminCMSServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewAdminCMSServer(port int) *adminCMSServer {
+	log.NewPrivateLog(constant.LogFileName)
+	return &adminCMSServer{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImAdminCMSName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (s *adminCMSServer) Run() {
+	log.NewInfo("0", "AdminCMS rpc start ")
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
+	//listener network
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.NewError("0", "Listen failed ", err.Error(), registerAddress)
+		return
+	}
+	log.NewInfo("0", "listen network success, ", registerAddress, listener)
+	defer listener.Close()
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	//Service registers with etcd
+	pbAdminCMS.RegisterAdminCMSServer(srv, s)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("0", "RegisterEtcd failed ", err.Error())
+		return
+	}
+	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(_ context.Context, req *pbAdminCMS.AdminLoginReq) (*pbAdminCMS.AdminLoginResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	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 := token_verify.CreateToken(adminID, constant.SingleChatType)
+			log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "generate token success", "token: ", token, "expTime:", expTime)
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "generate token failed", "adminID: ", adminID, err.Error())
+				return resp, openIMHttp.WrapError(constant.ErrTokenUnknown)
+			}
+			resp.Token = token
+			break
+		}
+	}
+
+	if resp.Token == "" {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "failed")
+		return resp, openIMHttp.WrapError(constant.ErrTokenMalformed)
+	}
+	return resp, nil
+}

internal/rpc/auth/auth.go

@@ -0,0 +1,104 @@
+package auth
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbAuth "Open_IM/pkg/proto/auth"
+	"Open_IM/pkg/utils"
+	"context"
+	"net"
+	"strconv"
+	"strings"
+
+	"Open_IM/pkg/common/config"
+
+	"google.golang.org/grpc"
+)
+
+func (rpc *rpcAuth) UserRegister(_ context.Context, req *pbAuth.UserRegisterReq) (*pbAuth.UserRegisterResp, error) {
+	log.NewInfo(req.OperationID, "UserRegister args ", req.String())
+	var user db.User
+	utils.CopyStructFields(&user, req.UserInfo)
+	if req.UserInfo.Birth != 0 {
+		user.Birth = utils.UnixSecondToTime(int64(req.UserInfo.Birth))
+	}
+	err := imdb.UserRegister(user)
+	if err != nil {
+		log.NewError(req.OperationID, "UserRegister failed ", err.Error(), user)
+		return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+
+	log.NewInfo(req.OperationID, "rpc UserRegister return")
+	return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{}}, nil
+}
+
+func (rpc *rpcAuth) UserToken(_ context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
+	log.NewInfo(req.OperationID, "UserToken args ", req.String())
+
+	_, err := imdb.GetUserByUserID(req.FromUserID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.FromUserID)
+		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+
+	tokens, expTime, err := token_verify.CreateToken(req.FromUserID, req.Platform)
+	if err != nil {
+		log.NewError(req.OperationID, "CreateToken failed ", err.Error(), req.FromUserID, req.Platform)
+		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+
+	log.NewInfo(req.OperationID, "rpc UserToken return ", tokens, expTime)
+	return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{}, Token: tokens, ExpiredTime: expTime}, nil
+}
+
+type rpcAuth struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewRpcAuthServer(port int) *rpcAuth {
+	log.NewPrivateLog(constant.LogFileName)
+	return &rpcAuth{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImAuthName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (rpc *rpcAuth) Run() {
+	log.NewInfo("0", "rpc auth start...")
+
+	address := utils.ServerIP + ":" + strconv.Itoa(rpc.rpcPort)
+	listener, err := net.Listen("tcp", address)
+	if err != nil {
+		log.NewError("0", "listen network failed ", err.Error(), address)
+		return
+	}
+	log.NewInfo("0", "listen network success, ", address, listener)
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+
+	//service registers with etcd
+	pbAuth.RegisterAuthServer(srv, rpc)
+	err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("0", "RegisterEtcd failed ", err.Error(),
+			rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
+		return
+	}
+	log.NewInfo("0", "RegisterAuthServer ok ", rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
+	err = srv.Serve(listener)
+	if err != nil {
+		log.NewError("0", "Serve failed ", err.Error())
+		return
+	}
+	log.NewInfo("0", "rpc auth ok")
+}

internal/rpc/auth/callback.go

@@ -0,0 +1 @@
+package auth

internal/rpc/friend/callback.go

@@ -0,0 +1 @@
+package friend

internal/rpc/friend/firend.go

@@ -0,0 +1,519 @@
+package friend
+
+import (
+	chat "Open_IM/internal/rpc/msg"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	cp "Open_IM/pkg/common/utils"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/pkg/proto/friend"
+	sdkws "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"google.golang.org/grpc"
+	"net"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type friendServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewFriendServer(port int) *friendServer {
+	log.NewPrivateLog(constant.LogFileName)
+	return &friendServer{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImFriendName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (s *friendServer) Run() {
+	log.NewInfo("0", "friendServer run...")
+
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
+	//listener network
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.NewError("0", "Listen failed ", err.Error(), registerAddress)
+		return
+	}
+	log.NewInfo("0", "listen ok ", registerAddress)
+	defer listener.Close()
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	//User friend related services register to etcd
+	pbFriend.RegisterFriendServer(srv, s)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("0", "RegisterEtcd failed ", err.Error(), s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName)
+		return
+	}
+	err = srv.Serve(listener)
+	if err != nil {
+		log.NewError("0", "Serve failed ", err.Error(), listener)
+		return
+	}
+}
+
+func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlacklistReq) (*pbFriend.AddBlacklistResp, error) {
+	log.NewInfo(req.CommID.OperationID, "AddBlacklist args ", req.String())
+	ok := token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	black := db.Black{OwnerUserID: req.CommID.FromUserID, BlockUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID}
+
+	err := imdb.InsertInToUserBlackList(black)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "InsertInToUserBlackList failed ", err.Error())
+		return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	log.NewInfo(req.CommID.OperationID, "AddBlacklist rpc ok ", req.CommID.FromUserID, req.CommID.ToUserID)
+	chat.BlackAddedNotification(req)
+	return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{}}, nil
+}
+
+func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq) (*pbFriend.AddFriendResp, error) {
+	log.NewInfo(req.CommID.OperationID, "AddFriend args ", req.String())
+	ok := token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID)
+	if !ok {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	//Cannot add non-existent users
+	if _, err := imdb.GetUserByUserID(req.CommID.ToUserID); err != nil {
+		log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), req.CommID.ToUserID)
+		return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+
+	//Establish a latest relationship in the friend request table
+	friendRequest := db.FriendRequest{
+		HandleResult: 0, ReqMsg: req.ReqMsg, CreateTime: time.Now()}
+	utils.CopyStructFields(&friendRequest, req.CommID)
+	// {openIM001 openIM002 0 test add friend 0001-01-01 00:00:00 +0000 UTC   0001-01-01 00:00:00 +0000 UTC }]
+	log.NewDebug(req.CommID.OperationID, "UpdateFriendApplication args ", friendRequest)
+	//err := imdb.InsertFriendApplication(&friendRequest)
+	err := imdb.InsertFriendApplication(&friendRequest,
+		map[string]interface{}{"handle_result": 0, "req_msg": friendRequest.ReqMsg, "create_time": friendRequest.CreateTime,
+			"handler_user_id": "", "handle_msg": "", "handle_time": utils.UnixSecondToTime(0), "ex": ""})
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error(), friendRequest)
+		return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+
+	chat.FriendApplicationNotification(req)
+	return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{}}, nil
+}
+
+func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFriendReq) (*pbFriend.ImportFriendResp, error) {
+	log.NewInfo(req.OperationID, "ImportFriend args ", req.String())
+	resp := pbFriend.ImportFriendResp{CommonResp: &pbFriend.CommonResp{}}
+	var c pbFriend.CommonResp
+
+	if !utils.IsContain(req.OpUserID, config.Config.Manager.AppManagerUid) {
+		log.NewError(req.OperationID, "not authorized", req.OpUserID, config.Config.Manager.AppManagerUid)
+		c.ErrCode = constant.ErrAccess.ErrCode
+		c.ErrMsg = constant.ErrAccess.ErrMsg
+		for _, v := range req.FriendUserIDList {
+			resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: v, Result: -1})
+		}
+		resp.CommonResp = &c
+		return &resp, nil
+	}
+	if _, err := imdb.GetUserByUserID(req.FromUserID); err != nil {
+		log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.FromUserID)
+		c.ErrCode = constant.ErrDB.ErrCode
+		c.ErrMsg = "this user not exists,cant not add friend"
+		for _, v := range req.FriendUserIDList {
+			resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: v, Result: -1})
+		}
+		resp.CommonResp = &c
+		return &resp, nil
+	}
+
+	for _, v := range req.FriendUserIDList {
+		log.NewDebug(req.OperationID, "FriendUserIDList ", v)
+		if _, fErr := imdb.GetUserByUserID(v); fErr != nil {
+			log.NewError(req.OperationID, "GetUserByUserID failed ", fErr.Error(), v)
+			resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: v, Result: -1})
+		} else {
+			if _, err := imdb.GetFriendRelationshipFromFriend(req.FromUserID, v); err != nil {
+				//Establish two single friendship
+				toInsertFollow := db.Friend{OwnerUserID: req.FromUserID, FriendUserID: v}
+				err1 := imdb.InsertToFriend(&toInsertFollow)
+				if err1 != nil {
+					log.NewError(req.OperationID, "InsertToFriend failed ", err1.Error(), toInsertFollow)
+					resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: v, Result: -1})
+					continue
+				}
+				toInsertFollow = db.Friend{OwnerUserID: v, FriendUserID: req.FromUserID}
+				err2 := imdb.InsertToFriend(&toInsertFollow)
+				if err2 != nil {
+					log.NewError(req.OperationID, "InsertToFriend failed ", err2.Error(), toInsertFollow)
+					resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: v, Result: -1})
+					continue
+				}
+				resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: v, Result: 0})
+				log.NewDebug(req.OperationID, "UserIDResultList ", resp.UserIDResultList)
+				chat.FriendAddedNotification(req.OperationID, req.OpUserID, req.FromUserID, v)
+			} else {
+				log.NewWarn(req.OperationID, "GetFriendRelationshipFromFriend ok", req.FromUserID, v)
+				resp.UserIDResultList = append(resp.UserIDResultList, &pbFriend.UserIDResult{UserID: v, Result: 0})
+			}
+		}
+	}
+	resp.CommonResp.ErrCode = 0
+	log.NewInfo(req.OperationID, "ImportFriend rpc ok ", resp.String())
+	return &resp, nil
+}
+
+//process Friend application
+func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddFriendResponseReq) (*pbFriend.AddFriendResponseResp, error) {
+	log.NewInfo(req.CommID.OperationID, "AddFriendResponse args ", req.String())
+
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+
+	//Check there application before agreeing or refuse to a friend's application
+	//req.CommID.FromUserID process req.CommID.ToUserID
+	friendRequest, err := imdb.GetFriendApplicationByBothUserID(req.CommID.ToUserID, req.CommID.FromUserID)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetFriendApplicationByBothUserID failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID)
+		return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	friendRequest.HandleResult = req.HandleResult
+	friendRequest.HandleTime = time.Now()
+	//friendRequest.HandleTime.Unix()
+	friendRequest.HandleMsg = req.HandleMsg
+	friendRequest.HandlerUserID = req.CommID.OpUserID
+	err = imdb.UpdateFriendApplication(friendRequest)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "UpdateFriendApplication failed ", err.Error(), friendRequest)
+		return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+
+	//Change the status of the friend request form
+	if req.HandleResult == constant.FriendFlag {
+		//Establish friendship after find friend relationship not exists
+		_, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
+		if err == nil {
+			log.NewWarn(req.CommID.OperationID, "GetFriendRelationshipFromFriend exist", req.CommID.FromUserID, req.CommID.ToUserID)
+		} else {
+			//Establish two single friendship
+			toInsertFollow := db.Friend{OwnerUserID: req.CommID.FromUserID, FriendUserID: req.CommID.ToUserID, OperatorUserID: req.CommID.OpUserID}
+			err = imdb.InsertToFriend(&toInsertFollow)
+			if err != nil {
+				log.NewError(req.CommID.OperationID, "InsertToFriend failed ", err.Error(), toInsertFollow)
+				return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+			}
+		}
+
+		_, err = imdb.GetFriendRelationshipFromFriend(req.CommID.ToUserID, req.CommID.FromUserID)
+		if err == nil {
+			log.NewWarn(req.CommID.OperationID, "GetFriendRelationshipFromFriend exist", req.CommID.ToUserID, req.CommID.FromUserID)
+		} else {
+			toInsertFollow := db.Friend{OwnerUserID: req.CommID.ToUserID, FriendUserID: req.CommID.FromUserID, OperatorUserID: req.CommID.OpUserID}
+			err = imdb.InsertToFriend(&toInsertFollow)
+			if err != nil {
+				log.NewError(req.CommID.OperationID, "InsertToFriend failed ", err.Error(), toInsertFollow)
+				return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+			}
+			chat.FriendAddedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
+		}
+	}
+	if req.HandleResult == constant.FriendResponseAgree {
+		chat.FriendApplicationApprovedNotification(req)
+	} else if req.HandleResult == constant.FriendResponseRefuse {
+		chat.FriendApplicationRejectedNotification(req)
+	} else {
+		log.Error(req.CommID.OperationID, "HandleResult failed ", req.HandleResult)
+	}
+	log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok")
+	return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{}}, nil
+}
+
+func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFriendReq) (*pbFriend.DeleteFriendResp, error) {
+	log.NewInfo(req.CommID.OperationID, "DeleteFriend args ", req.String())
+	//Parse token, to find current user information
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	err := imdb.DeleteSingleFriendInfo(req.CommID.FromUserID, req.CommID.ToUserID)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "DeleteSingleFriendInfo failed", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID)
+		return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	log.NewInfo(req.CommID.OperationID, "DeleteFriend rpc ok")
+	chat.FriendDeletedNotification(req)
+	return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{}}, nil
+}
+
+func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlacklistReq) (*pbFriend.GetBlacklistResp, error) {
+	log.NewInfo(req.CommID.OperationID, "GetBlacklist args ", req.String())
+
+	//Parse token, to find current user information
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.GetBlacklistResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+
+	blackListInfo, err := imdb.GetBlackListByUserID(req.CommID.FromUserID)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetBlackListByUID failed ", err.Error(), req.CommID.FromUserID)
+		return &pbFriend.GetBlacklistResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
+	}
+
+	var (
+		userInfoList []*sdkws.PublicUserInfo
+	)
+	for _, blackUser := range blackListInfo {
+		var blackUserInfo sdkws.PublicUserInfo
+		//Find black user information
+		us, err := imdb.GetUserByUserID(blackUser.BlockUserID)
+		if err != nil {
+			log.NewError(req.CommID.OperationID, "GetUserByUserID failed ", err.Error(), blackUser.BlockUserID)
+			continue
+		}
+		utils.CopyStructFields(&blackUserInfo, us)
+		userInfoList = append(userInfoList, &blackUserInfo)
+	}
+	log.NewInfo(req.CommID.OperationID, "rpc GetBlacklist ok ", pbFriend.GetBlacklistResp{BlackUserInfoList: userInfoList})
+	return &pbFriend.GetBlacklistResp{BlackUserInfoList: userInfoList}, nil
+}
+
+func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFriendRemarkReq) (*pbFriend.SetFriendRemarkResp, error) {
+	log.NewInfo(req.CommID.OperationID, "SetFriendComment args ", req.String())
+	//Parse token, to find current user information
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+
+	err := imdb.UpdateFriendComment(req.CommID.FromUserID, req.CommID.ToUserID, req.Remark)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "UpdateFriendComment failed ", req.CommID.FromUserID, req.CommID.ToUserID, req.Remark)
+		return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok")
+	chat.FriendRemarkSetNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
+	return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{}}, nil
+}
+
+func (s *friendServer) RemoveBlacklist(ctx context.Context, req *pbFriend.RemoveBlacklistReq) (*pbFriend.RemoveBlacklistResp, error) {
+	log.NewInfo(req.CommID.OperationID, "RemoveBlacklist args ", req.String())
+	//Parse token, to find current user information
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.RemoveBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	err := imdb.RemoveBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "RemoveBlackList failed", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID)
+		return &pbFriend.RemoveBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+
+	}
+	log.NewInfo(req.CommID.OperationID, "rpc RemoveBlacklist ok ")
+	chat.BlackDeletedNotification(req)
+	return &pbFriend.RemoveBlacklistResp{CommonResp: &pbFriend.CommonResp{}}, nil
+}
+
+func (s *friendServer) IsInBlackList(ctx context.Context, req *pbFriend.IsInBlackListReq) (*pbFriend.IsInBlackListResp, error) {
+	log.NewInfo("IsInBlackList args ", req.String())
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.IsInBlackListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+
+	var isInBlacklist = false
+	err := imdb.CheckBlack(req.CommID.FromUserID, req.CommID.ToUserID)
+	if err == nil {
+		isInBlacklist = true
+	}
+	log.NewInfo(req.CommID.OperationID, "IsInBlackList rpc ok ", pbFriend.IsInBlackListResp{Response: isInBlacklist})
+	return &pbFriend.IsInBlackListResp{Response: isInBlacklist}, nil
+}
+
+func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq) (*pbFriend.IsFriendResp, error) {
+	log.NewInfo(req.CommID.OperationID, req.String())
+	var isFriend bool
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.IsFriendResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	_, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
+	if err == nil {
+		isFriend = true
+	} else {
+		isFriend = false
+	}
+	log.NewInfo(req.CommID.OperationID, pbFriend.IsFriendResp{Response: isFriend})
+	return &pbFriend.IsFriendResp{Response: isFriend}, nil
+}
+
+func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFriendListReq) (*pbFriend.GetFriendListResp, error) {
+	log.NewInfo("GetFriendList args ", req.String())
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.GetFriendListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+
+	friends, err := imdb.GetFriendListByUserID(req.CommID.FromUserID)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "FindUserInfoFromFriend failed ", err.Error(), req.CommID.FromUserID)
+		return &pbFriend.GetFriendListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
+	}
+	var userInfoList []*sdkws.FriendInfo
+	for _, friendUser := range friends {
+		friendUserInfo := sdkws.FriendInfo{FriendUser: &sdkws.UserInfo{}}
+		cp.FriendDBCopyOpenIM(&friendUserInfo, &friendUser)
+		log.NewDebug(req.CommID.OperationID, "friends : ", friendUser, "openim friends: ", friendUserInfo)
+		userInfoList = append(userInfoList, &friendUserInfo)
+	}
+	log.NewInfo(req.CommID.OperationID, "rpc GetFriendList ok", pbFriend.GetFriendListResp{FriendInfoList: userInfoList})
+	return &pbFriend.GetFriendListResp{FriendInfoList: userInfoList}, nil
+}
+
+//received
+func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.GetFriendApplyListReq) (*pbFriend.GetFriendApplyListResp, error) {
+	log.NewInfo(req.CommID.OperationID, "GetFriendApplyList args ", req.String())
+	//Parse token, to find current user information
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.GetFriendApplyListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	//	Find the  current user friend applications received
+	ApplyUsersInfo, err := imdb.GetReceivedFriendsApplicationListByUserID(req.CommID.FromUserID)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetReceivedFriendsApplicationListByUserID ", err.Error(), req.CommID.FromUserID)
+		return &pbFriend.GetFriendApplyListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
+	}
+
+	var appleUserList []*sdkws.FriendRequest
+	for _, applyUserInfo := range ApplyUsersInfo {
+		var userInfo sdkws.FriendRequest
+		cp.FriendRequestDBCopyOpenIM(&userInfo, &applyUserInfo)
+		//	utils.CopyStructFields(&userInfo, applyUserInfo)
+		//	u, err := imdb.GetUserByUserID(userInfo.FromUserID)
+		//	if err != nil {
+		//		log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.FromUserID)
+		//		continue
+		//	}
+		//	userInfo.FromNickname = u.Nickname
+		//	userInfo.FromFaceURL = u.FaceURL
+		//	userInfo.FromGender = u.Gender
+		//
+		//	u, err = imdb.GetUserByUserID(userInfo.ToUserID)
+		//	if err != nil {
+		//		log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.ToUserID)
+		//		continue
+		//	}
+		//	userInfo.ToNickname = u.Nickname
+		//	userInfo.ToFaceURL = u.FaceURL
+		//	userInfo.ToGender = u.Gender
+		appleUserList = append(appleUserList, &userInfo)
+	}
+
+	log.NewInfo(req.CommID.OperationID, "rpc GetFriendApplyList ok", pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList})
+	return &pbFriend.GetFriendApplyListResp{FriendRequestList: appleUserList}, nil
+}
+
+func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSelfApplyListReq) (*pbFriend.GetSelfApplyListResp, error) {
+	log.NewInfo(req.CommID.OperationID, "GetSelfApplyList args ", req.String())
+
+	//Parse token, to find current user information
+	if !token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID) {
+		log.NewError(req.CommID.OperationID, "CheckAccess false ", req.CommID.OpUserID, req.CommID.FromUserID)
+		return &pbFriend.GetSelfApplyListResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	//	Find the self add other userinfo
+	usersInfo, err := imdb.GetSendFriendApplicationListByUserID(req.CommID.FromUserID)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "GetSendFriendApplicationListByUserID failed ", err.Error(), req.CommID.FromUserID)
+		return &pbFriend.GetSelfApplyListResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
+	}
+	var selfApplyOtherUserList []*sdkws.FriendRequest
+	for _, selfApplyOtherUserInfo := range usersInfo {
+		var userInfo sdkws.FriendRequest // pbFriend.ApplyUserInfo
+		cp.FriendRequestDBCopyOpenIM(&userInfo, &selfApplyOtherUserInfo)
+		//u, err := imdb.GetUserByUserID(userInfo.FromUserID)
+		//if err != nil {
+		//	log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.FromUserID)
+		//	continue
+		//}
+		//userInfo.FromNickname = u.Nickname
+		//userInfo.FromFaceURL = u.FaceURL
+		//userInfo.FromGender = u.Gender
+		//
+		//u, err = imdb.GetUserByUserID(userInfo.ToUserID)
+		//if err != nil {
+		//	log.Error(req.CommID.OperationID, "GetUserByUserID", userInfo.ToUserID)
+		//	continue
+		//}
+		//userInfo.ToNickname = u.Nickname
+		//userInfo.ToFaceURL = u.FaceURL
+		//userInfo.ToGender = u.Gender
+
+		selfApplyOtherUserList = append(selfApplyOtherUserList, &userInfo)
+	}
+	log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList})
+	return &pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}, nil
+}
+
+////
+//func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFriendsInfoReq) (*pbFriend.GetFriendInfoResp, error) {
+//	return nil, nil
+////	log.NewInfo(req.CommID.OperationID, "GetFriendsInfo args ", req.String())
+////	var (
+////		isInBlackList int32
+////		//	isFriend      int32
+////		comment string
+////	)
+////
+////	friendShip, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
+////	if err != nil {
+////		log.NewError(req.CommID.OperationID, "FindFriendRelationshipFromFriend failed ", err.Error())
+////		return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
+////		//	isFriend = constant.FriendFlag
+////	}
+////	comment = friendShip.Remark
+////
+////	friendUserInfo, err := imdb.FindUserByUID(req.CommID.ToUserID)
+////	if err != nil {
+////		log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error())
+////		return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
+////	}
+////
+////	err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
+////	if err == nil {
+////		isInBlackList = constant.BlackListFlag
+////	}
+////
+////	resp := pbFriend.GetFriendInfoResp{ErrCode: 0, ErrMsg:  "",}
+////
+////	utils.CopyStructFields(resp.FriendInfoList, friendUserInfo)
+////	resp.Data.IsBlack = isInBlackList
+////	resp.Data.OwnerUserID = req.CommID.FromUserID
+////	resp.Data.Remark = comment
+////	resp.Data.CreateTime = friendUserInfo.CreateTime
+////
+////	log.NewInfo(req.CommID.OperationID, "GetFriendsInfo ok ", resp)
+////	return &resp, nil
+////
+//}

internal/rpc/group/callback.go

@@ -0,0 +1,13 @@
+package group
+
+import (
+	pbGroup "Open_IM/pkg/proto/group"
+)
+
+func callbackBeforeCreateGroup(req *pbGroup.CreateGroupReq) (bool, error) {
+	return true, nil
+}
+
+func callbackAfterCreateGroup(req *pbGroup.CreateGroupReq) {
+
+}

internal/rpc/message_cms/message_cms.go

@@ -0,0 +1,167 @@
+package messageCMS
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	errors "Open_IM/pkg/common/http"
+	"context"
+
+	"Open_IM/pkg/common/log"
+
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbMessageCMS "Open_IM/pkg/proto/message_cms"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+
+	"Open_IM/pkg/utils"
+
+	"net"
+	"strconv"
+	"strings"
+
+	"google.golang.org/grpc"
+)
+
+type messageCMSServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewMessageCMSServer(port int) *messageCMSServer {
+	log.NewPrivateLog(constant.LogFileName)
+	return &messageCMSServer{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImMessageCMSName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (s *messageCMSServer) Run() {
+	log.NewInfo("0", "messageCMS rpc start ")
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
+	//listener network
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.NewError("0", "Listen failed ", err.Error(), registerAddress)
+		return
+	}
+	log.NewInfo("0", "listen network success, ", registerAddress, listener)
+	defer listener.Close()
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	//Service registers with etcd
+	pbMessageCMS.RegisterMessageCMSServer(srv, s)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("0", "RegisterEtcd failed ", err.Error())
+		return
+	}
+	err = srv.Serve(listener)
+	if err != nil {
+		log.NewError("0", "Serve failed ", err.Error())
+		return
+	}
+	log.NewInfo("0", "message cms rpc success")
+}
+
+func (s *messageCMSServer) BoradcastMessage(_ context.Context, req *pbMessageCMS.BoradcastMessageReq) (*pbMessageCMS.BoradcastMessageResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "BoradcastMessage", req.String())
+	resp := &pbMessageCMS.BoradcastMessageResp{}
+	return resp, errors.WrapError(constant.ErrDB)
+}
+
+func (s *messageCMSServer) GetChatLogs(_ context.Context, req *pbMessageCMS.GetChatLogsReq) (*pbMessageCMS.GetChatLogsResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetChatLogs", req.String())
+	resp := &pbMessageCMS.GetChatLogsResp{}
+	time, err := utils.TimeStringToTime(req.Date)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "time string parse error", err.Error())
+	}
+	chatLog := db.ChatLog{
+		Content:     req.Content,
+		SendTime:    time,
+		ContentType: req.ContentType,
+		SessionType: req.SessionType,
+	}
+	switch chatLog.SessionType {
+	case constant.SingleChatType:
+		chatLog.SendID = req.UserId
+	case constant.GroupChatType:
+		chatLog.RecvID = req.GroupId
+		chatLog.SendID = req.UserId
+	}
+	nums, err := imdb.GetChatLogCount(chatLog)
+	resp.ChatLogsNum = int32(nums)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetChatLogCount", err.Error())
+	}
+	chatLogs, err := imdb.GetChatLog(chatLog, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetChatLog", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	for _, chatLog := range chatLogs {
+		pbChatLog := &pbMessageCMS.ChatLogs{
+			SessionType:    chatLog.SessionType,
+			ContentType:    chatLog.ContentType,
+			SearchContent:  req.Content,
+			WholeContent:   chatLog.Content,
+			Date:           chatLog.CreateTime.String(),
+			SenderNickName: chatLog.SenderNickname,
+			SenderId:       chatLog.SendID,
+		}
+		if chatLog.SenderNickname == "" {
+			sendUser, err := imdb.GetUserByUserID(chatLog.SendID)
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID failed", err.Error())
+				continue
+			}
+			pbChatLog.SenderNickName = sendUser.Nickname
+		}
+		switch chatLog.SessionType {
+		case constant.SingleChatType:
+			recvUser, err := imdb.GetUserByUserID(chatLog.RecvID)
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID failed", err.Error())
+				continue
+			}
+			pbChatLog.ReciverId = recvUser.UserID
+			pbChatLog.ReciverNickName = recvUser.Nickname
+
+		case constant.GroupChatType:
+			group, err := imdb.GetGroupById(chatLog.RecvID)
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById failed")
+				continue
+			}
+			pbChatLog.GroupId = group.GroupID
+			pbChatLog.GroupName = group.GroupName
+		}
+		resp.ChatLogs = append(resp.ChatLogs, pbChatLog)
+	}
+	resp.Pagination = &open_im_sdk.ResponsePagination{
+		CurrentPage: req.Pagination.PageNumber,
+		ShowNumber:  req.Pagination.ShowNumber,
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp output: ", resp.String())
+	return resp, nil
+}
+
+func (s *messageCMSServer) MassSendMessage(_ context.Context, req *pbMessageCMS.MassSendMessageReq) (*pbMessageCMS.MassSendMessageResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "MassSendMessage", req.String())
+	resp := &pbMessageCMS.MassSendMessageResp{}
+	return resp, nil
+}
+
+func (s *messageCMSServer) WithdrawMessage(_ context.Context, req *pbMessageCMS.WithdrawMessageReq) (*pbMessageCMS.WithdrawMessageResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "WithdrawMessage", req.String())
+	resp := &pbMessageCMS.WithdrawMessageResp{}
+	return resp, nil
+}

internal/rpc/msg/callback.go

@@ -0,0 +1,159 @@
+package msg
+
+import (
+	cbApi "Open_IM/pkg/call_back_struct"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/http"
+	"Open_IM/pkg/common/log"
+	pbChat "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
+)
+
+func copyCallbackCommonReqStruct(msg *pbChat.SendMsgReq) cbApi.CommonCallbackReq {
+	return cbApi.CommonCallbackReq{
+		SendID:           msg.MsgData.SendID,
+		ServerMsgID:      msg.MsgData.ServerMsgID,
+		ClientMsgID:      msg.MsgData.ClientMsgID,
+		OperationID:      msg.OperationID,
+		SenderPlatformID: msg.MsgData.SenderPlatformID,
+		SenderNickname:   msg.MsgData.SenderNickname,
+		SessionType:      msg.MsgData.SessionType,
+		MsgFrom:          msg.MsgData.MsgFrom,
+		ContentType:      msg.MsgData.ContentType,
+		Status:           msg.MsgData.Status,
+		CreateTime:       msg.MsgData.CreateTime,
+		Content:          string(msg.MsgData.Content),
+	}
+}
+
+func callbackBeforeSendSingleMsg(msg *pbChat.SendMsgReq) (canSend bool, err error) {
+	if !config.Config.Callback.CallbackBeforeSendSingleMsg.Enable {
+		return true, nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackBeforeSendSingleMsgCommand
+	req := cbApi.CallbackBeforeSendSingleMsgReq{
+		CommonCallbackReq: commonCallbackReq,
+		RecvID:            msg.MsgData.RecvID,
+	}
+	resp := &cbApi.CallbackBeforeSendSingleMsgResp{
+		CommonCallbackResp: cbApi.CommonCallbackResp{},
+	}
+	//utils.CopyStructFields(req, msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackTimeOut); err != nil {
+		if !config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue {
+			return false, err
+		} else {
+			return true, err
+		}
+	} else {
+		if resp.ActionCode == constant.ActionForbidden && resp.ErrCode == constant.CallbackHandleSuccess {
+			return false, nil
+		}
+	}
+	return true, err
+}
+
+func callbackAfterSendSingleMsg(msg *pbChat.SendMsgReq) error {
+	if !config.Config.Callback.CallbackAfterSendSingleMsg.Enable {
+		return nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackAfterSendSingleMsgCommand
+	req := cbApi.CallbackAfterSendSingleMsgReq{
+		CommonCallbackReq: commonCallbackReq,
+		RecvID:            msg.MsgData.RecvID,
+	}
+	resp := &cbApi.CallbackAfterSendSingleMsgResp{CommonCallbackResp: cbApi.CommonCallbackResp{}}
+	//utils.CopyStructFields(req, msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackAfterSendSingleMsg.CallbackTimeOut); err != nil {
+		return err
+	}
+	return nil
+}
+
+func callbackBeforeSendGroupMsg(msg *pbChat.SendMsgReq) (canSend bool, err error) {
+	if !config.Config.Callback.CallbackBeforeSendGroupMsg.Enable {
+		return true, nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackBeforeSendGroupMsgCommand
+	req := cbApi.CallbackAfterSendGroupMsgReq{
+		CommonCallbackReq: commonCallbackReq,
+		GroupID:           msg.MsgData.GroupID,
+	}
+	resp := &cbApi.CallbackBeforeSendGroupMsgResp{CommonCallbackResp: cbApi.CommonCallbackResp{}}
+	//utils.CopyStructFields(req, msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackTimeOut); err != nil {
+		if !config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue {
+			return false, err
+		} else {
+			return true, err
+		}
+	} else {
+		if resp.ActionCode == constant.ActionForbidden && resp.ErrCode == constant.CallbackHandleSuccess {
+			return false, nil
+		}
+	}
+	return true, err
+}
+
+func callbackAfterSendGroupMsg(msg *pbChat.SendMsgReq) error {
+	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
+		return nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackAfterSendGroupMsgCommand
+	req := cbApi.CallbackAfterSendGroupMsgReq{
+		CommonCallbackReq: commonCallbackReq,
+		GroupID:           msg.MsgData.GroupID,
+	}
+	resp := &cbApi.CallbackAfterSendGroupMsgResp{CommonCallbackResp: cbApi.CommonCallbackResp{}}
+
+	//utils.CopyStructFields(req, msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil {
+		return err
+	}
+	return nil
+}
+
+func callbackWordFilter(msg *pbChat.SendMsgReq) (canSend bool, err error) {
+	if !config.Config.Callback.CallbackWordFilter.Enable || msg.MsgData.ContentType != constant.Text {
+		return true, nil
+	}
+	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
+	commonCallbackReq := copyCallbackCommonReqStruct(msg)
+	commonCallbackReq.CallbackCommand = constant.CallbackWordFilterCommand
+	req := cbApi.CallbackWordFilterReq{
+		CommonCallbackReq: commonCallbackReq,
+	}
+	resp := &cbApi.CallbackWordFilterResp{CommonCallbackResp: cbApi.CommonCallbackResp{}}
+	//utils.CopyStructFields(&req., msg.MsgData)
+	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
+	if err := http.PostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackWordFilter.CallbackTimeOut); err != nil {
+		if !config.Config.Callback.CallbackWordFilter.CallbackFailedContinue {
+			log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), "callback failed and config disable, stop this operation")
+			return false, err
+		} else {
+			return true, err
+		}
+	} else {
+		if resp.ActionCode == constant.ActionForbidden && resp.ErrCode == constant.CallbackHandleSuccess {
+			return false, nil
+		}
+		if resp.ErrCode == constant.CallbackHandleSuccess {
+			msg.MsgData.Content = []byte(resp.Content)
+		}
+		log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), string(msg.MsgData.Content))
+	}
+	return true, err
+}

internal/rpc/msg/conversation_notification.go

@@ -0,0 +1,76 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"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) {
+	log.NewInfo(operationID, "args: ", sendID, recvID, contentType, m.String(), tips.String())
+	var err error
+	tips.Detail, err = proto.Marshal(m)
+	if err != nil {
+		log.NewError(operationID, "Marshal failed ", err.Error(), m.String())
+		return
+	}
+	marshaler := jsonpb.Marshaler{
+		OrigName:     true,
+		EnumsAsInts:  false,
+		EmitDefaults: false,
+	}
+	tips.JsonDetail, _ = marshaler.MarshalToString(m)
+	var n NotificationMsg
+	n.SendID = sendID
+	n.RecvID = recvID
+	n.ContentType = int32(contentType)
+	n.SessionType = constant.SingleChatType
+	n.MsgFrom = constant.SysMsgType
+	n.OperationID = operationID
+	n.Content, err = proto.Marshal(&tips)
+	if err != nil {
+		log.Error(operationID, utils.GetSelfFuncName(), "Marshal failed ", err.Error(), tips.String())
+		return
+	}
+	Notification(&n)
+}
+
+// SetPrivate调用
+func ConversationSetPrivateNotification(operationID, sendID, recvID string, isPrivateChat bool) {
+	log.NewInfo(operationID, utils.GetSelfFuncName())
+	conversationSetPrivateTips := &open_im_sdk.ConversationSetPrivateTips{
+		RecvID:    recvID,
+		SendID:    sendID,
+		IsPrivate: isPrivateChat,
+	}
+	var tips open_im_sdk.TipsComm
+	var tipsMsg string
+	//var senderName string
+	//senderName, err := im_mysql_model.GetUserNameByUserID(sendID)
+	//if err != nil {
+	//	log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
+	//	senderName = sendID
+	//}
+	if isPrivateChat == true {
+		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.OpenTips
+	} else {
+		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.CloseTips
+	}
+	tips.DefaultTips = tipsMsg
+	SetConversationNotification(operationID, sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, tips)
+}
+
+// 会话改变
+func ConversationChangeNotification(operationID, userID string) {
+	log.NewInfo(operationID, utils.GetSelfFuncName())
+	ConversationChangedTips := &open_im_sdk.ConversationUpdateTips{
+		UserID: userID,
+	}
+	var tips open_im_sdk.TipsComm
+	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
+	SetConversationNotification(operationID, userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, tips)
+}

internal/rpc/msg/del_msg.go

@@ -0,0 +1,23 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	commonPb "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+)
+
+func (rpc *rpcChat) DelMsgList(_ context.Context, req *commonPb.DelMsgListReq) (*commonPb.DelMsgListResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &commonPb.DelMsgListResp{}
+	if err := db.DB.DelMsgLogic(req.UserID, req.SeqList, req.OperationID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelMsg failed", err.Error())
+		resp.ErrMsg = constant.ErrDB.ErrMsg
+		resp.ErrCode = constant.ErrDB.ErrCode
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}

internal/rpc/msg/friend_notification.go

@@ -0,0 +1,165 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	utils2 "Open_IM/pkg/common/utils"
+	pbFriend "Open_IM/pkg/proto/friend"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+)
+
+func getFromToUserNickname(fromUserID, toUserID string) (string, string, error) {
+	from, err := imdb.GetUserByUserID(fromUserID)
+	if err != nil {
+		return "", "", utils.Wrap(err, "")
+	}
+	to, err := imdb.GetUserByUserID(toUserID)
+	if err != nil {
+		return "", "", utils.Wrap(err, "")
+	}
+	return from.Nickname, to.Nickname, nil
+}
+
+func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Message) {
+	log.Info(commID.OperationID, utils.GetSelfFuncName(), "args: ", commID, contentType)
+	var err error
+	var tips open_im_sdk.TipsComm
+	tips.Detail, err = proto.Marshal(m)
+	if err != nil {
+		log.Error(commID.OperationID, "Marshal failed ", err.Error(), m.String())
+		return
+	}
+
+	marshaler := jsonpb.Marshaler{
+		OrigName:     true,
+		EnumsAsInts:  false,
+		EmitDefaults: false,
+	}
+
+	tips.JsonDetail, _ = marshaler.MarshalToString(m)
+
+	fromUserNickname, toUserNickname, err := getFromToUserNickname(commID.FromUserID, commID.ToUserID)
+	if err != nil {
+		log.Error(commID.OperationID, "getFromToUserNickname failed ", err.Error(), commID.FromUserID, commID.ToUserID)
+		return
+	}
+	cn := config.Config.Notification
+	switch contentType {
+	case constant.FriendApplicationNotification:
+		tips.DefaultTips = fromUserNickname + cn.FriendApplication.DefaultTips.Tips
+	case constant.FriendApplicationApprovedNotification:
+		tips.DefaultTips = fromUserNickname + cn.FriendApplicationApproved.DefaultTips.Tips
+	case constant.FriendApplicationRejectedNotification:
+		tips.DefaultTips = fromUserNickname + cn.FriendApplicationRejected.DefaultTips.Tips
+	case constant.FriendAddedNotification:
+		tips.DefaultTips = cn.FriendAdded.DefaultTips.Tips
+	case constant.FriendDeletedNotification:
+		tips.DefaultTips = cn.FriendDeleted.DefaultTips.Tips + toUserNickname
+	case constant.FriendRemarkSetNotification:
+		tips.DefaultTips = fromUserNickname + cn.FriendRemarkSet.DefaultTips.Tips
+	case constant.BlackAddedNotification:
+		tips.DefaultTips = cn.BlackAdded.DefaultTips.Tips
+	case constant.BlackDeletedNotification:
+		tips.DefaultTips = cn.BlackDeleted.DefaultTips.Tips + toUserNickname
+	case constant.UserInfoUpdatedNotification:
+		tips.DefaultTips = cn.UserInfoUpdated.DefaultTips.Tips
+	default:
+		log.Error(commID.OperationID, "contentType failed ", contentType)
+		return
+	}
+
+	var n NotificationMsg
+	n.SendID = commID.FromUserID
+	n.RecvID = commID.ToUserID
+	n.ContentType = contentType
+	n.SessionType = constant.SingleChatType
+	n.MsgFrom = constant.SysMsgType
+	n.OperationID = commID.OperationID
+	n.Content, err = proto.Marshal(&tips)
+	if err != nil {
+		log.Error(commID.OperationID, "Marshal failed ", err.Error(), tips.String())
+		return
+	}
+	Notification(&n)
+}
+
+func FriendApplicationNotification(req *pbFriend.AddFriendReq) {
+	FriendApplicationTips := open_im_sdk.FriendApplicationTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	FriendApplicationTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	friendNotification(req.CommID, constant.FriendApplicationNotification, &FriendApplicationTips)
+}
+
+func FriendApplicationApprovedNotification(req *pbFriend.AddFriendResponseReq) {
+	FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
+	friendNotification(req.CommID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
+}
+
+func FriendApplicationRejectedNotification(req *pbFriend.AddFriendResponseReq) {
+	FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
+	friendNotification(req.CommID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
+}
+
+func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string) {
+	friendAddedTips := open_im_sdk.FriendAddedTips{Friend: &open_im_sdk.FriendInfo{}, OpUser: &open_im_sdk.PublicUserInfo{}}
+	user, err := imdb.GetUserByUserID(opUserID)
+	if err != nil {
+		log.NewError(operationID, "GetUserByUserID failed ", err.Error(), opUserID)
+		return
+	}
+	utils2.UserDBCopyOpenIMPublicUser(friendAddedTips.OpUser, user)
+	friend, err := imdb.GetFriendRelationshipFromFriend(fromUserID, toUserID)
+	if err != nil {
+		log.NewError(operationID, "GetFriendRelationshipFromFriend failed ", err.Error(), fromUserID, toUserID)
+		return
+	}
+	utils2.FriendDBCopyOpenIM(friendAddedTips.Friend, friend)
+	commID := pbFriend.CommID{FromUserID: fromUserID, ToUserID: toUserID, OpUserID: opUserID, OperationID: operationID}
+	friendNotification(&commID, constant.FriendAddedNotification, &friendAddedTips)
+}
+
+func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) {
+	friendDeletedTips := open_im_sdk.FriendDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	friendDeletedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	friendDeletedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	friendNotification(req.CommID, constant.FriendDeletedNotification, &friendDeletedTips)
+}
+
+func FriendRemarkSetNotification(operationID, opUserID, fromUserID, toUserID string) {
+	friendInfoChangedTips := open_im_sdk.FriendInfoChangedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
+	friendInfoChangedTips.FromToUserID.ToUserID = toUserID
+	commID := pbFriend.CommID{FromUserID: fromUserID, ToUserID: toUserID, OpUserID: opUserID, OperationID: operationID}
+	friendNotification(&commID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
+}
+
+func BlackAddedNotification(req *pbFriend.AddBlacklistReq) {
+	blackAddedTips := open_im_sdk.BlackAddedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	blackAddedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	blackAddedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	friendNotification(req.CommID, constant.BlackAddedNotification, &blackAddedTips)
+}
+
+func BlackDeletedNotification(req *pbFriend.RemoveBlacklistReq) {
+	blackDeletedTips := open_im_sdk.BlackDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
+	blackDeletedTips.FromToUserID.FromUserID = req.CommID.FromUserID
+	blackDeletedTips.FromToUserID.ToUserID = req.CommID.ToUserID
+	friendNotification(req.CommID, constant.BlackDeletedNotification, &blackDeletedTips)
+}
+
+func UserInfoUpdatedNotification(operationID, userID string, needNotifiedUserID string) {
+	selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: userID}
+	commID := pbFriend.CommID{FromUserID: userID, ToUserID: needNotifiedUserID, OpUserID: userID, OperationID: operationID}
+	friendNotification(&commID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
+}

internal/rpc/msg/group_notification.go

@@ -0,0 +1,508 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	utils2 "Open_IM/pkg/common/utils"
+	pbGroup "Open_IM/pkg/proto/group"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+)
+
+//message GroupCreatedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo Creator = 2;
+//  repeated GroupMemberFullInfo MemberList = 3;
+//  uint64 OperationTime = 4;
+//} creator->group
+
+func setOpUserInfo(opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
+	if token_verify.IsManagerUserID(opUserID) {
+		u, err := imdb.GetUserByUserID(opUserID)
+		if err != nil {
+			return utils.Wrap(err, "GetUserByUserID failed")
+		}
+		utils.CopyStructFields(groupMemberInfo, u)
+		groupMemberInfo.GroupID = groupID
+	} else {
+		u, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, opUserID)
+		if err == nil {
+			if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, u); err != nil {
+				return utils.Wrap(err, "")
+			}
+		}
+
+		user, err := imdb.GetUserByUserID(opUserID)
+		if err != nil {
+			return utils.Wrap(err, "")
+		}
+		groupMemberInfo.GroupID = groupID
+		groupMemberInfo.UserID = user.UserID
+		groupMemberInfo.Nickname = user.Nickname
+		groupMemberInfo.AppMangerLevel = user.AppMangerLevel
+		groupMemberInfo.FaceURL = user.FaceURL
+	}
+	return nil
+}
+
+func setGroupInfo(groupID string, groupInfo *open_im_sdk.GroupInfo) error {
+	group, err := imdb.GetGroupInfoByGroupID(groupID)
+	if err != nil {
+		return utils.Wrap(err, "GetGroupInfoByGroupID failed")
+	}
+	err = utils2.GroupDBCopyOpenIM(groupInfo, group)
+	if err != nil {
+		return utils.Wrap(err, "GetGroupMemberNumByGroupID failed")
+	}
+	return nil
+}
+
+func setGroupMemberInfo(groupID, userID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
+	groupMember, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
+	if err == nil {
+		return utils.Wrap(utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember), "")
+	}
+
+	user, err := imdb.GetUserByUserID(userID)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	groupMemberInfo.GroupID = groupID
+	groupMemberInfo.UserID = user.UserID
+	groupMemberInfo.Nickname = user.Nickname
+	groupMemberInfo.AppMangerLevel = user.AppMangerLevel
+	groupMemberInfo.FaceURL = user.FaceURL
+	return nil
+}
+
+func setGroupOwnerInfo(groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
+	groupMember, err := imdb.GetGroupOwnerInfoByGroupID(groupID)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil {
+		return utils.Wrap(err, "")
+	}
+	return nil
+}
+
+func setPublicUserInfo(userID string, publicUserInfo *open_im_sdk.PublicUserInfo) error {
+	user, err := imdb.GetUserByUserID(userID)
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	utils2.UserDBCopyOpenIMPublicUser(publicUserInfo, user)
+	return nil
+}
+
+func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
+	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType)
+
+	var err error
+	var tips open_im_sdk.TipsComm
+	tips.Detail, err = proto.Marshal(m)
+	if err != nil {
+		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
+		return
+	}
+	marshaler := jsonpb.Marshaler{
+		OrigName:     true,
+		EnumsAsInts:  false,
+		EmitDefaults: false,
+	}
+
+	tips.JsonDetail, _ = marshaler.MarshalToString(m)
+
+	from, err := imdb.GetUserByUserID(sendID)
+	if err != nil {
+		log.Error(operationID, "GetUserByUserID failed ", err.Error(), sendID)
+	}
+	nickname := ""
+	if from != nil {
+		nickname = from.Nickname
+	}
+
+	to, err := imdb.GetUserByUserID(recvUserID)
+	if err != nil {
+		log.Error(operationID, "GetUserByUserID failed ", err.Error(), recvUserID)
+	}
+	toNickname := ""
+	if to != nil {
+		toNickname = to.Nickname
+	}
+
+	cn := config.Config.Notification
+	switch contentType {
+	case constant.GroupCreatedNotification:
+		tips.DefaultTips = nickname + " " + cn.GroupCreated.DefaultTips.Tips
+	case constant.GroupInfoSetNotification:
+		tips.DefaultTips = nickname + " " + cn.GroupInfoSet.DefaultTips.Tips
+	case constant.JoinGroupApplicationNotification:
+		tips.DefaultTips = nickname + " " + cn.JoinGroupApplication.DefaultTips.Tips
+	case constant.MemberQuitNotification:
+		tips.DefaultTips = nickname + " " + cn.MemberQuit.DefaultTips.Tips
+	case constant.GroupApplicationAcceptedNotification: //
+		tips.DefaultTips = toNickname + " " + cn.GroupApplicationAccepted.DefaultTips.Tips
+	case constant.GroupApplicationRejectedNotification: //
+		tips.DefaultTips = toNickname + " " + cn.GroupApplicationRejected.DefaultTips.Tips
+	case constant.GroupOwnerTransferredNotification: //
+		tips.DefaultTips = toNickname + " " + cn.GroupOwnerTransferred.DefaultTips.Tips
+	case constant.MemberKickedNotification: //
+		tips.DefaultTips = toNickname + " " + cn.MemberKicked.DefaultTips.Tips
+	case constant.MemberInvitedNotification: //
+		tips.DefaultTips = toNickname + " " + cn.MemberInvited.DefaultTips.Tips
+	case constant.MemberEnterNotification:
+		tips.DefaultTips = toNickname + " " + cn.MemberEnter.DefaultTips.Tips
+	case constant.GroupDismissedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupDismissed.DefaultTips.Tips
+	case constant.GroupMutedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMuted.DefaultTips.Tips
+	case constant.GroupCancelMutedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupCancelMuted.DefaultTips.Tips
+	case constant.GroupMemberMutedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberMuted.DefaultTips.Tips
+	case constant.GroupMemberCancelMutedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips
+	default:
+		log.Error(operationID, "contentType failed ", contentType)
+		return
+	}
+
+	var n NotificationMsg
+	n.SendID = sendID
+	if groupID != "" {
+		n.RecvID = groupID
+		n.SessionType = constant.GroupChatType
+	} else {
+		n.RecvID = recvUserID
+		n.SessionType = constant.SingleChatType
+	}
+	n.ContentType = contentType
+	n.OperationID = operationID
+	n.Content, err = proto.Marshal(&tips)
+	if err != nil {
+		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
+		return
+	}
+	Notification(&n)
+}
+
+//创建群后调用
+func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) {
+	GroupCreatedTips := open_im_sdk.GroupCreatedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, GroupOwnerUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil {
+		log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser)
+		return
+	}
+	err := setGroupInfo(groupID, GroupCreatedTips.Group)
+	if err != nil {
+		log.Error(operationID, "setGroupInfo failed ", groupID, GroupCreatedTips.Group)
+		return
+	}
+	imdb.GetGroupOwnerInfoByGroupID(groupID)
+	if err := setGroupOwnerInfo(groupID, GroupCreatedTips.GroupOwnerUser); err != nil {
+		log.Error(operationID, "setGroupOwnerInfo failed", err.Error(), groupID)
+		return
+	}
+	for _, v := range initMemberList {
+		var groupMemberInfo open_im_sdk.GroupMemberFullInfo
+		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
+			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v)
+			continue
+		}
+		GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo)
+	}
+	groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
+}
+
+//群信息改变后掉用
+func GroupInfoSetNotification(operationID, opUserID, groupID string) {
+	GroupInfoChangedTips := open_im_sdk.GroupInfoSetTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID)
+}
+
+func GroupMutedNotification(operationID, opUserID, groupID string) {
+	tips := open_im_sdk.GroupMutedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, tips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	groupNotification(constant.GroupMutedNotification, &tips, opUserID, groupID, "", operationID)
+}
+
+func GroupCancelMutedNotification(operationID, opUserID, groupID string) {
+	tips := open_im_sdk.GroupCancelMutedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, tips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	groupNotification(constant.GroupCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
+}
+
+func GroupMemberMutedNotification(operationID, opUserID, groupID, groupMemberUserID string, mutedSeconds uint32) {
+	tips := open_im_sdk.GroupMemberMutedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, MutedUser: &open_im_sdk.GroupMemberFullInfo{}}
+	tips.MutedSeconds = mutedSeconds
+	if err := setGroupInfo(groupID, tips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
+		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
+		return
+	}
+	groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID)
+}
+
+func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
+	tips := open_im_sdk.GroupMemberCancelMutedTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, MutedUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, tips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
+		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
+		return
+	}
+	groupNotification(constant.GroupMemberCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
+}
+
+//message ReceiveJoinApplicationTips{
+//  GroupInfo Group = 1;
+//  PublicUserInfo Applicant  = 2;
+//  string 	Reason = 3;
+//}  apply->all managers GroupID              string   `protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"`
+//	ReqMessage           string   `protobuf:"bytes,2,opt,name=ReqMessage" json:"ReqMessage,omitempty"`
+//	OpUserID             string   `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"`
+//	OperationID          string   `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
+//申请进群后调用
+func JoinGroupApplicationNotification(req *pbGroup.JoinGroupReq) {
+	JoinGroupApplicationTips := open_im_sdk.JoinGroupApplicationTips{Group: &open_im_sdk.GroupInfo{}, Applicant: &open_im_sdk.PublicUserInfo{}}
+	err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group)
+	if err != nil {
+		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
+		return
+	}
+	if err = setPublicUserInfo(req.OpUserID, JoinGroupApplicationTips.Applicant); err != nil {
+		log.Error(req.OperationID, "setPublicUserInfo failed ", err.Error(), req.OpUserID)
+		return
+	}
+	JoinGroupApplicationTips.ReqMsg = req.ReqMessage
+
+	managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
+		return
+	}
+	for _, v := range managerList {
+		groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, req.OpUserID, "", v.UserID, req.OperationID)
+		log.NewInfo(req.OperationID, "Notification ", v)
+	}
+}
+
+func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
+	MemberQuitTips := open_im_sdk.MemberQuitTips{Group: &open_im_sdk.GroupInfo{}, QuitUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(req.GroupID, MemberQuitTips.Group); err != nil {
+		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
+		return
+	}
+	if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberQuitTips.QuitUser); err != nil {
+		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID)
+		return
+	}
+
+	groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID)
+	//	groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, "", req.OpUserID, req.OperationID)
+
+}
+
+//message ApplicationProcessedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo OpUser = 2;
+//  int32 Result = 3;
+//  string 	Reason = 4;
+//}
+//处理进群请求后调用
+func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) {
+	GroupApplicationAcceptedTips := open_im_sdk.GroupApplicationAcceptedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
+	if err := setGroupInfo(req.GroupID, GroupApplicationAcceptedTips.Group); err != nil {
+		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationAcceptedTips.Group)
+		return
+	}
+	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser); err != nil {
+		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser)
+		return
+	}
+	groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
+}
+
+func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) {
+	GroupApplicationRejectedTips := open_im_sdk.GroupApplicationRejectedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
+	if err := setGroupInfo(req.GroupID, GroupApplicationRejectedTips.Group); err != nil {
+		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationRejectedTips.Group)
+		return
+	}
+	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser); err != nil {
+		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser)
+		return
+	}
+	groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
+}
+
+func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
+	GroupOwnerTransferredTips := open_im_sdk.GroupOwnerTransferredTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, NewGroupOwner: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(req.GroupID, GroupOwnerTransferredTips.Group); err != nil {
+		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
+		return
+	}
+	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupOwnerTransferredTips.OpUser); err != nil {
+		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
+		return
+	}
+	if err := setGroupMemberInfo(req.GroupID, req.NewOwnerUserID, GroupOwnerTransferredTips.NewGroupOwner); err != nil {
+		log.Error(req.OperationID, "setGroupMemberInfo failed", req.GroupID, req.NewOwnerUserID)
+		return
+	}
+	groupNotification(constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, req.OpUserID, req.GroupID, "", req.OperationID)
+}
+
+func GroupDismissedNotification(req *pbGroup.DismissGroupReq) {
+	tips := open_im_sdk.GroupDismissedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(req.GroupID, tips.Group); err != nil {
+		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
+		return
+	}
+	if err := setOpUserInfo(req.OpUserID, req.GroupID, tips.OpUser); err != nil {
+		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
+		return
+	}
+	groupNotification(constant.GroupDismissedNotification, &tips, req.OpUserID, req.GroupID, "", req.OperationID)
+}
+
+//message MemberKickedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo OpUser = 2;
+//  GroupMemberFullInfo KickedUser = 3;
+//  uint64 OperationTime = 4;
+//}
+//被踢后调用
+func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
+	MemberKickedTips := open_im_sdk.MemberKickedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(req.GroupID, MemberKickedTips.Group); err != nil {
+		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
+		return
+	}
+	if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberKickedTips.OpUser); err != nil {
+		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID)
+		return
+	}
+	for _, v := range kickedUserIDList {
+		var groupMemberInfo open_im_sdk.GroupMemberFullInfo
+		if err := setGroupMemberInfo(req.GroupID, v, &groupMemberInfo); err != nil {
+			log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.GroupID, v)
+			continue
+		}
+		MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
+	}
+	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, req.GroupID, "", req.OperationID)
+	//
+	//for _, v := range kickedUserIDList {
+	//	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID)
+	//}
+}
+
+//message MemberInvitedTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo OpUser = 2;
+//  GroupMemberFullInfo InvitedUser = 3;
+//  uint64 OperationTime = 4;
+//}
+//被邀请进群后调用
+func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
+	MemberInvitedTips := open_im_sdk.MemberInvitedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, MemberInvitedTips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, MemberInvitedTips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	for _, v := range invitedUserIDList {
+		var groupMemberInfo open_im_sdk.GroupMemberFullInfo
+		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
+			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID)
+			continue
+		}
+		MemberInvitedTips.InvitedUserList = append(MemberInvitedTips.InvitedUserList, &groupMemberInfo)
+	}
+
+	groupNotification(constant.MemberInvitedNotification, &MemberInvitedTips, opUserID, groupID, "", operationID)
+}
+
+//message GroupInfoChangedTips{
+//  int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification  100:Introduction; 1000:FaceUrl
+//  GroupInfo Group = 2;
+//  GroupMemberFullInfo OpUser = 3;
+//}
+
+//message MemberLeaveTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo LeaverUser = 2;
+//  uint64 OperationTime = 3;
+//}
+
+//群成员退群后调用
+
+//message MemberEnterTips{
+//  GroupInfo Group = 1;
+//  GroupMemberFullInfo EntrantUser = 2;
+//  uint64 OperationTime = 3;
+//}
+//群成员主动申请进群，管理员同意后调用，
+func MemberEnterNotification(req *pbGroup.GroupApplicationResponseReq) {
+	MemberEnterTips := open_im_sdk.MemberEnterTips{Group: &open_im_sdk.GroupInfo{}, EntrantUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(req.GroupID, MemberEnterTips.Group); err != nil {
+		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberEnterTips.Group)
+		return
+	}
+	if err := setGroupMemberInfo(req.GroupID, req.FromUserID, MemberEnterTips.EntrantUser); err != nil {
+		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser)
+		return
+	}
+	groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID)
+
+}

internal/rpc/msg/pull_message.go

@@ -0,0 +1,74 @@
+package msg
+
+import (
+	"context"
+	"github.com/garyburd/redigo/redis"
+
+	commonDB "Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	pbMsg "Open_IM/pkg/proto/chat"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+)
+
+func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *pbMsg.GetMaxAndMinSeqReq) (*pbMsg.GetMaxAndMinSeqResp, error) {
+	log.InfoByKv("rpc getMaxAndMinSeq is arriving", in.OperationID, in.String())
+	//seq, err := model.GetBiggestSeqFromReceive(in.UserID)
+	maxSeq, err1 := commonDB.DB.GetUserMaxSeq(in.UserID)
+	minSeq, err2 := commonDB.DB.GetUserMinSeq(in.UserID)
+	resp := new(pbMsg.GetMaxAndMinSeqResp)
+	if err1 == nil {
+		resp.MaxSeq = uint32(maxSeq)
+	} else if err1 == redis.ErrNil {
+		resp.MaxSeq = 0
+	} else {
+		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String(), err1.Error())
+		resp.ErrCode = 200
+		resp.ErrMsg = "redis get err"
+	}
+	if err2 == nil {
+		resp.MinSeq = uint32(minSeq)
+	} else if err2 == redis.ErrNil {
+		resp.MinSeq = 0
+	} else {
+		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String(), err2.Error())
+		resp.ErrCode = 201
+		resp.ErrMsg = "redis get err"
+	}
+	return resp, nil
+}
+func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *open_im_sdk.PullMessageBySeqListReq) (*open_im_sdk.PullMessageBySeqListResp, error) {
+	log.NewInfo(in.OperationID, "rpc PullMessageBySeqList is arriving", in.String())
+	resp := new(open_im_sdk.PullMessageBySeqListResp)
+	//msgList, err := commonDB.DB.GetMsgBySeqList(in.UserID, in.SeqList, in.OperationID)
+	msgList, err := commonDB.DB.GetMsgBySeqListMongo2(in.UserID, in.SeqList, in.OperationID)
+	if err != nil {
+		log.ErrorByKv("PullMessageBySeqList data error", in.OperationID, in.String())
+		resp.ErrCode = 201
+		resp.ErrMsg = err.Error()
+		return resp, nil
+	}
+	//respSingleMsgFormat = singleMsgHandleByUser(SingleMsgFormat, in.UserID)
+	//respGroupMsgFormat = groupMsgHandleByUser(GroupMsgFormat)
+	resp.ErrCode = 0
+	resp.ErrMsg = ""
+	resp.List = msgList
+	return resp, nil
+
+}
+
+type MsgFormats []*open_im_sdk.MsgData
+
+// Implement the sort.Interface interface to get the number of elements method
+func (s MsgFormats) Len() int {
+	return len(s)
+}
+
+//Implement the sort.Interface interface comparison element method
+func (s MsgFormats) Less(i, j int) bool {
+	return s[i].SendTime < s[j].SendTime
+}
+
+//Implement the sort.Interface interface exchange element method
+func (s MsgFormats) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}

internal/rpc/msg/rpcChat.go

@@ -0,0 +1,67 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
+	"google.golang.org/grpc"
+	"net"
+	"strconv"
+	"strings"
+)
+
+type rpcChat struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+	producer        *kafka.Producer
+}
+
+func NewRpcChatServer(port int) *rpcChat {
+	log.NewPrivateLog(constant.LogFileName)
+	rc := rpcChat{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImOfflineMessageName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+	rc.producer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.Ws2mschat.Topic)
+	return &rc
+}
+
+func (rpc *rpcChat) Run() {
+	log.Info("", "", "rpc get_token init...")
+
+	address := utils.ServerIP + ":" + strconv.Itoa(rpc.rpcPort)
+	listener, err := net.Listen("tcp", address)
+	if err != nil {
+		log.Error("", "", "listen network failed, err = %s, address = %s", err.Error(), address)
+		return
+	}
+	log.Info("", "", "listen network success, address = ", address)
+
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+
+	//service registers with etcd
+
+	pbChat.RegisterChatServer(srv, rpc)
+	err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName, 10)
+	if err != nil {
+		log.Error("", "", "register rpc get_token to etcd failed, err = %s", err.Error())
+		return
+	}
+
+	err = srv.Serve(listener)
+	if err != nil {
+		log.Info("", "", "rpc get_token fail, err = %s", err.Error())
+		return
+	}
+	log.Info("", "", "rpc get_token init success")
+}

internal/rpc/msg/send_msg.go

@@ -0,0 +1,593 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	rpc "Open_IM/pkg/proto/friend"
+	pbGroup "Open_IM/pkg/proto/group"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/garyburd/redigo/redis"
+	"github.com/golang/protobuf/proto"
+	"math/rand"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type MsgCallBackReq struct {
+	SendID       string `json:"sendID"`
+	RecvID       string `json:"recvID"`
+	Content      string `json:"content"`
+	SendTime     int64  `json:"sendTime"`
+	MsgFrom      int32  `json:"msgFrom"`
+	ContentType  int32  `json:"contentType"`
+	SessionType  int32  `json:"sessionType"`
+	PlatformID   int32  `json:"senderPlatformID"`
+	MsgID        string `json:"msgID"`
+	IsOnlineOnly bool   `json:"isOnlineOnly"`
+}
+type MsgCallBackResp struct {
+	ErrCode         int32  `json:"errCode"`
+	ErrMsg          string `json:"errMsg"`
+	ResponseErrCode int32  `json:"responseErrCode"`
+	ResponseResult  struct {
+		ModifiedMsg string `json:"modifiedMsg"`
+		Ext         string `json:"ext"`
+	}
+}
+
+func userRelationshipVerification(data *pbChat.SendMsgReq) (bool, int32, string) {
+	if data.MsgData.SessionType == constant.GroupChatType {
+		return true, 0, ""
+	}
+	log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
+	req := &rpc.IsInBlackListReq{CommID: &rpc.CommID{}}
+	req.CommID.OperationID = data.OperationID
+	req.CommID.OpUserID = data.MsgData.RecvID
+	req.CommID.FromUserID = data.MsgData.RecvID
+	req.CommID.ToUserID = data.MsgData.SendID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := rpc.NewFriendClient(etcdConn)
+	reply, err := client.IsInBlackList(context.Background(), req)
+	if err != nil {
+		log.NewDebug(data.OperationID, "IsInBlackListReq rpc failed, ", req.String(), err.Error())
+	} else if reply.Response == true {
+		log.NewDebug(data.OperationID, "IsInBlackListReq  ", req.String())
+		return false, 600, "in black list"
+	}
+	log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
+	if config.Config.MessageVerify.FriendVerify {
+		friendReq := &rpc.IsFriendReq{CommID: &rpc.CommID{}}
+		friendReq.CommID.OperationID = data.OperationID
+		friendReq.CommID.OpUserID = data.MsgData.RecvID
+		friendReq.CommID.FromUserID = data.MsgData.RecvID
+		friendReq.CommID.ToUserID = data.MsgData.SendID
+		friendReply, err := client.IsFriend(context.Background(), friendReq)
+		if err != nil {
+			log.NewDebug(data.OperationID, "IsFriendReq rpc failed, ", req.String(), err.Error())
+			return true, 0, ""
+		} else if friendReply.Response == false {
+			log.NewDebug(data.OperationID, "not friend  ", req.String())
+			return friendReply.Response, 601, "not friend"
+		}
+		log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify, friendReply.Response)
+		return true, 0, ""
+	} else {
+		return true, 0, ""
+	}
+}
+func (rpc *rpcChat) encapsulateMsgData(msg *sdk_ws.MsgData) {
+	msg.ServerMsgID = GetMsgID(msg.SendID)
+	msg.SendTime = utils.GetCurrentTimestampByMill()
+	switch msg.ContentType {
+	case constant.Text:
+		fallthrough
+	case constant.Picture:
+		fallthrough
+	case constant.Voice:
+		fallthrough
+	case constant.Video:
+		fallthrough
+	case constant.File:
+		fallthrough
+	case constant.AtText:
+		fallthrough
+	case constant.Merger:
+		fallthrough
+	case constant.Card:
+		fallthrough
+	case constant.Location:
+		fallthrough
+	case constant.Custom:
+		fallthrough
+	case constant.Quote:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, true)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, true)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderSync, true)
+	case constant.Revoke:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
+	case constant.HasReadReceipt:
+		log.Info("", "this is a test start", msg, msg.Options)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
+		log.Info("", "this is a test end", msg, msg.Options)
+	case constant.Typing:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsHistory, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsPersistent, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderSync, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, false)
+
+	}
+}
+func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.SendMsgResp, error) {
+	replay := pbChat.SendMsgResp{}
+	log.NewDebug(pb.OperationID, "rpc sendMsg come here", pb.String())
+	flag, errCode, errMsg := userRelationshipVerification(pb)
+	if !flag {
+		return returnMsg(&replay, pb, errCode, errMsg, "", 0)
+	}
+	//if !utils.VerifyToken(pb.Token, pb.SendID) {
+	//	return returnMsg(&replay, pb, http.StatusUnauthorized, "token validate err,not authorized", "", 0)
+	rpc.encapsulateMsgData(pb.MsgData)
+	log.Info("", "this is a test MsgData ", pb.MsgData)
+	msgToMQ := pbChat.MsgDataToMQ{Token: pb.Token, OperationID: pb.OperationID, MsgData: pb.MsgData}
+	//options := utils.JsonStringToMap(pbData.Options)
+	isHistory := utils.GetSwitchFromOptions(pb.MsgData.Options, constant.IsHistory)
+	mReq := MsgCallBackReq{
+		SendID:      pb.MsgData.SendID,
+		RecvID:      pb.MsgData.RecvID,
+		Content:     string(pb.MsgData.Content),
+		SendTime:    pb.MsgData.SendTime,
+		MsgFrom:     pb.MsgData.MsgFrom,
+		ContentType: pb.MsgData.ContentType,
+		SessionType: pb.MsgData.SessionType,
+		PlatformID:  pb.MsgData.SenderPlatformID,
+		MsgID:       pb.MsgData.ClientMsgID,
+	}
+	if !isHistory {
+		mReq.IsOnlineOnly = true
+	}
+
+	// callback
+	canSend, err := callbackWordFilter(pb)
+	if err != nil {
+		log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackWordFilter failed", err.Error(), pb.MsgData)
+	}
+	if !canSend {
+		log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackWordFilter result", canSend, "end rpc and return", pb.MsgData)
+		return returnMsg(&replay, pb, 201, "callbackWordFilter result stop rpc and return", "", 0)
+	}
+	switch pb.MsgData.SessionType {
+	case constant.SingleChatType:
+		// callback
+		canSend, err := callbackBeforeSendSingleMsg(pb)
+		if err != nil {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg failed", err.Error())
+		}
+		if !canSend {
+			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", canSend, "end rpc and return")
+			return returnMsg(&replay, pb, 201, "callbackBeforeSendSingleMsg result stop rpc and return", "", 0)
+		}
+		isSend := modifyMessageByUserMessageReceiveOpt(pb.MsgData.RecvID, pb.MsgData.SendID, constant.SingleChatType, pb)
+		if isSend {
+			msgToMQ.MsgData = pb.MsgData
+			log.NewInfo(msgToMQ.OperationID, msgToMQ)
+			err1 := rpc.sendMsgToKafka(&msgToMQ, msgToMQ.MsgData.RecvID)
+			if err1 != nil {
+				log.NewError(msgToMQ.OperationID, "kafka send msg err:RecvID", msgToMQ.MsgData.RecvID, msgToMQ.String())
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+		if msgToMQ.MsgData.SendID != msgToMQ.MsgData.RecvID { //Filter messages sent to yourself
+			err2 := rpc.sendMsgToKafka(&msgToMQ, msgToMQ.MsgData.SendID)
+			if err2 != nil {
+				log.NewError(msgToMQ.OperationID, "kafka send msg err:SendID", msgToMQ.MsgData.SendID, msgToMQ.String())
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+		// callback
+		if err := callbackAfterSendSingleMsg(pb); err != nil {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendSingleMsg failed", err.Error())
+		}
+		return returnMsg(&replay, pb, 0, "", msgToMQ.MsgData.ServerMsgID, msgToMQ.MsgData.SendTime)
+	case constant.GroupChatType:
+		// callback
+		canSend, err := callbackBeforeSendGroupMsg(pb)
+		if err != nil {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendGroupMsg failed", err.Error())
+		}
+		if !canSend {
+			log.NewDebug(pb.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendGroupMsg result", canSend, "end rpc and return")
+			return returnMsg(&replay, pb, 201, "callbackBeforeSendGroupMsg result stop rpc and return", "", 0)
+		}
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+		client := pbGroup.NewGroupClient(etcdConn)
+		req := &pbGroup.GetGroupAllMemberReq{
+			GroupID:     pb.MsgData.GroupID,
+			OperationID: pb.OperationID,
+		}
+		reply, err := client.GetGroupAllMember(context.Background(), req)
+		if err != nil {
+			log.Error(pb.Token, pb.OperationID, "rpc send_msg getGroupInfo failed, err = %s", err.Error())
+			return returnMsg(&replay, pb, 201, err.Error(), "", 0)
+		}
+		if reply.ErrCode != 0 {
+			log.Error(pb.Token, pb.OperationID, "rpc send_msg getGroupInfo failed, err = %s", reply.ErrMsg)
+			return returnMsg(&replay, pb, reply.ErrCode, reply.ErrMsg, "", 0)
+		}
+		var addUidList []string
+		switch pb.MsgData.ContentType {
+		case constant.MemberKickedNotification:
+			var tips sdk_ws.TipsComm
+			var memberKickedTips sdk_ws.MemberKickedTips
+			err := proto.Unmarshal(pb.MsgData.Content, &tips)
+			if err != nil {
+				log.Error(pb.OperationID, "Unmarshal err", err.Error())
+			}
+			err = proto.Unmarshal(tips.Detail, &memberKickedTips)
+			if err != nil {
+				log.Error(pb.OperationID, "Unmarshal err", err.Error())
+			}
+			log.Info(pb.OperationID, "data is ", memberKickedTips)
+			for _, v := range memberKickedTips.KickedUserList {
+				addUidList = append(addUidList, v.UserID)
+			}
+		case constant.MemberQuitNotification:
+			addUidList = append(addUidList, pb.MsgData.SendID)
+		default:
+		}
+		groupID := pb.MsgData.GroupID
+		for _, v := range reply.MemberList {
+			pb.MsgData.RecvID = v.UserID
+			isSend := modifyMessageByUserMessageReceiveOpt(v.UserID, groupID, constant.GroupChatType, pb)
+			if isSend {
+				msgToMQ.MsgData = pb.MsgData
+				err := rpc.sendMsgToKafka(&msgToMQ, v.UserID)
+				if err != nil {
+					log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v.UserID, msgToMQ.String())
+					return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+				}
+			}
+
+		}
+		log.Info(msgToMQ.OperationID, "addUidList", addUidList)
+		for _, v := range addUidList {
+			pb.MsgData.RecvID = v
+			isSend := modifyMessageByUserMessageReceiveOpt(v, groupID, constant.GroupChatType, pb)
+			log.Info(msgToMQ.OperationID, "isSend", isSend)
+			if isSend {
+				msgToMQ.MsgData = pb.MsgData
+				err := rpc.sendMsgToKafka(&msgToMQ, v)
+				if err != nil {
+					log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v, msgToMQ.String())
+					return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+				}
+			}
+		}
+		// callback
+		if err := callbackAfterSendGroupMsg(pb); err != nil {
+			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendGroupMsg failed", err.Error())
+		}
+		return returnMsg(&replay, pb, 0, "", msgToMQ.MsgData.ServerMsgID, msgToMQ.MsgData.SendTime)
+	case constant.NotificationChatType:
+		msgToMQ.MsgData = pb.MsgData
+		log.NewInfo(msgToMQ.OperationID, msgToMQ)
+		err1 := rpc.sendMsgToKafka(&msgToMQ, msgToMQ.MsgData.RecvID)
+		if err1 != nil {
+			log.NewError(msgToMQ.OperationID, "kafka send msg err:RecvID", msgToMQ.MsgData.RecvID, msgToMQ.String())
+			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+		}
+
+		if msgToMQ.MsgData.SendID != msgToMQ.MsgData.RecvID { //Filter messages sent to yourself
+			err2 := rpc.sendMsgToKafka(&msgToMQ, msgToMQ.MsgData.SendID)
+			if err2 != nil {
+				log.NewError(msgToMQ.OperationID, "kafka send msg err:SendID", msgToMQ.MsgData.SendID, msgToMQ.String())
+				return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+			}
+		}
+		return returnMsg(&replay, pb, 0, "", msgToMQ.MsgData.ServerMsgID, msgToMQ.MsgData.SendTime)
+	default:
+		return returnMsg(&replay, pb, 203, "unkonwn sessionType", "", 0)
+	}
+}
+
+func (rpc *rpcChat) sendMsgToKafka(m *pbChat.MsgDataToMQ, key string) error {
+	pid, offset, err := rpc.producer.SendMessage(m, key)
+	if err != nil {
+		log.ErrorByKv("kafka send failed", m.OperationID, "send data", m.String(), "pid", pid, "offset", offset, "err", err.Error(), "key", key)
+	}
+	return err
+}
+func GetMsgID(sendID string) string {
+	t := time.Now().Format("2006-01-02 15:04:05")
+	return utils.Md5(t + "-" + sendID + "-" + strconv.Itoa(rand.Int()))
+}
+
+func returnMsg(replay *pbChat.SendMsgResp, pb *pbChat.SendMsgReq, errCode int32, errMsg, serverMsgID string, sendTime int64) (*pbChat.SendMsgResp, error) {
+	replay.ErrCode = errCode
+	replay.ErrMsg = errMsg
+	replay.ServerMsgID = serverMsgID
+	replay.ClientMsgID = pb.MsgData.ClientMsgID
+	replay.SendTime = sendTime
+	return replay, nil
+}
+
+func modifyMessageByUserMessageReceiveOpt(userID, sourceID string, sessionType int, pb *pbChat.SendMsgReq) bool {
+	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
+	opt, err := db.DB.GetSingleConversationRecvMsgOpt(userID, conversationID)
+	if err != nil && err != redis.ErrNil {
+		log.NewError(pb.OperationID, "GetSingleConversationMsgOpt from redis err", conversationID, pb.String(), err.Error())
+		return true
+	}
+	switch opt {
+	case constant.ReceiveMessage:
+		return true
+	case constant.NotReceiveMessage:
+		return false
+	case constant.ReceiveNotNotifyMessage:
+		if pb.MsgData.Options == nil {
+			pb.MsgData.Options = make(map[string]bool, 10)
+		}
+		utils.SetSwitchFromOptions(pb.MsgData.Options, constant.IsOfflinePush, false)
+		return true
+	}
+
+	return true
+}
+
+type NotificationMsg struct {
+	SendID      string
+	RecvID      string
+	Content     []byte //  open_im_sdk.TipsComm
+	MsgFrom     int32
+	ContentType int32
+	SessionType int32
+	OperationID string
+}
+
+func Notification(n *NotificationMsg) {
+	var req pbChat.SendMsgReq
+	var msg sdk_ws.MsgData
+	var offlineInfo sdk_ws.OfflinePushInfo
+	var title, desc, ex string
+	var pushSwitch, unReadCount bool
+	var reliabilityLevel int
+	req.OperationID = n.OperationID
+	msg.SendID = n.SendID
+	msg.RecvID = n.RecvID
+	msg.Content = n.Content
+	msg.MsgFrom = n.MsgFrom
+	msg.ContentType = n.ContentType
+	msg.SessionType = n.SessionType
+	msg.CreateTime = utils.GetCurrentTimestampByMill()
+	msg.ClientMsgID = utils.GetMsgID(n.SendID)
+	msg.Options = make(map[string]bool, 7)
+	switch n.SessionType {
+	case constant.GroupChatType:
+		msg.RecvID = ""
+		msg.GroupID = n.RecvID
+	}
+	offlineInfo.IOSBadgeCount = config.Config.IOSPush.BadgeCount
+	offlineInfo.IOSPushSound = config.Config.IOSPush.PushSound
+	switch msg.ContentType {
+	case constant.GroupCreatedNotification:
+		pushSwitch = config.Config.Notification.GroupCreated.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupCreated.OfflinePush.Title
+		desc = config.Config.Notification.GroupCreated.OfflinePush.Desc
+		ex = config.Config.Notification.GroupCreated.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupCreated.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupCreated.Conversation.UnreadCount
+	case constant.GroupInfoSetNotification:
+		pushSwitch = config.Config.Notification.GroupInfoSet.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupInfoSet.OfflinePush.Title
+		desc = config.Config.Notification.GroupInfoSet.OfflinePush.Desc
+		ex = config.Config.Notification.GroupInfoSet.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupInfoSet.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupInfoSet.Conversation.UnreadCount
+	case constant.JoinGroupApplicationNotification:
+		pushSwitch = config.Config.Notification.JoinGroupApplication.OfflinePush.PushSwitch
+		title = config.Config.Notification.JoinGroupApplication.OfflinePush.Title
+		desc = config.Config.Notification.JoinGroupApplication.OfflinePush.Desc
+		ex = config.Config.Notification.JoinGroupApplication.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.JoinGroupApplication.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.JoinGroupApplication.Conversation.UnreadCount
+	case constant.MemberQuitNotification:
+		pushSwitch = config.Config.Notification.MemberQuit.OfflinePush.PushSwitch
+		title = config.Config.Notification.MemberQuit.OfflinePush.Title
+		desc = config.Config.Notification.MemberQuit.OfflinePush.Desc
+		ex = config.Config.Notification.MemberQuit.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.MemberQuit.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.MemberQuit.Conversation.UnreadCount
+	case constant.GroupApplicationAcceptedNotification:
+		pushSwitch = config.Config.Notification.GroupApplicationAccepted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Title
+		desc = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupApplicationAccepted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupApplicationAccepted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupApplicationAccepted.Conversation.UnreadCount
+	case constant.GroupApplicationRejectedNotification:
+		pushSwitch = config.Config.Notification.GroupApplicationRejected.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupApplicationRejected.OfflinePush.Title
+		desc = config.Config.Notification.GroupApplicationRejected.OfflinePush.Desc
+		ex = config.Config.Notification.GroupApplicationRejected.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupApplicationRejected.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupApplicationRejected.Conversation.UnreadCount
+	case constant.GroupOwnerTransferredNotification:
+		pushSwitch = config.Config.Notification.GroupOwnerTransferred.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Title
+		desc = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Desc
+		ex = config.Config.Notification.GroupOwnerTransferred.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupOwnerTransferred.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupOwnerTransferred.Conversation.UnreadCount
+	case constant.MemberKickedNotification:
+		pushSwitch = config.Config.Notification.MemberKicked.OfflinePush.PushSwitch
+		title = config.Config.Notification.MemberKicked.OfflinePush.Title
+		desc = config.Config.Notification.MemberKicked.OfflinePush.Desc
+		ex = config.Config.Notification.MemberKicked.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.MemberKicked.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.MemberKicked.Conversation.UnreadCount
+	case constant.MemberInvitedNotification:
+		pushSwitch = config.Config.Notification.MemberInvited.OfflinePush.PushSwitch
+		title = config.Config.Notification.MemberInvited.OfflinePush.Title
+		desc = config.Config.Notification.MemberInvited.OfflinePush.Desc
+		ex = config.Config.Notification.MemberInvited.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.MemberInvited.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.MemberInvited.Conversation.UnreadCount
+	case constant.MemberEnterNotification:
+		pushSwitch = config.Config.Notification.MemberEnter.OfflinePush.PushSwitch
+		title = config.Config.Notification.MemberEnter.OfflinePush.Title
+		desc = config.Config.Notification.MemberEnter.OfflinePush.Desc
+		ex = config.Config.Notification.MemberEnter.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.MemberEnter.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.MemberEnter.Conversation.UnreadCount
+	case constant.UserInfoUpdatedNotification:
+		pushSwitch = config.Config.Notification.UserInfoUpdated.OfflinePush.PushSwitch
+		title = config.Config.Notification.UserInfoUpdated.OfflinePush.Title
+		desc = config.Config.Notification.UserInfoUpdated.OfflinePush.Desc
+		ex = config.Config.Notification.UserInfoUpdated.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.UserInfoUpdated.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.UserInfoUpdated.Conversation.UnreadCount
+	case constant.FriendApplicationNotification:
+		pushSwitch = config.Config.Notification.FriendApplication.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendApplication.OfflinePush.Title
+		desc = config.Config.Notification.FriendApplication.OfflinePush.Desc
+		ex = config.Config.Notification.FriendApplication.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendApplication.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendApplication.Conversation.UnreadCount
+	case constant.FriendApplicationApprovedNotification:
+		pushSwitch = config.Config.Notification.FriendApplicationApproved.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendApplicationApproved.OfflinePush.Title
+		desc = config.Config.Notification.FriendApplicationApproved.OfflinePush.Desc
+		ex = config.Config.Notification.FriendApplicationApproved.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendApplicationApproved.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendApplicationApproved.Conversation.UnreadCount
+	case constant.FriendApplicationRejectedNotification:
+		pushSwitch = config.Config.Notification.FriendApplicationRejected.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendApplicationRejected.OfflinePush.Title
+		desc = config.Config.Notification.FriendApplicationRejected.OfflinePush.Desc
+		ex = config.Config.Notification.FriendApplicationRejected.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendApplicationRejected.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendApplicationRejected.Conversation.UnreadCount
+	case constant.FriendAddedNotification:
+		pushSwitch = config.Config.Notification.FriendAdded.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendAdded.OfflinePush.Title
+		desc = config.Config.Notification.FriendAdded.OfflinePush.Desc
+		ex = config.Config.Notification.FriendAdded.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendAdded.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendAdded.Conversation.UnreadCount
+	case constant.FriendDeletedNotification:
+		pushSwitch = config.Config.Notification.FriendDeleted.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendDeleted.OfflinePush.Title
+		desc = config.Config.Notification.FriendDeleted.OfflinePush.Desc
+		ex = config.Config.Notification.FriendDeleted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendDeleted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendDeleted.Conversation.UnreadCount
+	case constant.FriendRemarkSetNotification:
+		pushSwitch = config.Config.Notification.FriendRemarkSet.OfflinePush.PushSwitch
+		title = config.Config.Notification.FriendRemarkSet.OfflinePush.Title
+		desc = config.Config.Notification.FriendRemarkSet.OfflinePush.Desc
+		ex = config.Config.Notification.FriendRemarkSet.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.FriendRemarkSet.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.FriendRemarkSet.Conversation.UnreadCount
+	case constant.BlackAddedNotification:
+		pushSwitch = config.Config.Notification.BlackAdded.OfflinePush.PushSwitch
+		title = config.Config.Notification.BlackAdded.OfflinePush.Title
+		desc = config.Config.Notification.BlackAdded.OfflinePush.Desc
+		ex = config.Config.Notification.BlackAdded.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.BlackAdded.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.BlackAdded.Conversation.UnreadCount
+	case constant.BlackDeletedNotification:
+		pushSwitch = config.Config.Notification.BlackDeleted.OfflinePush.PushSwitch
+		title = config.Config.Notification.BlackDeleted.OfflinePush.Title
+		desc = config.Config.Notification.BlackDeleted.OfflinePush.Desc
+		ex = config.Config.Notification.BlackDeleted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.BlackDeleted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.BlackDeleted.Conversation.UnreadCount
+	case constant.ConversationOptChangeNotification:
+		pushSwitch = config.Config.Notification.ConversationOptUpdate.OfflinePush.PushSwitch
+		title = config.Config.Notification.ConversationOptUpdate.OfflinePush.Title
+		desc = config.Config.Notification.ConversationOptUpdate.OfflinePush.Desc
+		ex = config.Config.Notification.ConversationOptUpdate.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.ConversationOptUpdate.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.ConversationOptUpdate.Conversation.UnreadCount
+
+	case constant.GroupDismissedNotification:
+		pushSwitch = config.Config.Notification.GroupDismissed.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupDismissed.OfflinePush.Title
+		desc = config.Config.Notification.GroupDismissed.OfflinePush.Desc
+		ex = config.Config.Notification.GroupDismissed.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupDismissed.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupDismissed.Conversation.UnreadCount
+
+	case constant.GroupMutedNotification:
+		pushSwitch = config.Config.Notification.GroupMuted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupMuted.OfflinePush.Title
+		desc = config.Config.Notification.GroupMuted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupMuted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupMuted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupMuted.Conversation.UnreadCount
+
+	case constant.GroupCancelMutedNotification:
+		pushSwitch = config.Config.Notification.GroupCancelMuted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupCancelMuted.OfflinePush.Title
+		desc = config.Config.Notification.GroupCancelMuted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupCancelMuted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupCancelMuted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupCancelMuted.Conversation.UnreadCount
+
+	case constant.GroupMemberMutedNotification:
+		pushSwitch = config.Config.Notification.GroupMemberMuted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupMemberMuted.OfflinePush.Title
+		desc = config.Config.Notification.GroupMemberMuted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupMemberMuted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupMemberMuted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupMemberMuted.Conversation.UnreadCount
+
+	case constant.GroupMemberCancelMutedNotification:
+		pushSwitch = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Title
+		desc = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Desc
+		ex = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupMemberCancelMuted.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupMemberCancelMuted.Conversation.UnreadCount
+	}
+	switch reliabilityLevel {
+	case constant.UnreliableNotification:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsHistory, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsPersistent, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
+	case constant.ReliableNotificationNoMsg:
+		utils.SetSwitchFromOptions(msg.Options, constant.IsConversationUpdate, false)
+		utils.SetSwitchFromOptions(msg.Options, constant.IsSenderConversationUpdate, false)
+	case constant.ReliableNotificationMsg:
+
+	}
+	utils.SetSwitchFromOptions(msg.Options, constant.IsUnreadCount, unReadCount)
+	utils.SetSwitchFromOptions(msg.Options, constant.IsOfflinePush, pushSwitch)
+	offlineInfo.Title = title
+	offlineInfo.Desc = desc
+	offlineInfo.Ex = ex
+	msg.OfflinePushInfo = &offlineInfo
+	req.MsgData = &msg
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	client := pbChat.NewChatClient(etcdConn)
+	reply, err := client.SendMsg(context.Background(), &req)
+	if err != nil {
+		log.NewError(req.OperationID, "SendMsg rpc failed, ", req.String(), err.Error())
+	} else if reply.ErrCode != 0 {
+		log.NewError(req.OperationID, "SendMsg rpc failed, ", req.String(), reply.ErrCode, reply.ErrMsg)
+	}
+}

internal/rpc/msg/tag_send_msg.go

@@ -0,0 +1,45 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/pkg/proto/chat"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+)
+
+func TagSendMessage(operationID string, user *db.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.CreateTime = utils.GetCurrentTimestampByMill()
+	msgData.ClientMsgID = utils.GetMsgID(user.UserID)
+	msgData.SenderPlatformID = senderPlatformID
+	req.MsgData = &msgData
+	req.OperationID = operationID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	client := pbChat.NewChatClient(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/office/office.go

@@ -0,0 +1,445 @@
+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/mysql_model/im_mysql_model"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbOffice "Open_IM/pkg/proto/office"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"google.golang.org/grpc"
+	"net"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type officeServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewOfficeServer(port int) *officeServer {
+	log.NewPrivateLog(constant.LogFileName)
+	return &officeServer{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImOfficeName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (s *officeServer) Run() {
+	log.NewInfo("0", "officeServer rpc start ")
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
+	//listener network
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.NewError("0", "Listen failed ", err.Error(), registerAddress)
+		return
+	}
+	log.NewInfo("0", "listen network success, ", registerAddress, listener)
+	defer listener.Close()
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	//Service registers with etcd
+	pbOffice.RegisterOfficeServiceServer(srv, s)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("0", "RegisterEtcd failed ", err.Error())
+		return
+	}
+	err = srv.Serve(listener)
+	if err != nil {
+		log.NewError("0", "Serve failed ", err.Error())
+		return
+	}
+	log.NewInfo("0", "message cms rpc success")
+}
+
+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", 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 {
+		userIDList, err := im_mysql_model.GetGroupMemberIDListByGroupID(groupID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMemberIDListByGroupID failed", err.Error())
+			continue
+		}
+		log.NewInfo(req.OperationID, utils.GetSelfFuncName(), userIDList)
+		groupUserIDList = append(groupUserIDList, userIDList...)
+	}
+	log.NewInfo(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:]...)
+		}
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "total userIDList result: ", userIDList)
+	us, err := imdb.GetUserByUserID(req.SendID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.SendID)
+	}
+	for _, userID := range userIDList {
+		msg.TagSendMessage(req.OperationID, us, userID, req.Content, req.SenderPlatformID)
+	}
+	var tagSendLogs db.TagSendLog
+	for _, userID := range userIDList {
+		userName, err := im_mysql_model.GetUserNameByUserID(userID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID failed", err.Error())
+			continue
+		}
+		tagSendLogs.UserList = append(tagSendLogs.UserList, db.TagUser{
+			UserID:   userID,
+			UserName: userName,
+		})
+	}
+	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", 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{}
+	workMoment := db.WorkMoment{}
+	if err := utils.CopyStructFields(&workMoment, req.WorkMoment); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+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{}
+	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 (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{}
+	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
+	}
+	if workMoment.UserID != req.WorkMomentID {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "workMoment.UserID != req.WorkMomentID ", workMoment, req.WorkMomentID)
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}
+		return resp, nil
+	}
+	if err = db.DB.LikeOneWorkMoment(req.UserID, req.WorkMomentID); 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
+	}
+	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{}
+	commentUserName, err := imdb.GetUserNameByUserID(req.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID commentUserName failed", req.UserID, err.Error())
+	}
+	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 := db.Comment{
+		UserID:        req.UserID,
+		UserName:      commentUserName,
+		ReplyUserID:   req.ReplyUserID,
+		ReplyUserName: replyUserName,
+		ContentID:     "",
+		Content:       req.Content,
+		CreateTime:    int32(time.Now().Unix()),
+	}
+	if err = db.DB.CommentOneWorkMoment(comment, req.WorkMomentID); 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
+	}
+	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{}
+	workMoments, err := db.DB.GetUserWorkMoments(req.UserID, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err)
+		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())
+	}
+	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
+	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{}
+	friendIDList, err := imdb.GetFriendIDListByUserID(req.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListByUserID", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "friendIDList: ", friendIDList)
+	workMoments, err := db.DB.GetUserFriendWorkMoments(friendIDList, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	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())
+	}
+	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *officeServer) GetUserWorkMomentsCommentsMsg(_ context.Context, req *pbOffice.GetUserWorkMomentsCommentsMsgReq) (resp *pbOffice.GetUserWorkMomentsCommentsMsgResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.GetUserWorkMomentsCommentsMsgResp{CommentsMsgs: []*pbOffice.CommentsMsg{}}
+	workMomentsCommentMsgs, err := db.DB.GetUserWorkMomentsCommentsMsg(req.UserID, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserWorkMomentsCommentsMsg", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	for _, commentMsg := range workMomentsCommentMsgs {
+		comment := pbOffice.Comment{}
+		if err := utils.CopyStructFields(&comment, commentMsg); err != nil {
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), err.Error())
+		}
+		resp.CommentsMsgs = append(resp.CommentsMsgs, &pbOffice.CommentsMsg{
+			Comment:      &comment,
+			WorkMomentID: commentMsg.WorkMomentID,
+			Content:      commentMsg.Content,
+		})
+	}
+	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
+	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{}
+	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) ClearUserWorkMomentsCommentsMsg(_ context.Context, req *pbOffice.ClearUserWorkMomentsCommentsMsgReq) (resp *pbOffice.ClearUserWorkMomentsCommentsMsgResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.ClearUserWorkMomentsCommentsMsgResp{}
+	if err := db.DB.ClearUserWorkMomentsCommentsMsg(req.UserID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "ClearUserWorkMomentsCommentsMsg", 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
+}

internal/rpc/organization/organization.go

@@ -0,0 +1,349 @@
+package organization
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	rpc "Open_IM/pkg/proto/organization"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"time"
+
+	"context"
+	"google.golang.org/grpc"
+	"net"
+	"strconv"
+	"strings"
+)
+
+type organizationServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewServer(port int) *organizationServer {
+	log.NewPrivateLog(constant.LogFileName)
+	return &organizationServer{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImOrganizationName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (s *organizationServer) Run() {
+	log.NewInfo("", "organization rpc start ")
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
+	//listener network
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.NewError("", "Listen failed ", err.Error(), registerAddress)
+		return
+	}
+	log.NewInfo("", "listen network success, ", registerAddress, listener)
+	defer listener.Close()
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	//Service registers with etcd
+	rpc.RegisterOrganizationServer(srv, s)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("", "RegisterEtcd failed ", err.Error())
+		return
+	}
+	log.NewInfo("", "organization rpc RegisterEtcd success", ip, s.rpcPort, s.rpcRegisterName, 10)
+	err = srv.Serve(listener)
+	if err != nil {
+		log.NewError("", "Serve failed ", err.Error())
+		return
+	}
+	log.NewInfo("", "organization rpc success")
+}
+
+func (s *organizationServer) CreateDepartment(ctx context.Context, req *rpc.CreateDepartmentReq) (*rpc.CreateDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+
+	department := db.Department{}
+	utils.CopyStructFields(&department, req.DepartmentInfo)
+	if department.DepartmentID == "" {
+		department.DepartmentID = utils.Md5(strconv.FormatInt(time.Now().UnixNano(), 10))
+	}
+	log.Debug(req.OperationID, "dst ", department, "src ", req.DepartmentInfo)
+	if err := imdb.CreateDepartment(&department); err != nil {
+		errMsg := req.OperationID + " " + "CreateDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	err, createdDepartment := imdb.GetDepartment(department.DepartmentID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "GetDepartment failed " + err.Error() + department.DepartmentID
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "GetDepartment ", department.DepartmentID, *createdDepartment)
+	resp := &rpc.CreateDepartmentResp{DepartmentInfo: &open_im_sdk.Department{}}
+	utils.CopyStructFields(resp.DepartmentInfo, createdDepartment)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) UpdateDepartment(ctx context.Context, req *rpc.UpdateDepartmentReq) (*rpc.UpdateDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.UpdateDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+
+	department := db.Department{}
+	utils.CopyStructFields(&department, req.DepartmentInfo)
+
+	log.Debug(req.OperationID, "dst ", department, "src ", req.DepartmentInfo)
+	if err := imdb.UpdateDepartment(&department, nil); err != nil {
+		errMsg := req.OperationID + " " + "UpdateDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg)
+		return &rpc.UpdateDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	resp := &rpc.UpdateDepartmentResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) GetSubDepartment(ctx context.Context, req *rpc.GetSubDepartmentReq) (*rpc.GetSubDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	err, departmentList := imdb.GetSubDepartmentList(req.DepartmentID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "GetDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg)
+		return &rpc.GetSubDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "GetSubDepartmentList ", req.DepartmentID, departmentList)
+	resp := &rpc.GetSubDepartmentResp{}
+	for _, v := range departmentList {
+		v1 := open_im_sdk.Department{}
+		utils.CopyStructFields(&v1, v)
+		log.Debug(req.OperationID, "src ", v, "dst ", v1)
+		resp.DepartmentList = append(resp.DepartmentList, &v1)
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) DeleteDepartment(ctx context.Context, req *rpc.DeleteDepartmentReq) (*rpc.DeleteDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.DeleteDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	err := imdb.DeleteDepartment(req.DepartmentID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "DeleteDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.DepartmentID)
+		return &rpc.DeleteDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "DeleteDepartment ", req.DepartmentID)
+	resp := &rpc.DeleteDepartmentResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", resp)
+	return resp, nil
+}
+
+func (s *organizationServer) CreateOrganizationUser(ctx context.Context, req *rpc.CreateOrganizationUserReq) (*rpc.CreateOrganizationUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	organizationUser := db.OrganizationUser{}
+	utils.CopyStructFields(&organizationUser, req.OrganizationUser)
+	organizationUser.Birth = utils.UnixSecondToTime(int64(req.OrganizationUser.Birth))
+	log.Debug(req.OperationID, "src ", *req.OrganizationUser, "dst ", organizationUser)
+	err := imdb.CreateOrganizationUser(&organizationUser)
+	if err != nil {
+		errMsg := req.OperationID + " " + "CreateOrganizationUser failed " + err.Error()
+		log.Error(req.OperationID, errMsg, organizationUser)
+		return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "CreateOrganizationUser ", organizationUser)
+	resp := &rpc.CreateOrganizationUserResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) UpdateOrganizationUser(ctx context.Context, req *rpc.UpdateOrganizationUserReq) (*rpc.UpdateOrganizationUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	organizationUser := db.OrganizationUser{}
+	utils.CopyStructFields(&organizationUser, req.OrganizationUser)
+	log.Debug(req.OperationID, "src ", *req.OrganizationUser, "dst ", organizationUser)
+	err := imdb.UpdateOrganizationUser(&organizationUser, nil)
+	if err != nil {
+		errMsg := req.OperationID + " " + "CreateOrganizationUser failed " + err.Error()
+		log.Error(req.OperationID, errMsg, organizationUser)
+		return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "UpdateOrganizationUser ", organizationUser)
+	resp := &rpc.UpdateOrganizationUserResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", resp)
+	return resp, nil
+}
+
+func (s *organizationServer) CreateDepartmentMember(ctx context.Context, req *rpc.CreateDepartmentMemberReq) (*rpc.CreateDepartmentMemberResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentMemberResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	departmentMember := db.DepartmentMember{}
+	utils.CopyStructFields(&departmentMember, req.UserInDepartment)
+	log.Debug(req.OperationID, "src ", *req.UserInDepartment, "dst ", departmentMember)
+	err := imdb.CreateDepartmentMember(&departmentMember)
+	if err != nil {
+		errMsg := req.OperationID + " " + "CreateDepartmentMember failed " + err.Error()
+		log.Error(req.OperationID, errMsg, departmentMember)
+		return &rpc.CreateDepartmentMemberResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "UpdateOrganizationUser ", departmentMember)
+	resp := &rpc.CreateDepartmentMemberResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) GetUserInDepartmentByUserID(userID string) (*open_im_sdk.UserInDepartment, error) {
+	err, organizationUser := imdb.GetOrganizationUser(userID)
+	if err != nil {
+		return nil, utils.Wrap(err, "GetOrganizationUser failed")
+	}
+	err, departmentMemberList := imdb.GetUserInDepartment(userID)
+	if err != nil {
+		return nil, utils.Wrap(err, "GetUserInDepartment failed")
+	}
+	resp := &open_im_sdk.UserInDepartment{OrganizationUser: &open_im_sdk.OrganizationUser{}}
+	utils.CopyStructFields(resp.OrganizationUser, organizationUser)
+	for _, v := range departmentMemberList {
+		v1 := open_im_sdk.DepartmentMember{}
+		utils.CopyStructFields(&v1, v)
+		resp.DepartmentMemberList = append(resp.DepartmentMemberList, &v1)
+	}
+	return resp, nil
+}
+
+func (s *organizationServer) GetUserInDepartment(ctx context.Context, req *rpc.GetUserInDepartmentReq) (*rpc.GetUserInDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	r, err := s.GetUserInDepartmentByUserID(req.UserID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "GetUserInDepartmentByUserID failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.UserID)
+		return &rpc.GetUserInDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "GetUserInDepartmentByUserID success ", req.UserID, r)
+	resp := rpc.GetUserInDepartmentResp{UserInDepartment: &open_im_sdk.UserInDepartment{OrganizationUser: &open_im_sdk.OrganizationUser{}}}
+	resp.UserInDepartment.DepartmentMemberList = r.DepartmentMemberList
+	resp.UserInDepartment.OrganizationUser = r.OrganizationUser
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", resp)
+	return &resp, nil
+}
+
+func (s *organizationServer) UpdateUserInDepartment(ctx context.Context, req *rpc.UpdateUserInDepartmentReq) (*rpc.UpdateUserInDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.UpdateUserInDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	departmentMember := &db.DepartmentMember{}
+	utils.CopyStructFields(departmentMember, req.DepartmentMember)
+	log.Debug(req.OperationID, "dst ", departmentMember, "src ", req.DepartmentMember)
+	err := imdb.UpdateUserInDepartment(departmentMember, nil)
+	if err != nil {
+		errMsg := req.OperationID + " " + "UpdateUserInDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg, *departmentMember)
+		return &rpc.UpdateUserInDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	resp := &rpc.UpdateUserInDepartmentResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) DeleteUserInDepartment(ctx context.Context, req *rpc.DeleteUserInDepartmentReq) (*rpc.DeleteUserInDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.DeleteUserInDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+
+	err := imdb.DeleteUserInDepartment(req.DepartmentID, req.UserID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "DeleteUserInDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.DepartmentID, req.UserID)
+		return &rpc.DeleteUserInDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "DeleteUserInDepartment success ", req.DepartmentID, req.UserID)
+	resp := &rpc.DeleteUserInDepartmentResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) DeleteOrganizationUser(ctx context.Context, req *rpc.DeleteOrganizationUserReq) (*rpc.DeleteOrganizationUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + "" + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.DeleteOrganizationUserResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+	}
+	err := imdb.DeleteOrganizationUser(req.UserID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "DeleteOrganizationUser failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.UserID)
+		return &rpc.DeleteOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "DeleteOrganizationUser success ", req.UserID)
+	resp := &rpc.DeleteOrganizationUserResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) GetDepartmentMember(ctx context.Context, req *rpc.GetDepartmentMemberReq) (*rpc.GetDepartmentMemberResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	err, departmentMemberUserIDList := imdb.GetDepartmentMemberUserIDList(req.DepartmentID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "GetDepartmentMemberUserIDList failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.DepartmentID)
+		return &rpc.GetDepartmentMemberResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	resp := rpc.GetDepartmentMemberResp{}
+	for _, v := range departmentMemberUserIDList {
+		r, err := s.GetUserInDepartmentByUserID(v)
+		if err != nil {
+			log.Error(req.OperationID, "GetUserInDepartmentByUserID failed ", err.Error())
+			continue
+		}
+		log.Debug(req.OperationID, "GetUserInDepartmentByUserID success ", *r)
+		resp.UserInDepartmentList = append(resp.UserInDepartmentList, r)
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", resp)
+	return &resp, nil
+}

internal/rpc/statistics/statistics.go

@@ -0,0 +1,378 @@
+package statistics
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"context"
+	"sync"
+	"time"
+
+	//"Open_IM/pkg/common/constant"
+	//"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+
+	//cp "Open_IM/pkg/common/utils"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbStatistics "Open_IM/pkg/proto/statistics"
+
+	//open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	//"context"
+	errors "Open_IM/pkg/common/http"
+	"net"
+	"strconv"
+	"strings"
+
+	"google.golang.org/grpc"
+)
+
+type statisticsServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewStatisticsServer(port int) *statisticsServer {
+	log.NewPrivateLog(constant.LogFileName)
+	return &statisticsServer{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImStatisticsName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (s *statisticsServer) Run() {
+	log.NewInfo("0", "Statistics rpc start ")
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
+	//listener network
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.NewError("0", "Listen failed ", err.Error(), registerAddress)
+		return
+	}
+	log.NewInfo("0", "listen network success, ", registerAddress, listener)
+	defer listener.Close()
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	//Service registers with etcd
+	pbStatistics.RegisterUserServer(srv, s)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("0", "RegisterEtcd failed ", err.Error())
+		return
+	}
+	err = srv.Serve(listener)
+	if err != nil {
+		log.NewError("0", "Serve failed ", err.Error())
+		return
+	}
+	log.NewInfo("0", "statistics rpc success")
+}
+
+func (s *statisticsServer) GetActiveGroup(_ context.Context, req *pbStatistics.GetActiveGroupReq) (*pbStatistics.GetActiveGroupResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetActiveGroupResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
+		return resp, errors.WrapError(constant.ErrArgs)
+	}
+	activeGroups, err := imdb.GetActiveGroups(fromTime, toTime, 12)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetActiveGroups failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	for _, activeGroup := range activeGroups {
+		resp.Groups = append(resp.Groups,
+			&pbStatistics.GroupResp{
+				GroupName:  activeGroup.Name,
+				GroupId:    activeGroup.Id,
+				MessageNum: int32(activeGroup.MessageNum),
+			})
+	}
+	return resp, nil
+}
+
+func (s *statisticsServer) GetActiveUser(_ context.Context, req *pbStatistics.GetActiveUserReq) (*pbStatistics.GetActiveUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetActiveUserResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	activeUsers, err := imdb.GetActiveUsers(fromTime, toTime, 12)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetActiveUsers failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	for _, activeUser := range activeUsers {
+		resp.Users = append(resp.Users,
+			&pbStatistics.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 *statisticsServer) GetGroupStatistics(_ context.Context, req *pbStatistics.GetGroupStatisticsReq) (*pbStatistics.GetGroupStatisticsResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetGroupStatisticsResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupStatistics failed", err.Error())
+		return resp, errors.WrapError(constant.ErrArgs)
+	}
+	increaseGroupNum, err := imdb.GetIncreaseGroupNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	totalGroupNum, err := imdb.GetTotalGroupNum()
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	resp.IncreaseGroupNum = increaseGroupNum
+	resp.TotalGroupNum = totalGroupNum
+	times := GetRangeDate(fromTime, toTime)
+	log.NewInfo(req.OperationID, "times:", times)
+	wg := &sync.WaitGroup{}
+	resp.IncreaseGroupNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
+	resp.TotalGroupNumList = make([]*pbStatistics.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 := imdb.GetIncreaseGroupNum(v[0], v[1])
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+			}
+			resp.IncreaseGroupNumList[index] = &pbStatistics.DateNumList{
+				Date: v[0].String(),
+				Num:  num,
+			}
+			num, err = imdb.GetGroupNum(v[1])
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+			}
+			resp.TotalGroupNumList[index] = &pbStatistics.DateNumList{
+				Date: v[0].String(),
+				Num:  num,
+			}
+		}(wg, i, v)
+	}
+	wg.Wait()
+	return resp, nil
+}
+
+func (s *statisticsServer) GetMessageStatistics(_ context.Context, req *pbStatistics.GetMessageStatisticsReq) (*pbStatistics.GetMessageStatisticsResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetMessageStatisticsResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
+		return resp, errors.WrapError(constant.ErrArgs)
+	}
+	privateMessageNum, err := imdb.GetPrivateMessageNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetPrivateMessageNum failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	groupMessageNum, err := imdb.GetGroupMessageNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMessageNum failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	resp.PrivateMessageNum = privateMessageNum
+	resp.GroupMessageNum = groupMessageNum
+	times := GetRangeDate(fromTime, toTime)
+	resp.GroupMessageNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
+	resp.PrivateMessageNumList = make([]*pbStatistics.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 := imdb.GetPrivateMessageNum(v[0], v[1])
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+			}
+			resp.PrivateMessageNumList[index] = &pbStatistics.DateNumList{
+				Date: v[0].String(),
+				Num:  num,
+			}
+			num, err = imdb.GetGroupMessageNum(v[0], v[1])
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+			}
+			resp.GroupMessageNumList[index] = &pbStatistics.DateNumList{
+				Date: v[0].String(),
+				Num:  num,
+			}
+		}(wg, i, v)
+	}
+	wg.Wait()
+	return resp, nil
+}
+
+func (s *statisticsServer) GetUserStatistics(_ context.Context, req *pbStatistics.GetUserStatisticsReq) (*pbStatistics.GetUserStatisticsResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.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 resp, errors.WrapError(constant.ErrArgs)
+	}
+	activeUserNum, err := imdb.GetActiveUserNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetActiveUserNum failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	increaseUserNum, err := imdb.GetIncreaseUserNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseUserNum failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	totalUserNum, err := imdb.GetTotalUserNum()
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTotalUserNum failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	resp.ActiveUserNum = activeUserNum
+	resp.TotalUserNum = totalUserNum
+	resp.IncreaseUserNum = increaseUserNum
+	times := GetRangeDate(fromTime, toTime)
+	resp.TotalUserNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
+	resp.ActiveUserNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
+	resp.IncreaseUserNumList = make([]*pbStatistics.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 := imdb.GetActiveUserNum(v[0], v[1])
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+			}
+			resp.ActiveUserNumList[index] = &pbStatistics.DateNumList{
+				Date: v[0].String(),
+				Num:  num,
+			}
+
+			num, err = imdb.GetTotalUserNumByDate(v[1])
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTotalUserNumByDate", v, err.Error())
+			}
+			resp.TotalUserNumList[index] = &pbStatistics.DateNumList{
+				Date: v[0].String(),
+				Num:  num,
+			}
+			num, err = imdb.GetIncreaseUserNum(v[0], v[1])
+			if err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseUserNum", v, err.Error())
+			}
+			resp.IncreaseUserNumList[index] = &pbStatistics.DateNumList{
+				Date: v[0].String(),
+				Num:  num,
+			}
+		}(wg, i, v)
+	}
+	wg.Wait()
+	return resp, nil
+}

internal/rpc/user/callback.go

@@ -0,0 +1 @@
+package user

internal/rpc/user/user.go

@@ -0,0 +1,590 @@
+package user
+
+import (
+	chat "Open_IM/internal/rpc/msg"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	errors "Open_IM/pkg/common/http"
+
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/pkg/proto/friend"
+	sdkws "Open_IM/pkg/proto/sdk_ws"
+	pbUser "Open_IM/pkg/proto/user"
+	"Open_IM/pkg/utils"
+	"context"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+
+	"google.golang.org/grpc"
+)
+
+type userServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewUserServer(port int) *userServer {
+	log.NewPrivateLog(constant.LogFileName)
+	return &userServer{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImUserName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (s *userServer) Run() {
+	log.NewInfo("0", "", "rpc user start...")
+
+	ip := utils.ServerIP
+	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
+	//listener network
+	listener, err := net.Listen("tcp", registerAddress)
+	if err != nil {
+		log.NewError("0", "listen network failed ", err.Error(), registerAddress)
+		return
+	}
+	log.NewInfo("0", "listen network success, address ", registerAddress, listener)
+	defer listener.Close()
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+	//Service registers with etcd
+	pbUser.RegisterUserServer(srv, s)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("0", "RegisterEtcd failed ", err.Error(), s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName)
+		return
+	}
+	err = srv.Serve(listener)
+	if err != nil {
+		log.NewError("0", "Serve failed ", err.Error())
+		return
+	}
+	log.NewInfo("0", "rpc  user success")
+}
+
+func syncPeerUserConversation(conversation *pbUser.Conversation, operationID string) error {
+	peerUserConversation := db.Conversation{
+		OwnerUserID:      conversation.UserID,
+		ConversationID:   "single_" + conversation.OwnerUserID,
+		ConversationType: constant.SingleChatType,
+		UserID:           conversation.OwnerUserID,
+		GroupID:          "",
+		RecvMsgOpt:       0,
+		UnreadCount:      0,
+		DraftTextTime:    0,
+		IsPinned:         false,
+		IsPrivateChat:    conversation.IsPrivateChat,
+		AttachedInfo:     "",
+		Ex:               "",
+	}
+	err := imdb.PeerUserSetConversation(peerUserConversation)
+	if err != nil {
+		log.NewError(operationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
+		return err
+	}
+	chat.ConversationSetPrivateNotification(operationID, conversation.OwnerUserID, conversation.UserID, conversation.IsPrivateChat)
+	return nil
+}
+
+func (s *userServer) GetUserInfo(ctx context.Context, req *pbUser.GetUserInfoReq) (*pbUser.GetUserInfoResp, error) {
+	log.NewInfo(req.OperationID, "GetUserInfo args ", req.String())
+	var userInfoList []*sdkws.UserInfo
+	if len(req.UserIDList) > 0 {
+		for _, userID := range req.UserIDList {
+			var userInfo sdkws.UserInfo
+			user, err := imdb.GetUserByUserID(userID)
+			if err != nil {
+				log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), userID)
+				continue
+			}
+			utils.CopyStructFields(&userInfo, user)
+			userInfo.Birth = uint32(user.Birth.Unix())
+			userInfoList = append(userInfoList, &userInfo)
+		}
+	} else {
+		return &pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
+	}
+	log.NewInfo(req.OperationID, "GetUserInfo rpc return ", pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{}, UserInfoList: userInfoList})
+	return &pbUser.GetUserInfoResp{CommonResp: &pbUser.CommonResp{}, UserInfoList: userInfoList}, nil
+}
+
+func (s *userServer) BatchSetConversations(ctx context.Context, req *pbUser.BatchSetConversationsReq) (*pbUser.BatchSetConversationsResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	if req.NotificationType == 0 {
+		req.NotificationType = constant.ConversationOptChangeNotification
+	}
+	resp := &pbUser.BatchSetConversationsResp{}
+	for _, v := range req.Conversations {
+		conversation := db.Conversation{}
+		if err := utils.CopyStructFields(&conversation, v); err != nil {
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), v.String(), "CopyStructFields failed", err.Error())
+		}
+		if err := db.DB.SetSingleConversationRecvMsgOpt(req.OwnerUserID, v.ConversationID, v.RecvMsgOpt); err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "cache failed, rpc return", err.Error())
+			resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+			return resp, nil
+		}
+		if err := imdb.SetConversation(conversation); err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
+			resp.Failed = append(resp.Failed, v.ConversationID)
+			continue
+		}
+		resp.Success = append(resp.Success, v.ConversationID)
+		// if is set private chat operation，then peer user need to sync and set tips\
+		if v.ConversationType == constant.SingleChatType && req.NotificationType == constant.ConversationPrivateChatNotification {
+			if err := syncPeerUserConversation(v, req.OperationID); err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "syncPeerUserConversation", err.Error())
+			}
+		}
+	}
+	chat.ConversationChangeNotification(req.OperationID, req.OwnerUserID)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
+	resp.CommonResp = &pbUser.CommonResp{}
+	return resp, nil
+}
+
+func (s *userServer) GetAllConversations(ctx context.Context, req *pbUser.GetAllConversationsReq) (*pbUser.GetAllConversationsResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbUser.GetAllConversationsResp{Conversations: []*pbUser.Conversation{}}
+	conversations, err := imdb.GetUserAllConversations(req.OwnerUserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetConversations error", err.Error())
+		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	if err = utils.CopyStructFields(&resp.Conversations, conversations); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields error", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
+	resp.CommonResp = &pbUser.CommonResp{}
+	return resp, nil
+}
+
+func (s *userServer) GetConversation(ctx context.Context, req *pbUser.GetConversationReq) (*pbUser.GetConversationResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbUser.GetConversationResp{Conversation: &pbUser.Conversation{}}
+	conversation, err := imdb.GetConversation(req.OwnerUserID, req.ConversationID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetConversation error", err.Error())
+		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	if err := utils.CopyStructFields(resp.Conversation, &conversation); err != nil {
+		log.Debug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields error", conversation, err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	resp.CommonResp = &pbUser.CommonResp{}
+	return resp, nil
+}
+
+func (s *userServer) GetConversations(ctx context.Context, req *pbUser.GetConversationsReq) (*pbUser.GetConversationsResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbUser.GetConversationsResp{Conversations: []*pbUser.Conversation{}}
+	conversations, err := imdb.GetConversations(req.OwnerUserID, req.ConversationIDs)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetConversations error", err.Error())
+		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	if err := utils.CopyStructFields(&resp.Conversations, conversations); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", conversations, err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	resp.CommonResp = &pbUser.CommonResp{}
+	return resp, nil
+}
+
+func (s *userServer) SetConversation(ctx context.Context, req *pbUser.SetConversationReq) (*pbUser.SetConversationResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	if req.NotificationType == 0 {
+		req.NotificationType = constant.ConversationOptChangeNotification
+	}
+	resp := &pbUser.SetConversationResp{}
+	var conversation db.Conversation
+	if err := utils.CopyStructFields(&conversation, req.Conversation); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", *req.Conversation, err.Error())
+	}
+	if err := db.DB.SetSingleConversationRecvMsgOpt(req.Conversation.OwnerUserID, req.Conversation.ConversationID, req.Conversation.RecvMsgOpt); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "cache failed, rpc return", err.Error())
+		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	err := imdb.SetConversation(conversation)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
+		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	// notification
+	if req.Conversation.ConversationType == constant.SingleChatType && req.NotificationType == constant.ConversationPrivateChatNotification {
+		//sync peer user conversation if conversation is singleChatType
+		if err := syncPeerUserConversation(req.Conversation, req.OperationID); err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "syncPeerUserConversation", err.Error())
+			resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+			return resp, nil
+		}
+	} else {
+		chat.ConversationChangeNotification(req.OperationID, req.Conversation.OwnerUserID)
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
+	resp.CommonResp = &pbUser.CommonResp{}
+	return resp, nil
+}
+
+func (s *userServer) SetRecvMsgOpt(ctx context.Context, req *pbUser.SetRecvMsgOptReq) (*pbUser.SetRecvMsgOptResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbUser.SetRecvMsgOptResp{}
+	var conversation db.Conversation
+	if err := utils.CopyStructFields(&conversation, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", *req, err.Error())
+	}
+	if err := db.DB.SetSingleConversationRecvMsgOpt(req.OwnerUserID, req.ConversationID, req.RecvMsgOpt); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "cache failed, rpc return", err.Error())
+		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	stringList := strings.Split(req.ConversationID, "_")
+	if len(stringList) > 1 {
+		switch stringList[0] {
+		case "single_":
+			conversation.UserID = stringList[1]
+			conversation.ConversationType = constant.SingleChatType
+		case "group":
+			conversation.GroupID = stringList[1]
+			conversation.ConversationType = constant.GroupChatType
+		}
+	}
+	err := imdb.SetRecvMsgOpt(conversation)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
+		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	chat.ConversationChangeNotification(req.OperationID, req.OwnerUserID)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	resp.CommonResp = &pbUser.CommonResp{}
+	return resp, nil
+}
+
+func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) (*pbUser.DeleteUsersResp, error) {
+	log.NewInfo(req.OperationID, "DeleteUsers args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
+		return &pbUser.DeleteUsersResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, FailedUserIDList: req.DeleteUserIDList}, nil
+	}
+	var common pbUser.CommonResp
+	resp := pbUser.DeleteUsersResp{CommonResp: &common}
+	for _, userID := range req.DeleteUserIDList {
+		i := imdb.DeleteUser(userID)
+		if i == 0 {
+			log.NewError(req.OperationID, "delete user error", userID)
+			common.ErrCode = 201
+			common.ErrMsg = "some uid deleted failed"
+			resp.FailedUserIDList = append(resp.FailedUserIDList, userID)
+		}
+	}
+	log.NewInfo(req.OperationID, "DeleteUsers rpc return ", resp.String())
+	return &resp, nil
+}
+
+func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq) (*pbUser.GetAllUserIDResp, error) {
+	log.NewInfo(req.OperationID, "GetAllUserID args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
+		return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	uidList, err := imdb.SelectAllUserID()
+	if err != nil {
+		log.NewError(req.OperationID, "SelectAllUserID false ", err.Error())
+		return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	} else {
+		log.NewInfo(req.OperationID, "GetAllUserID rpc return ", pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{}, UserIDList: uidList})
+		return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{}, UserIDList: uidList}, nil
+	}
+}
+
+func (s *userServer) AccountCheck(_ context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
+	log.NewInfo(req.OperationID, "AccountCheck args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
+		return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	uidList, err := imdb.SelectSomeUserID(req.CheckUserIDList)
+	log.NewDebug(req.OperationID, "from db uid list is:", uidList)
+	if err != nil {
+		log.NewError(req.OperationID, "SelectSomeUserID failed ", err.Error(), req.CheckUserIDList)
+		return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	} else {
+		var r []*pbUser.AccountCheckResp_SingleUserStatus
+		for _, v := range req.CheckUserIDList {
+			temp := new(pbUser.AccountCheckResp_SingleUserStatus)
+			temp.UserID = v
+			if utils.IsContain(v, uidList) {
+				temp.AccountStatus = constant.Registered
+			} else {
+				temp.AccountStatus = constant.UnRegistered
+			}
+			r = append(r, temp)
+		}
+		resp := pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: 0, ErrMsg: ""}, ResultList: r}
+		log.NewInfo(req.OperationID, "AccountCheck rpc return ", resp.String())
+		return &resp, nil
+	}
+
+}
+
+func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserInfoReq) (*pbUser.UpdateUserInfoResp, error) {
+	log.NewInfo(req.OperationID, "UpdateUserInfo args ", req.String())
+	if !token_verify.CheckAccess(req.OpUserID, req.UserInfo.UserID) {
+		log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.UserInfo.UserID)
+		return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+
+	var user db.User
+	utils.CopyStructFields(&user, req.UserInfo)
+	if req.UserInfo.Birth != 0 {
+		user.Birth = utils.UnixSecondToTime(int64(req.UserInfo.Birth))
+	}
+	err := imdb.UpdateUserInfo(user)
+	if err != nil {
+		log.NewError(req.OperationID, "UpdateUserInfo failed ", err.Error(), user)
+		return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	client := pbFriend.NewFriendClient(etcdConn)
+	newReq := &pbFriend.GetFriendListReq{
+		CommID: &pbFriend.CommID{OperationID: req.OperationID, FromUserID: req.UserInfo.UserID, OpUserID: req.OpUserID},
+	}
+
+	RpcResp, err := client.GetFriendList(context.Background(), newReq)
+	if err != nil {
+		log.NewError(req.OperationID, "GetFriendList failed ", err.Error(), newReq)
+		return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
+	}
+	for _, v := range RpcResp.FriendInfoList {
+		log.Info(req.OperationID, "UserInfoUpdatedNotification ", req.UserInfo.UserID, v.FriendUser.UserID)
+		chat.UserInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID, v.FriendUser.UserID)
+	}
+	chat.UserInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID, req.OpUserID)
+	log.Info(req.OperationID, "UserInfoUpdatedNotification ", req.UserInfo.UserID, req.OpUserID)
+	return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
+}
+
+func (s *userServer) GetUsersByName(ctx context.Context, req *pbUser.GetUsersByNameReq) (*pbUser.GetUsersByNameResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req.String())
+	resp := &pbUser.GetUsersByNameResp{}
+	users, err := imdb.GetUserByName(req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByName failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	for _, user := range users {
+		isBlock, err := imdb.UserIsBlock(user.UserID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+			continue
+		}
+		resp.Users = append(resp.Users, &pbUser.User{
+			ProfilePhoto: user.FaceURL,
+			Nickname:     user.Nickname,
+			UserId:       user.UserID,
+			CreateTime:   user.CreateTime.String(),
+			IsBlock:      isBlock,
+		})
+	}
+	user := db.User{Nickname: req.UserName}
+	userNums, err := imdb.GetUsersCount(user)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	resp.UserNums = userNums
+	resp.Pagination = &sdkws.ResponsePagination{
+		CurrentPage: req.Pagination.PageNumber,
+		ShowNumber:  req.Pagination.ShowNumber,
+	}
+	return resp, nil
+}
+
+func (s *userServer) GetUserById(ctx context.Context, req *pbUser.GetUserByIdReq) (*pbUser.GetUserByIdResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req.String())
+	resp := &pbUser.GetUserByIdResp{User: &pbUser.User{}}
+	user, err := imdb.GetUserByUserID(req.UserId)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	isBlock, err := imdb.UserIsBlock(req.UserId)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "req：", req.String())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	resp.User = &pbUser.User{
+		ProfilePhoto: user.FaceURL,
+		Nickname:     user.Nickname,
+		UserId:       user.UserID,
+		CreateTime:   user.CreateTime.String(),
+		IsBlock:      isBlock,
+	}
+	return resp, nil
+}
+
+func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pbUser.GetUsersResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbUser.GetUsersResp{User: []*pbUser.User{}}
+	users, err := imdb.GetUsers(req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	if err != nil {
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	for _, v := range users {
+		isBlock, err := imdb.UserIsBlock(v.UserID)
+		if err == nil {
+			user := &pbUser.User{
+				ProfilePhoto: v.FaceURL,
+				UserId:       v.UserID,
+				CreateTime:   v.CreateTime.String(),
+				Nickname:     v.Nickname,
+				IsBlock:      isBlock,
+			}
+			resp.User = append(resp.User, user)
+		}
+	}
+	user := db.User{}
+	nums, err := imdb.GetUsersCount(user)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUsersCount failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	resp.UserNums = nums
+	resp.Pagination = &sdkws.ResponsePagination{ShowNumber: req.Pagination.ShowNumber, CurrentPage: req.Pagination.PageNumber}
+	return resp, nil
+}
+
+func (s *userServer) ResignUser(ctx context.Context, req *pbUser.ResignUserReq) (*pbUser.ResignUserResp, error) {
+	log.NewInfo(req.OperationID, "ResignUser args ", req.String())
+	return &pbUser.ResignUserResp{}, nil
+}
+
+func (s *userServer) AlterUser(ctx context.Context, req *pbUser.AlterUserReq) (*pbUser.AlterUserResp, error) {
+	log.NewInfo(req.OperationID, "AlterUser args ", req.String())
+	resp := &pbUser.AlterUserResp{}
+	user := db.User{
+		PhoneNumber: strconv.FormatInt(req.PhoneNumber, 10),
+		Nickname:    req.Nickname,
+		Email:       req.Email,
+		UserID:      req.UserId,
+	}
+	if err := imdb.UpdateUserInfo(user); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "UpdateUserInfo", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	chat.UserInfoUpdatedNotification(req.OperationID, req.UserId, req.OpUserId)
+	return resp, nil
+}
+
+func (s *userServer) AddUser(ctx context.Context, req *pbUser.AddUserReq) (*pbUser.AddUserResp, error) {
+	log.NewInfo(req.OperationID, "AddUser args ", req.String())
+	resp := &pbUser.AddUserResp{}
+	err := imdb.AddUser(req.UserId, req.PhoneNumber, req.Name)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddUser", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	return resp, nil
+}
+
+func (s *userServer) BlockUser(ctx context.Context, req *pbUser.BlockUserReq) (*pbUser.BlockUserResp, error) {
+	log.NewInfo(req.OperationID, "BlockUser args ", req.String())
+	fmt.Println("BlockUser args ", req.String())
+	resp := &pbUser.BlockUserResp{}
+	err := imdb.BlockUser(req.UserId, req.EndDisableTime)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "BlockUser", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	return resp, nil
+}
+
+func (s *userServer) UnBlockUser(ctx context.Context, req *pbUser.UnBlockUserReq) (*pbUser.UnBlockUserResp, error) {
+	log.NewInfo(req.OperationID, "UnBlockUser args ", req.String())
+	resp := &pbUser.UnBlockUserResp{}
+	err := imdb.UnBlockUser(req.UserId)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "unBlockUser", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	return resp, nil
+}
+
+func (s *userServer) GetBlockUsers(ctx context.Context, req *pbUser.GetBlockUsersReq) (*pbUser.GetBlockUsersResp, error) {
+	log.NewInfo(req.OperationID, "GetBlockUsers args ", req.String())
+	resp := &pbUser.GetBlockUsersResp{}
+	blockUsers, err := imdb.GetBlockUsers(req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	if err != nil {
+		log.Error(req.OperationID, utils.GetSelfFuncName(), "GetBlockUsers", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	for _, v := range blockUsers {
+		resp.BlockUsers = append(resp.BlockUsers, &pbUser.BlockUser{
+			User: &pbUser.User{
+				ProfilePhoto: v.User.FaceURL,
+				Nickname:     v.User.Nickname,
+				UserId:       v.User.UserID,
+				IsBlock:      true,
+			},
+			BeginDisableTime: (v.BeginDisableTime).String(),
+			EndDisableTime:   (v.EndDisableTime).String(),
+		})
+	}
+	resp.Pagination = &sdkws.ResponsePagination{}
+	resp.Pagination.ShowNumber = req.Pagination.ShowNumber
+	resp.Pagination.CurrentPage = req.Pagination.PageNumber
+	nums, err := imdb.GetBlockUsersNumCount()
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetBlockUsersNumCount failed", err.Error())
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	resp.UserNums = nums
+	return resp, nil
+}
+
+func (s *userServer) GetBlockUserById(_ context.Context, req *pbUser.GetBlockUserByIdReq) (*pbUser.GetBlockUserByIdResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetBlockUserById args ", req.String())
+	resp := &pbUser.GetBlockUserByIdResp{}
+	user, err := imdb.GetBlockUserById(req.UserId)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetBlockUserById", err)
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	resp.BlockUser = &pbUser.BlockUser{
+		User: &pbUser.User{
+			ProfilePhoto: user.User.FaceURL,
+			Nickname:     user.User.Nickname,
+			UserId:       user.User.UserID,
+			IsBlock:      true,
+		},
+		BeginDisableTime: (user.BeginDisableTime).String(),
+		EndDisableTime:   (user.EndDisableTime).String(),
+	}
+	return resp, nil
+}
+
+func (s *userServer) DeleteUser(_ context.Context, req *pbUser.DeleteUserReq) (*pbUser.DeleteUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
+	resp := &pbUser.DeleteUserResp{}
+	if row := imdb.DeleteUser(req.UserId); row == 0 {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "delete failed", "delete rows:", row)
+		return resp, errors.WrapError(constant.ErrDB)
+	}
+	return resp, nil
+}

internal/timed_task/init.go

@@ -0,0 +1,26 @@
+package timed_task
+
+type TimeTask struct {
+	delMgoChatChan chan bool
+}
+
+var timeTask TimeTask
+
+func GetInstance() *TimeTask {
+	if timeTask.delMgoChatChan == nil {
+		timeTask.delMgoChatChan = make(chan bool)
+		go func() {
+			timeTask.delMgoChatChan <- true
+		}()
+	}
+	return &timeTask
+}
+
+func (t *TimeTask) Run() {
+	for {
+		select {
+		case <-t.delMgoChatChan:
+			t.timedDeleteUserChat()
+		}
+	}
+}

internal/timed_task/timed_task.go

@@ -0,0 +1,26 @@
+package timed_task
+
+import (
+	"Open_IM/pkg/common/db"
+	"time"
+)
+
+func (t *TimeTask) timedDeleteUserChat() {
+	now := time.Now()
+	next := now.Add(time.Hour * 24)
+	next = time.Date(next.Year(), next.Month(), next.Day(), 0, 0, 0, 0, next.Location())
+	tm := time.NewTimer(next.Sub(now))
+
+	<-tm.C
+
+	count, _ := db.DB.MgoUserCount()
+	for i := 0; i < count; i++ {
+		time.Sleep(10 * time.Millisecond)
+		uid, _ := db.DB.MgoSkipUID(i)
+		db.DB.DelUserChatMongo2(uid)
+	}
+
+	go func() {
+		t.delMgoChatChan <- true
+	}()
+}

internal/utils/callback.go

@@ -0,0 +1 @@
+package utils

internal/utils/cors_middleware_test.go

@@ -0,0 +1,68 @@
+package utils
+
+import (
+	"Open_IM/pkg/utils"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	gin.SetMode(gin.TestMode)
+}
+
+func performRequest(r http.Handler, method, origin string) *httptest.ResponseRecorder {
+	return performRequestWithHeaders(r, method, origin, http.Header{})
+}
+
+func performRequestWithHeaders(r http.Handler, method, origin string, header http.Header) *httptest.ResponseRecorder {
+	req, _ := http.NewRequest(method, "/", nil)
+	// From go/net/http/request.go:
+	// For incoming requests, the Host header is promoted to the
+	// Request.Host field and removed from the Header map.
+	req.Host = header.Get("Host")
+	header.Del("Host")
+	if len(origin) > 0 {
+		header.Set("Origin", origin)
+	}
+	req.Header = header
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+	return w
+}
+
+func newTestRouter() *gin.Engine {
+	router := gin.New()
+	router.Use(utils.CorsHandler())
+	router.GET("/", func(c *gin.Context) {
+		c.String(http.StatusOK, "get")
+	})
+	router.POST("/", func(c *gin.Context) {
+		c.String(http.StatusOK, "post")
+	})
+	router.PATCH("/", func(c *gin.Context) {
+		c.String(http.StatusOK, "patch")
+	})
+
+	return router
+}
+
+func Test_CorsHandler(t *testing.T) {
+	router := newTestRouter()
+	// no CORS request, origin == ""
+	w := performRequest(router, "GET", "")
+	assert.Equal(t, "get", w.Body.String())
+	assert.Equal(t, w.Header().Get("Access-Control-Allow-Origin"), "*")
+	assert.Equal(t, w.Header().Get("Access-Control-Allow-Methods"), "*")
+	assert.Equal(t, w.Header().Get("Access-Control-Allow-Headers"), "*")
+	assert.Equal(t, w.Header().Get("Access-Control-Expose-Headers"), "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers,Cache-Control,Content-Language,Content-Type,Expires,Last-Modified,Pragma,FooBar")
+	assert.Equal(t, w.Header().Get("Access-Control-Max-Age"), "172800")
+	assert.Equal(t, w.Header().Get("Access-Control-Allow-Credentials"), "false")
+	assert.Equal(t, w.Header().Get("content-type"), "application/json")
+
+	w = performRequest(router, "OPTIONS", "")
+	assert.Equal(t, w.Body.String(), "\"Options Request!\"")
+}

internal/utils/get_server_ip_test.go

@@ -0,0 +1,13 @@
+package utils
+
+import (
+	"Open_IM/pkg/utils"
+	"net"
+	"testing"
+)
+
+func TestServerIP(t *testing.T) {
+	if net.ParseIP(utils.ServerIP) == nil {
+		t.Fail()
+	}
+}

internal/utils/id.go

@@ -0,0 +1,28 @@
+package utils
+
+import (
+	"github.com/bwmarrin/snowflake"
+)
+
+func init() {
+	var err error
+	idGenerator, err = snowflake.NewNode(getNodeNum())
+	if err != nil {
+		panic(err)
+	}
+}
+
+func getNodeNum() int64 {
+	return 1
+}
+
+var idGenerator *snowflake.Node
+
+func GenID() string {
+	return idGenerator.Generate().String()
+}
+
+func GenIDs(count int) []string {
+	//impl
+	return []string{}
+}

internal/utils/id_test.go

@@ -0,0 +1,15 @@
+package utils
+
+import "testing"
+
+func TestGenID(t *testing.T) {
+	m := map[string]struct{}{}
+	for i := 0; i < 2000; i++ {
+		got := GenID()
+		if _, ok := m[got]; !ok {
+			m[got] = struct{}{}
+		} else {
+			t.Error("id generate error", got)
+		}
+	}
+}

internal/utils/image_test.go

@@ -0,0 +1,28 @@
+package utils
+
+import (
+	"Open_IM/pkg/utils"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	_, b, _, _ = runtime.Caller(0)
+	// Root folder of this project
+	Root = filepath.Join(filepath.Dir(b), "../..")
+)
+
+func Test_GenSmallImage(t *testing.T) {
+	println(Root)
+	err := utils.GenSmallImage(Root+"/docs/open-im-logo.png", Root+"/out-test/open-im-logo-test.png")
+	assert.Nil(t, err)
+
+	err = utils.GenSmallImage(Root+"/docs/open-im-logo.png", "out-test/open-im-logo-test.png")
+	assert.Nil(t, err)
+
+	err = utils.GenSmallImage(Root+"/docs/Architecture.jpg", "out-test/Architecture-test.jpg")
+	assert.Nil(t, err)
+}

internal/utils/jwt_token_test.go

@@ -0,0 +1,89 @@
+package utils
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/token_verify"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_BuildClaims(t *testing.T) {
+	uid := "1"
+	platform := "PC"
+	ttl := int64(-1)
+	claim := token_verify.BuildClaims(uid, platform, ttl)
+	now := time.Now().Unix()
+
+	assert.Equal(t, claim.UID, uid, "uid should equal")
+	assert.Equal(t, claim.Platform, platform, "platform should equal")
+	assert.Equal(t, claim.RegisteredClaims.ExpiresAt, int64(-1), "StandardClaims.ExpiresAt should be equal")
+	// time difference within 1s
+	assert.Equal(t, claim.RegisteredClaims.IssuedAt, now, "StandardClaims.IssuedAt should be equal")
+	assert.Equal(t, claim.RegisteredClaims.NotBefore, now, "StandardClaims.NotBefore should be equal")
+
+	ttl = int64(60)
+	now = time.Now().Unix()
+	claim = token_verify.BuildClaims(uid, platform, ttl)
+	// time difference within 1s
+	assert.Equal(t, claim.RegisteredClaims.ExpiresAt, int64(60)+now, "StandardClaims.ExpiresAt should be equal")
+	assert.Equal(t, claim.RegisteredClaims.IssuedAt, now, "StandardClaims.IssuedAt should be equal")
+	assert.Equal(t, claim.RegisteredClaims.NotBefore, now, "StandardClaims.NotBefore should be equal")
+}
+
+func Test_CreateToken(t *testing.T) {
+	uid := "1"
+	platform := int32(1)
+	now := time.Now().Unix()
+
+	tokenString, expiresAt, err := token_verify.CreateToken(uid, platform)
+
+	assert.NotEmpty(t, tokenString)
+	assert.Equal(t, expiresAt, 604800+now)
+	assert.Nil(t, err)
+}
+
+func Test_VerifyToken(t *testing.T) {
+	uid := "1"
+	platform := int32(1)
+	tokenString, _, _ := token_verify.CreateToken(uid, platform)
+	result, _ := token_verify.VerifyToken(tokenString, uid)
+	assert.True(t, result)
+	result, _ = token_verify.VerifyToken(tokenString, "2")
+	assert.False(t, result)
+}
+
+func Test_ParseRedisInterfaceToken(t *testing.T) {
+	uid := "1"
+	platform := int32(1)
+	tokenString, _, _ := token_verify.CreateToken(uid, platform)
+
+	claims, err := token_verify.ParseRedisInterfaceToken([]uint8(tokenString))
+	assert.Nil(t, err)
+	assert.Equal(t, claims.UID, uid)
+
+	// timeout
+	config.Config.TokenPolicy.AccessExpire = -80
+	tokenString, _, _ = token_verify.CreateToken(uid, platform)
+	claims, err = token_verify.ParseRedisInterfaceToken([]uint8(tokenString))
+	assert.Equal(t, err, constant.ExpiredToken)
+	assert.Nil(t, claims)
+}
+
+func Test_ParseToken(t *testing.T) {
+	uid := "1"
+	platform := int32(1)
+	tokenString, _, _ := token_verify.CreateToken(uid, platform)
+	claims, err := token_verify.ParseToken(tokenString, "")
+	if err == nil {
+		assert.Equal(t, claims.UID, uid)
+	}
+}
+func Test_GetClaimFromToken(t *testing.T) {
+	token := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVSUQiOiJvcGVuSU0xMjM0NTYiLCJQbGF0Zm9ybSI6IiIsImV4cCI6MTYzODg0NjQ3NiwibmJmIjoxNjM4MjQxNjc2LCJpYXQiOjE2MzgyNDE2NzZ9.W8RZB7ec5ySFj-rGE2Aho2z32g3MprQMdCyPiQu_C2I"
+	c, err := token_verify.GetClaimFromToken(token)
+	assert.Nil(t, c)
+	assert.Nil(t, err)
+}

internal/utils/md5_test.go

@@ -0,0 +1,16 @@
+package utils
+
+import (
+	"Open_IM/pkg/utils"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_Md5(t *testing.T) {
+	result := utils.Md5("go")
+	assert.Equal(t, result, "34d1f91fb2e514b8576fab1a75a89a6b")
+
+	result2 := utils.Md5("go")
+	assert.Equal(t, result, result2)
+}

internal/utils/platform_number_id_to_name_test.go

@@ -0,0 +1,46 @@
+package utils
+
+import (
+	"Open_IM/pkg/common/constant"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_PlatformIDToName(t *testing.T) {
+	assert.Equal(t, constant.PlatformIDToName(1), "IOS")
+	assert.Equal(t, constant.PlatformIDToName(2), "Android")
+	assert.Equal(t, constant.PlatformIDToName(3), "Windows")
+	assert.Equal(t, constant.PlatformIDToName(4), "OSX")
+	assert.Equal(t, constant.PlatformIDToName(5), "Web")
+	assert.Equal(t, constant.PlatformIDToName(6), "MiniWeb")
+	assert.Equal(t, constant.PlatformIDToName(7), "Linux")
+
+	assert.Equal(t, constant.PlatformIDToName(0), "")
+}
+
+func Test_PlatformNameToID(t *testing.T) {
+	assert.Equal(t, constant.PlatformNameToID("IOS"), int32(1))
+	assert.Equal(t, constant.PlatformNameToID("Android"), int32(2))
+	assert.Equal(t, constant.PlatformNameToID("Windows"), int32(3))
+	assert.Equal(t, constant.PlatformNameToID("OSX"), int32(4))
+	assert.Equal(t, constant.PlatformNameToID("Web"), int32(5))
+	assert.Equal(t, constant.PlatformNameToID("MiniWeb"), int32(6))
+	assert.Equal(t, constant.PlatformNameToID("Linux"), int32(7))
+
+	assert.Equal(t, constant.PlatformNameToID("UnknownDevice"), int32(0))
+	assert.Equal(t, constant.PlatformNameToID(""), int32(0))
+}
+
+func Test_PlatformNameToClass(t *testing.T) {
+	assert.Equal(t, constant.PlatformNameToClass("IOS"), "Mobile")
+	assert.Equal(t, constant.PlatformNameToClass("Android"), "Mobile")
+	assert.Equal(t, constant.PlatformNameToClass("OSX"), "PC")
+	assert.Equal(t, constant.PlatformNameToClass("Windows"), "PC")
+	assert.Equal(t, constant.PlatformNameToClass("Web"), "PC")
+	assert.Equal(t, constant.PlatformNameToClass("MiniWeb"), "Mobile")
+	assert.Equal(t, constant.PlatformNameToClass("Linux"), "PC")
+
+	assert.Equal(t, constant.PlatformNameToClass("UnknownDevice"), "")
+	assert.Equal(t, constant.PlatformNameToClass(""), "")
+}

internal/utils/utils.go

@@ -0,0 +1,49 @@
+package utils
+
+import (
+	"encoding/json"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+	"reflect"
+)
+
+func JsonDataList(resp interface{}) []map[string]interface{} {
+	var list []proto.Message
+	if reflect.TypeOf(resp).Kind() == reflect.Slice {
+		s := reflect.ValueOf(resp)
+		for i := 0; i < s.Len(); i++ {
+			ele := s.Index(i)
+			list = append(list, ele.Interface().(proto.Message))
+		}
+	}
+
+	result := make([]map[string]interface{}, 0)
+	for _, v := range list {
+		m := ProtoToMap(v, false)
+		result = append(result, m)
+	}
+	return result
+}
+
+func JsonDataOne(pb proto.Message) map[string]interface{} {
+	return ProtoToMap(pb, false)
+}
+
+func ProtoToMap(pb proto.Message, idFix bool) map[string]interface{} {
+	marshaler := jsonpb.Marshaler{
+		OrigName:     true,
+		EnumsAsInts:  false,
+		EmitDefaults: false,
+	}
+
+	s, _ := marshaler.MarshalToString(pb)
+	out := make(map[string]interface{})
+	json.Unmarshal([]byte(s), &out)
+	if idFix {
+		if _, ok := out["id"]; ok {
+			out["_id"] = out["id"]
+			delete(out, "id")
+		}
+	}
+	return out
+}