Merge branch 'tuoyun'

# Conflicts: # cmd/open_im_api/main.go # config/config.yaml # go.sum # pkg/common/config/config.go # pkg/common/db/model.go
2026-05-19 08:19:01 +08:00 · 2022-03-29 10:58:01 +08:00
parent c1ee2a0adb 1286f9dcb6
commit c5828aba91
75 changed files with 10892 additions and 5192 deletions
@@ -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)
+}
@@ -7,6 +7,7 @@ import (
 	"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"
@@ -39,7 +40,10 @@ func PullMsgBySeqList(c *gin.Context) {

 	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()})
+		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{}
@@ -4,10 +4,8 @@ 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"
-	"Open_IM/pkg/proto/user"
-	rpc "Open_IM/pkg/proto/user"
+	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
 	"github.com/gin-gonic/gin"
@@ -15,111 +13,206 @@ import (
 	"strings"
 )

-func GetAllConversationMessageOpt(c *gin.Context) {
-	params := api.GetAllConversationMessageOptReq{}
-	if err := c.BindJSON(&params); err != nil {
+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
 	}
-	req := &rpc.GetAllConversationMsgOptReq{}
-	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 or not set token in header"})
-		return
-	}
-	log.NewInfo(params.OperationID, "GetAllConversationMessageOpt args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
-	client := user.NewUserClient(etcdConn)
-	RpcResp, err := client.GetAllConversationMsgOpt(context.Background(), req)
+	reqPb.Conversation = &pbUser.Conversation{}
+	err := utils.CopyStructFields(&reqPb, req)
+	err = utils.CopyStructFields(reqPb.Conversation, req.Conversation)
 	if err != nil {
-		log.NewError(params.OperationID, "GetAllConversationMsgOpt rpc failed, ", req, err.Error())
+		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
 	}
-	optResult := make([]*api.OptResult, 0)
-	for _, v := range RpcResp.ConversationOptResultList {
-		temp := new(api.OptResult)
-		temp.ConversationID = v.ConversationID
-		temp.Result = &v.Result
-		optResult = append(optResult, temp)
-	}
-	resp := api.GetAllConversationMessageOptResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, ConversationOptResultList: optResult}
-	log.NewInfo(req.OperationID, "GetAllConversationMsgOpt api return: ", resp)
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	c.JSON(http.StatusOK, resp)
 }

-func GetReceiveMessageOpt(c *gin.Context) {
-	params := api.GetReceiveMessageOptReq{}
-	if err := c.BindJSON(&params); err != nil {
+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
 	}
-	req := &rpc.GetReceiveMessageOptReq{}
-	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
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	log.NewInfo(params.OperationID, "GetReceiveMessageOpt args ", req.String())
+	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 := user.NewUserClient(etcdConn)
-	RpcResp, err := client.GetReceiveMessageOpt(context.Background(), req)
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.BatchSetConversations(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(params.OperationID, "GetReceiveMessageOpt rpc failed, ", req, err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetReceiveMessageOpt rpc failed, " + err.Error()})
+		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
 	}
-	optResult := make([]*api.OptResult, 0)
-	for _, v := range RpcResp.ConversationOptResultList {
-		temp := new(api.OptResult)
-		temp.ConversationID = v.ConversationID
-		temp.Result = &v.Result
-		optResult = append(optResult, temp)
+	if err := utils.CopyStructFields(&resp.Data, respPb); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	resp := api.GetReceiveMessageOptResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, ConversationOptResultList: optResult}
-	log.NewInfo(req.OperationID, "GetReceiveMessageOpt api return: ", resp)
+	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(), "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.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(), "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)
+}
+
+//Deprecated
 func SetReceiveMessageOpt(c *gin.Context) {
-	params := api.SetReceiveMessageOptReq{}
-	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": 400, "errMsg": "bind json failed " + err.Error()})
-		return
-	}
-	req := &rpc.SetReceiveMessageOptReq{}
-	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(params.OperationID, "SetReceiveMessageOpt args ", req.String())
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
-	client := user.NewUserClient(etcdConn)
-	RpcResp, err := client.SetReceiveMessageOpt(context.Background(), req)
-	if err != nil {
-		log.NewError(params.OperationID, "SetReceiveMessageOpt rpc failed, ", req, err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "SetReceiveMessageOpt rpc failed, " + err.Error()})
-		return
-	}
-	optResult := make([]*api.OptResult, 0)
-	for _, v := range RpcResp.ConversationOptResultList {
-		temp := new(api.OptResult)
-		temp.ConversationID = v.ConversationID
-		temp.Result = &v.Result
-		optResult = append(optResult, temp)
-	}
-	resp := api.SetReceiveMessageOptResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, ConversationOptResultList: optResult}
-	log.NewInfo(req.OperationID, "SetReceiveMessageOpt api return: ", resp)
-	c.JSON(http.StatusOK, resp)
+
+}
+
+//Deprecated
+func GetReceiveMessageOpt(c *gin.Context) {
+
+}
+
+//Deprecated
+func GetAllConversationMessageOpt(c *gin.Context) {
+
 }
@@ -26,7 +26,7 @@ func AddBlack(c *gin.Context) {
 	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"))
+	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"})
@@ -57,7 +57,7 @@ func ImportFriend(c *gin.Context) {
 	req := &rpc.ImportFriendReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -97,7 +97,7 @@ func AddFriend(c *gin.Context) {
 	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"))
+	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"})
@@ -131,7 +131,7 @@ func AddFriendResponse(c *gin.Context) {
 	req.HandleMsg = params.HandleMsg
 	req.HandleResult = params.Flag
 	var ok bool
-	ok, req.CommID.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -164,7 +164,7 @@ func DeleteFriend(c *gin.Context) {
 	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"))
+	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"})
@@ -196,7 +196,7 @@ func GetBlacklist(c *gin.Context) {
 	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"))
+	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"})
@@ -235,7 +235,7 @@ func SetFriendRemark(c *gin.Context) {
 	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"))
+	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"})
@@ -267,7 +267,7 @@ func RemoveBlack(c *gin.Context) {
 	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"))
+	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"})
@@ -298,7 +298,7 @@ func IsFriend(c *gin.Context) {
 	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"))
+	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"})
@@ -365,7 +365,7 @@ func GetFriendList(c *gin.Context) {
 	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"))
+	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"})
@@ -399,7 +399,7 @@ func GetFriendApplyList(c *gin.Context) {
 	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"))
+	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"})
@@ -433,7 +433,7 @@ func GetSelfFriendApplyList(c *gin.Context) {
 	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"))
+	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"})
@@ -30,7 +30,7 @@ func KickGroupMember(c *gin.Context) {
 	req := &rpc.KickGroupMemberReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -72,7 +72,7 @@ func GetGroupMembersInfo(c *gin.Context) {
 	req := &rpc.GetGroupMembersInfoReq{}
 	utils.CopyStructFields(req, params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -107,7 +107,7 @@ func GetGroupMemberList(c *gin.Context) {
 	req := &rpc.GetGroupMemberListReq{}
 	utils.CopyStructFields(req, params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -142,7 +142,7 @@ func GetGroupAllMemberList(c *gin.Context) {
 	req := &rpc.GetGroupAllMemberReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -175,7 +175,7 @@ func GetJoinedGroupList(c *gin.Context) {
 	req := &rpc.GetJoinedGroupListReq{}
 	utils.CopyStructFields(req, params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -208,7 +208,7 @@ func InviteUserToGroup(c *gin.Context) {
 	req := &rpc.InviteUserToGroupReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -253,7 +253,7 @@ func CreateGroup(c *gin.Context) {
 		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"))
+	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"})
@@ -357,7 +357,7 @@ func GetGroupsInfo(c *gin.Context) {
 	req := &rpc.GetGroupsInfoReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -390,7 +390,7 @@ func ApplicationGroupResponse(c *gin.Context) {
 	req := &rpc.GroupApplicationResponseReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -422,7 +422,7 @@ func JoinGroup(c *gin.Context) {
 	req := &rpc.JoinGroupReq{}
 	utils.CopyStructFields(req, params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -453,7 +453,7 @@ func QuitGroup(c *gin.Context) {
 	req := &rpc.QuitGroupReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -485,7 +485,7 @@ func SetGroupInfo(c *gin.Context) {
 	utils.CopyStructFields(req.GroupInfo, &params)
 	req.OperationID = params.OperationID
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -516,7 +516,7 @@ func TransferGroupOwner(c *gin.Context) {
 	req := &rpc.TransferGroupOwnerReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -537,3 +537,35 @@ func TransferGroupOwner(c *gin.Context) {
 	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)
+}
@@ -20,6 +20,7 @@ import (
 	"context"
 	"github.com/gin-gonic/gin"
 	"github.com/go-playground/validator/v10"
+	"github.com/golang/protobuf/proto"
 	"github.com/mitchellh/mapstructure"
 	"net/http"
 	"strings"
@@ -29,6 +30,7 @@ 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)
@@ -40,6 +42,9 @@ func newUserSendMsgReq(params *ManagementSendMsgReq) *pbChat.SendMsgReq {
 		fallthrough
 	case constant.File:
 		newContent = utils.StructToJsonString(params.Content)
+	case constant.Revoke:
+		newContent = params.Content["revokeMsgClientID"].(string)
+
 	default:
 	}
 	var options map[string]bool
@@ -70,6 +75,14 @@ func newUserSendMsgReq(params *ManagementSendMsgReq) *pbChat.SendMsgReq {
 			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() {
@@ -103,7 +116,11 @@ func ManagementSendMsg(c *gin.Context) {
 	//case constant.Location:
 	case constant.Custom:
 		data = CustomElem{}
-	//case constant.Revoke:
+	case constant.Revoke:
+		data = RevokeElem{}
+	case constant.OANotification:
+		data = OANotificationElem{}
+		params.SessionType = constant.NotificationChatType
 	//case constant.HasReadReceipt:
 	//case constant.Typing:
 	//case constant.Quote:
@@ -121,12 +138,13 @@ func ManagementSendMsg(c *gin.Context) {
 		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)
 	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": ""})
@@ -138,11 +156,13 @@ func ManagementSendMsg(c *gin.Context) {
 		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
 		}

 	}
@@ -257,3 +277,30 @@ type CustomElem struct {
 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"`
+	Image               struct {
+		SourceUrl   string `mapstructure:"sourceUrl"`
+		SnapshotUrl string `mapstructure:"snapshotUrl"`
+	} `mapstructure:"image"`
+	Video struct {
+		SourceUrl   string `mapstructure:"sourceUrl"`
+		SnapshotUrl string `mapstructure:"snapshotUrl"`
+		Duration    int64  `mapstructure:"duration"`
+	} `mapstructure:"video"`
+	File struct {
+		SourceUrl string `mapstructure:"sourceUrl"`
+		FileName  string `mapstructure:"fileName"`
+		FileSize  int64  `mapstructure:"fileSize"`
+	} `mapstructure:"file"`
+	Ex string `mapstructure:"ex"`
+}
@@ -31,7 +31,7 @@ func DeleteUser(c *gin.Context) {
 	req := &rpc.DeleteUsersReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -63,7 +63,7 @@ func GetAllUsersUid(c *gin.Context) {
 	req := &rpc.GetAllUserIDReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -95,7 +95,7 @@ func AccountCheck(c *gin.Context) {
 	req := &rpc.AccountCheckReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -127,7 +127,7 @@ func GetUsersOnlineStatus(c *gin.Context) {
 	req := &pbRelay.GetUsersOnlineStatusReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -0,0 +1,236 @@
+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())
+	}
+	resp.Data.Tags = respPb.Tags
+	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())
+	}
+	resp.Data.Logs = respPb.TagSendLogs
+	resp.Data.ShowNumber = respPb.Pagination.ShowNumber
+	resp.Data.CurrentPage = respPb.Pagination.CurrentPage
+	c.JSON(http.StatusOK, resp)
+}
@@ -10,13 +10,18 @@ import (
 	url2 "net/url"
 )

+var (
+	minioClient *minio.Client
+)
+
 func MinioInit() {
+	log.NewInfo("", utils.GetSelfFuncName())
 	minioUrl, err := url2.Parse(config.Config.Credential.Minio.Endpoint)
 	if err != nil {
 		log.NewError("", utils.GetSelfFuncName(), "parse failed, please check config/config.yaml", err.Error())
 		return
 	}
-	minioClient, err := minio.New(minioUrl.Host, &minio.Options{
+	minioClient, err = minio.New(minioUrl.Host, &minio.Options{
 		Creds:  credentials.NewStaticV4(config.Config.Credential.Minio.AccessKeyID, config.Config.Credential.Minio.SecretAccessKey, ""),
 		Secure: false,
 	})
@@ -45,8 +50,8 @@ func MinioInit() {
 	// 自动化桶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 	", err.Error())
-	//	return`z
+	//	log.NewError("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
+	//	return
 	//}
 	log.NewInfo("", utils.GetSelfFuncName(), "minio create and set policy success")
 }
@@ -8,15 +8,92 @@ import (
 	"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.StatusBadRequest, gin.H{"errCode": 400, "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
+		req  apiStruct.MinioStorageCredentialReq
 		resp apiStruct.MiniostorageCredentialResp
 	)
 	if err := c.BindJSON(&req); err != nil {
@@ -24,7 +101,7 @@ func MinioStorageCredential(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
 		return
 	}
-	ok, _ := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -51,5 +128,5 @@ func MinioStorageCredential(c *gin.Context) {
 	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})
+	c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
 }
@@ -22,7 +22,7 @@ func TencentCloudStorageCredential(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
 		return
 	}
-	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -26,7 +26,7 @@ func GetUsersInfo(c *gin.Context) {
 	req := &rpc.GetUserInfoReq{}
 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -66,7 +66,7 @@ func UpdateUserInfo(c *gin.Context) {

 	req.OperationID = params.OperationID
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -98,7 +98,7 @@ func GetSelfUserInfo(c *gin.Context) {

 	utils.CopyStructFields(req, &params)
 	var ok bool
-	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+	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"})
@@ -11,7 +11,7 @@ import (

 func JWTAuth() gin.HandlerFunc {
 	return func(c *gin.Context) {
-		ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"))
+		ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), "")
 		log.NewInfo("0", utils.GetSelfFuncName(), "userID: ", userID)
 		c.Set("userID", userID)
 		if !ok {
@@ -28,7 +28,7 @@ func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
 	dec := gob.NewDecoder(b)
 	err := dec.Decode(&m)
 	if err != nil {
-		log.ErrorByKv("ws Decode  err", "", "err", err.Error())
+		log.NewError("", "ws Decode  err", err.Error())
 		ws.sendErrMsg(conn, 200, err.Error(), constant.WSDataError, "", "")
 		err = conn.Close()
 		if err != nil {
@@ -37,7 +37,7 @@ func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
 		return
 	}
 	if err := validate.Struct(m); err != nil {
-		log.ErrorByKv("ws args validate  err", "", "err", err.Error())
+		log.NewError("", "ws args validate  err", err.Error())
 		ws.sendErrMsg(conn, 201, err.Error(), m.ReqIdentifier, m.MsgIncr, m.OperationID)
 		return
 	}
@@ -45,7 +45,7 @@ func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
 	//	ws.sendErrMsg(conn, 202, "token validate err", m.ReqIdentifier, m.MsgIncr,m.OperationID)
 	//	return
 	//}
-	log.InfoByKv("Basic Info Authentication Success", m.OperationID, "reqIdentifier", m.ReqIdentifier, "sendID", m.SendID, "msgIncr", m.MsgIncr)
+	log.NewInfo(m.OperationID, "Basic Info Authentication Success", m)

 	switch m.ReqIdentifier {
 	case constant.WSGetNewestSeq:
@@ -61,7 +61,7 @@ func (ws *WServer) msgParse(conn *UserConn, binaryMsg []byte) {
 	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)
+	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
@@ -99,15 +99,15 @@ func (ws *WServer) getSeqResp(conn *UserConn, m *Req, pb *pbChat.GetMaxAndMinSeq
 }

 func (ws *WServer) pullMsgBySeqListReq(conn *UserConn, m *Req) {
-	log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq start", m.SendID, m.ReqIdentifier, m.MsgIncr)
+	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)
-	log.NewInfo(m.OperationID, "Ws call success to pullMsgBySeqListReq middle", m.SendID, m.ReqIdentifier, m.MsgIncr, data.(sdk_ws.PullMessageBySeqListReq).SeqList)
 	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)
@@ -145,7 +145,7 @@ func (ws *WServer) pullMsgBySeqListResp(conn *UserConn, m *Req, pb *sdk_ws.PullM
 }
 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)
+	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 {
@@ -196,51 +196,48 @@ func (ws *WServer) sendMsgResp(conn *UserConn, m *Req, pb *pbChat.SendMsgResp) {
 }

 func (ws *WServer) sendSignalMsgReq(conn *UserConn, m *Req) {
-	sendMsgCount++
-	log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq start", m.MsgIncr, m.ReqIdentifier, m.SendID)
+	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.WSSendMsg)
+	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendSignalMsg)
 	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 sendSignalMsgReq 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, "rpc sendMsg err", err.Error())
-			nReply.ErrCode = 200
-			nReply.ErrMsg = err.Error()
-			ws.sendSignalMsgResp(conn, m, nReply)
+		isPass2, errCode2, errMsg2, signalResp, msgData := ws.signalMessageAssemble(pData.(*sdk_ws.SignalReq), m.OperationID)
+		if isPass2 {
+			pbData := pbChat.SendMsgReq{
+				Token:       m.Token,
+				OperationID: m.OperationID,
+				MsgData:     msgData,
+			}
+			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, "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.NewInfo(pbData.OperationID, "rpc call success to sendMsgReq", reply.String())
-			ws.sendSignalMsgResp(conn, m, reply)
+			log.NewError(m.OperationID, isPass2, errCode2, errMsg2)
+			ws.sendSignalMsgResp(conn, errCode2, errMsg2, m, signalResp)
 		}
-
 	} else {
-		nReply.ErrCode = errCode
-		nReply.ErrMsg = errMsg
-		ws.sendSignalMsgResp(conn, m, nReply)
+		ws.sendSignalMsgResp(conn, errCode, errMsg, m, nil)
 	}

 }
-func (ws *WServer) sendSignalMsgResp(conn *UserConn, m *Req, pb *pbChat.SendMsgResp) {
+func (ws *WServer) sendSignalMsgResp(conn *UserConn, errCode int32, errMsg string, m *Req, pb *sdk_ws.SignalResp) {
 	// := 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)
+	b, _ := proto.Marshal(pb)
 	mReply := Resp{
 		ReqIdentifier: m.ReqIdentifier,
 		MsgIncr:       m.MsgIncr,
-		ErrCode:       pb.GetErrCode(),
-		ErrMsg:        pb.GetErrMsg(),
+		ErrCode:       errCode,
+		ErrMsg:        errMsg,
 		OperationID:   m.OperationID,
 		Data:          b,
 	}
@@ -0,0 +1,67 @@
+package open_im_media
+
+import (
+	pbRtc "Open_IM/pkg/proto/rtc"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"context"
+	"errors"
+	"github.com/jinzhu/copier"
+	"google.golang.org/grpc"
+)
+
+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,
+	//})
+
+}
@@ -7,9 +7,12 @@
 package gate

 import (
+	"Open_IM/internal/msg_gateway/gate/open_im_media"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
 	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"errors"
 	"github.com/golang/protobuf/proto"
 )

@@ -58,7 +61,7 @@ type SeqListData struct {

 func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, errMsg string, returnData interface{}) {
 	switch r {
-	case constant.WSSendMsg | constant.WSSendSignalMsg:
+	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)
@@ -70,6 +73,18 @@ func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, er

 		}
 		return true, 0, "", data
+	case constant.WSSendSignalMsg:
+		data := open_im_sdk.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 {
@@ -101,3 +116,140 @@ func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, er
 	//} 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
+}
@@ -93,20 +93,20 @@ func (ws *WServer) writeMsg(conn *UserConn, a int, msg []byte) error {
 	return conn.WriteMessage(a, msg)

 }
-func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int32, newConn *UserConn, token string) {
+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 {
+		if oldConnMap, ok := ws.wsUserToConn[uid]; ok { // user->map[platform->conn]
 			if oldConn, ok := oldConnMap[constant.PlatformIDToName(platformID)]; ok {
-				log.NewDebug("", uid, platformID, "kick old conn")
+				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("", "get token from redis err", err.Error())
+					log.NewError(operationID, "get token from redis err", err.Error())
 					return
 				}
 				if m == nil {
-					log.NewError("", "get token from redis err", "m is nil")
+					log.NewError(operationID, "get token from redis err", "m is nil")
 					return
 				}
 				for k, _ := range m {
@@ -114,10 +114,10 @@ func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int32, newCo
 						m[k] = constant.KickedToken
 					}
 				}
-				log.NewDebug("get map is ", m)
+				log.NewDebug(operationID, "get map is ", m)
 				err = db.DB.SetTokenMapByUidPid(uid, platformID, m)
 				if err != nil {
-					log.NewError("", "SetTokenMapByUidPid err", err.Error())
+					log.NewError(operationID, "SetTokenMapByUidPid err", err.Error())
 					return
 				}
 				err = oldConn.Close()
@@ -128,13 +128,15 @@ func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int32, newCo
 				}
 				delete(ws.wsConnToUser, oldConn)
 				if err != nil {
-					log.NewError("", "conn close err", err.Error(), uid, platformID)
+					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("no other conn", ws.wsUserToConn)
+			log.NewDebug(operationID, "no other conn", ws.wsUserToConn, uid, platformID)
 		}

 	case constant.SingleTerminalLogin:
@@ -162,14 +164,17 @@ func (ws *WServer) sendKickMsg(oldConn, newConn *UserConn) {
 func (ws *WServer) addUserConn(uid string, platformID int32, conn *UserConn, token string) {
 	rwLock.Lock()
 	defer rwLock.Unlock()
-	ws.MultiTerminalLoginChecker(uid, platformID, conn, token)
+	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
@@ -183,7 +188,7 @@ func (ws *WServer) addUserConn(uid string, platformID int32, conn *UserConn, tok
 	for _, v := range ws.wsUserToConn {
 		count = count + len(v)
 	}
-	log.Debug("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)
+	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))

 }
@@ -258,9 +263,9 @@ 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 := token_verify.VerifyToken(query["token"][0], query["sendID"][0]); !ok {
+		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)
+			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
@@ -38,15 +38,15 @@ func (mc *HistoryConsumerHandler) Init() {
 }

 func (mc *HistoryConsumerHandler) handleChatWs2Mongo(msg []byte, msgKey string) {
-	log.NewInfo("msg come mongo!!!", "", "msg", string(msg))
 	time := utils.GetCurrentTimestampByNano()
 	msgFromMQ := pbMsg.MsgDataToMQ{}
 	err := proto.Unmarshal(msg, &msgFromMQ)
 	if err != nil {
-		log.ErrorByKv("msg_transfer Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
+		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)
@@ -99,28 +99,28 @@ func (mc *HistoryConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
 	return nil
 }
 func sendMessageToPush(message *pbMsg.MsgDataToMQ, pushToUserID string) {
-	log.InfoByKv("msg_transfer send message to push", message.OperationID, "message", message.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.ErrorByKv("rpc dial failed", rpcPushMsg.OperationID, "push data", rpcPushMsg.String())
+		log.Error(rpcPushMsg.OperationID, "rpc dial failed", "push data", rpcPushMsg.String())
 		pid, offset, err := producer.SendMessage(&mqPushMsg)
 		if err != nil {
-			log.ErrorByKv("kafka send failed", mqPushMsg.OperationID, "send data", message.String(), "pid", pid, "offset", offset, "err", err.Error())
+			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.ErrorByKv("rpc send failed", rpcPushMsg.OperationID, "push data", rpcPushMsg.String(), "err", err.Error())
+		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.ErrorByKv("kafka send failed", mqPushMsg.OperationID, "send data", mqPushMsg.String(), "pid", pid, "offset", offset, "err", err.Error())
+			log.Error("kafka send failed", mqPushMsg.OperationID, "send data", mqPushMsg.String(), "pid", pid, "offset", offset, "err", err.Error())
 		}
 	} else {
-		log.InfoByKv("rpc send success", rpcPushMsg.OperationID, "push data", rpcPushMsg.String())
+		log.Info("rpc send success", rpcPushMsg.OperationID, "push data", rpcPushMsg.String())

 	}
 }
@@ -51,7 +51,7 @@ func (rpc *rpcAuth) UserToken(_ context.Context, req *pbAuth.UserTokenReq) (*pbA
 		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}

-	log.NewInfo(req.OperationID, "rpc UserToken return ")
+	log.NewInfo(req.OperationID, "rpc UserToken return ", tokens, expTime)
 	return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{}, Token: tokens, ExpiredTime: expTime}, nil
 }

@@ -351,7 +351,7 @@ func (s *friendServer) IsInBlackList(ctx context.Context, req *pbFriend.IsInBlac
 }

 func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq) (*pbFriend.IsFriendResp, error) {
-	log.NewInfo("IsFriend args ", req.String())
+	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)
@@ -363,7 +363,7 @@ func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq)
 	} else {
 		isFriend = false
 	}
-	log.NewInfo("IsFriend rpc ok ", pbFriend.IsFriendResp{Response: isFriend})
+	log.NewInfo(req.CommID.OperationID, pbFriend.IsFriendResp{Response: isFriend})
 	return &pbFriend.IsFriendResp{Response: isFriend}, nil
 }

@@ -937,3 +937,74 @@ func (s *groupServer) GetUserReqApplicationList(_ context.Context, req *pbGroup.
 	}
 	return resp, nil
 }
+
+func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (*pbGroup.DismissGroupResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
+	if !token_verify.IsMangerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
+		log.NewError(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
+		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+
+	err := imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusDismissed)
+	if err != nil {
+		log.NewError(req.OperationID, "OperateGroupStatus failed ", req.GroupID, constant.GroupStatusDismissed)
+		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	chat.GroupDismissedNotification(req)
+
+	err = imdb.DeleteGroupMemberByGroupID(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "DeleteGroupMemberByGroupID failed ", req.GroupID)
+		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
+	return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
+}
+
+//  rpc MuteGroupMember(MuteGroupMemberReq) returns(MuteGroupMemberResp);
+//  rpc CancelMuteGroupMember(CancelMuteGroupMemberReq) returns(CancelMuteGroupMemberResp);
+//  rpc MuteGroup(MuteGroupReq) returns(MuteGroupResp);
+//  rpc CancelMuteGroup(CancelMuteGroupReq) returns(CancelMuteGroupResp);
+
+func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (*pbGroup.MuteGroupMemberResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.UserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+		log.Error(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
+		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	groupMemberInfo := db.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
+	groupMemberInfo.MuteEndTime = time.Unix(int64(time.Now().Second())+int64(req.MutedSeconds), 0)
+	err := imdb.UpdateGroupMemberInfo(groupMemberInfo)
+	if err != nil {
+		log.Error(req.OperationID, "UpdateGroupMemberInfo failed ", err.Error(), groupMemberInfo)
+		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
+	return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
+}
+
+func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (*pbGroup.CancelMuteGroupMemberResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.UserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+		log.Error(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
+		return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+	groupMemberInfo := db.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
+	groupMemberInfo.MuteEndTime = time.Unix(0, 0)
+	err := imdb.UpdateGroupMemberInfo(groupMemberInfo)
+	if err != nil {
+		log.Error(req.OperationID, "UpdateGroupMemberInfo failed ", err.Error(), groupMemberInfo)
+		return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
+	return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
+}
+
+func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (*pbGroup.MuteGroupResp, error) {
+	return nil, nil
+}
+
+func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) {
+	return nil, nil
+}
@@ -44,9 +44,8 @@ func conversationNotification(contentType int32, m proto.Message, operationID, u
 	Notification(&n)
 }

-// 客户端调用设置opt接口后调用
-func SetReceiveMessageOptNotification(operationID, opUserID, userID string) {
-	log.NewInfo(operationID, utils.GetSelfFuncName(), "operation user: ", opUserID, "operation id: ", userID)
+func SetConversationNotification(operationID, userID string) {
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "userID: ", userID)
 	conversationUpdateTips := open_im_sdk.ConversationUpdateTips{
 		UserID: userID,
 	}
@@ -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, err
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
@@ -157,7 +157,9 @@ func groupNotification(contentType int32, m proto.Message, sendID, groupID, recv
 	case constant.MemberInvitedNotification: //
 		tips.DefaultTips = toNickname + " " + cn.MemberInvited.DefaultTips.Tips
 	case constant.MemberEnterNotification:
-		tips.DefaultTips = toNickname + " " + cn.MemberInvited.DefaultTips.Tips
+		tips.DefaultTips = toNickname + " " + cn.MemberEnter.DefaultTips.Tips
+	case constant.GroupDismissedNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupDismissed.DefaultTips.Tips
 	default:
 		log.Error(operationID, "contentType failed ", contentType)
 		return
@@ -324,6 +326,19 @@ func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
 	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;
@@ -7,6 +7,7 @@ import (
 	"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"
@@ -41,16 +42,45 @@ type MsgCallBackResp struct {
 	}
 }

-func userRelationshipVerification(data *pbChat.SendMsgReq) {
-
-	//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())
-	//}
+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)
@@ -86,6 +116,7 @@ func (rpc *rpcChat) encapsulateMsgData(msg *sdk_ws.MsgData) {
 	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)
@@ -94,6 +125,7 @@ func (rpc *rpcChat) encapsulateMsgData(msg *sdk_ws.MsgData) {
 		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)

@@ -102,12 +134,15 @@ func (rpc *rpcChat) encapsulateMsgData(msg *sdk_ws.MsgData) {
 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())
-	userRelationshipVerification(pb)
+	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}
+	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{
@@ -274,7 +309,7 @@ func returnMsg(replay *pbChat.SendMsgResp, pb *pbChat.SendMsgReq, errCode int32,

 func modifyMessageByUserMessageReceiveOpt(userID, sourceID string, sessionType int, pb *pbChat.SendMsgReq) bool {
 	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
-	opt, err := db.DB.GetSingleConversationMsgOpt(userID, conversationID)
+	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
@@ -470,14 +505,24 @@ func Notification(n *NotificationMsg) {
 		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
 	}
 	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:

 	}
@@ -0,0 +1,39 @@
+package msg
+
+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"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+)
+
+func TagSendMessage(operationID, sendID, recvID, content string, contentType int32) {
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "args: ", sendID, recvID, content, contentType)
+	var req pbChat.SendMsgReq
+	var msgData pbCommon.MsgData
+	msgData.SendID = sendID
+	msgData.RecvID = recvID
+	msgData.ContentType = contentType
+	msgData.SessionType = constant.SingleChatType
+	msgData.MsgFrom = constant.UserMsgType
+	msgData.Content = []byte(content)
+	msgData.Options = map[string]bool{}
+	msgData.Options[constant.IsSenderConversationUpdate] = false
+	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)
+	}
+}
@@ -0,0 +1,186 @@
+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"
+	"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"
+)
+
+type officeServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewOfficeServer(port int) *officeServer {
+	log.NewPrivateLog("office")
+	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.RemoveUserIDRepByMap(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.RemoveUserIDRepByMap(req.IncreaseUserIDList)
+	reduceUserIDList := utils.RemoveUserIDRepByMap(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{}}
+	userIDList, err := db.DB.GetUserIDListByTagID(req.SendID, req.TagID)
+	for _, userID := range userIDList {
+		msg.TagSendMessage(req.OperationID, req.SendID, userID, req.Content, req.ContentType)
+	}
+	if err := db.DB.SaveTagSendLog(req); 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
+}
@@ -88,63 +88,137 @@ func (s *userServer) GetUserInfo(ctx context.Context, req *pbUser.GetUserInfoReq
 			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) SetReceiveMessageOpt(ctx context.Context, req *pbUser.SetReceiveMessageOptReq) (*pbUser.SetReceiveMessageOptResp, error) {
-	log.NewInfo(req.OperationID, "SetReceiveMessageOpt args ", req.String())
-	m := make(map[string]int, len(req.ConversationIDList))
-	for _, v := range req.ConversationIDList {
-		m[v] = int(req.Opt)
+func (s *userServer) BatchSetConversations(ctx context.Context, req *pbUser.BatchSetConversationsReq) (*pbUser.BatchSetConversationsResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	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)
 	}
-	err := db.DB.SetMultiConversationMsgOpt(req.FromUserID, m)
-	if err != nil {
-		log.NewError(req.OperationID, "SetMultiConversationMsgOpt failed ", err.Error(), req)
-		return &pbUser.SetReceiveMessageOptResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-	}
-	resp := pbUser.SetReceiveMessageOptResp{CommonResp: &pbUser.CommonResp{}}
-
-	for _, v := range req.ConversationIDList {
-		resp.ConversationOptResultList = append(resp.ConversationOptResultList, &pbUser.OptResult{ConversationID: v, Result: req.Opt})
-	}
-	chat.SetReceiveMessageOptNotification(req.OperationID, req.OpUserID, req.FromUserID)
-	log.NewInfo(req.OperationID, "SetReceiveMessageOpt rpc return ", resp.String())
-	return &resp, nil
+	chat.SetConversationNotification(req.OperationID, req.OwnerUserID)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
+	resp.CommonResp = &pbUser.CommonResp{}
+	return resp, nil
 }

-func (s *userServer) GetReceiveMessageOpt(ctx context.Context, req *pbUser.GetReceiveMessageOptReq) (*pbUser.GetReceiveMessageOptResp, error) {
-	log.NewInfo(req.OperationID, "GetReceiveMessageOpt args ", req.String())
-	m, err := db.DB.GetMultiConversationMsgOpt(req.FromUserID, req.ConversationIDList)
+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, "GetMultiConversationMsgOpt failed ", err.Error(), req.FromUserID, req.ConversationIDList)
-		return &pbUser.GetReceiveMessageOptResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, 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
 	}
-	resp := pbUser.GetReceiveMessageOptResp{CommonResp: &pbUser.CommonResp{}}
-	for k, v := range m {
-		resp.ConversationOptResultList = append(resp.ConversationOptResultList, &pbUser.OptResult{ConversationID: k, Result: int32(v)})
+	if err = utils.CopyStructFields(&resp.Conversations, conversations); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields error", err.Error())
 	}
-	log.NewInfo(req.OperationID, "GetReceiveMessageOpt rpc return ", resp.String())
-	return &resp, nil
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
+	resp.CommonResp = &pbUser.CommonResp{}
+	return resp, nil
 }

-func (s *userServer) GetAllConversationMsgOpt(ctx context.Context, req *pbUser.GetAllConversationMsgOptReq) (*pbUser.GetAllConversationMsgOptResp, error) {
-	log.NewInfo(req.OperationID, "GetAllConversationMsgOpt args ", req.String())
-	m, err := db.DB.GetAllConversationMsgOpt(req.FromUserID)
+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, "GetAllConversationMsgOpt failed ", err.Error(), req.FromUserID)
-		return &pbUser.GetAllConversationMsgOptResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, 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
 	}
-	resp := pbUser.GetAllConversationMsgOptResp{CommonResp: &pbUser.CommonResp{}}
-	for k, v := range m {
-		resp.ConversationOptResultList = append(resp.ConversationOptResultList, &pbUser.OptResult{ConversationID: k, Result: int32(v)})
+	if err := utils.CopyStructFields(resp.Conversation, &conversation); err != nil {
+		log.Debug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields error", conversation, err.Error())
 	}
-	log.NewInfo(req.OperationID, "GetAllConversationMsgOpt rpc return ", resp.String())
-	return &resp, nil
+	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())
+	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
+	}
+	chat.SetConversationNotification(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
+	}
+	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.SetConversationNotification(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.IsMangerUserID(req.OpUserID) {