Merge branch 'tuoyun'

# Conflicts:
#	cmd/open_im_cms_api/main.go
#	config/config.yaml

cmd/open_im_api/main.go

@@ -34,7 +34,7 @@ func main() {
 	r := gin.Default()
 	r.Use(utils.CorsHandler())
 
-	log.Info("load config: ", config.Config)
+	log.Info("load  config: ", config.Config)
 	// user routing group, which handles user registration and login services
 	userRouterGroup := r.Group("/user")
 	{
@@ -42,6 +42,7 @@ func main() {
 		userRouterGroup.POST("/get_users_info", user.GetUsersInfo)                  //1
 		userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo)           //1
 		userRouterGroup.POST("/get_users_online_status", user.GetUsersOnlineStatus) //1
+		userRouterGroup.POST("/get_users_info_from_cache", user.GetUsersInfoFromCache)
 	}
 	//friend routing group
 	friendRouterGroup := r.Group("/friend")
@@ -129,6 +130,7 @@ func main() {
 		conversationGroup.POST("/set_conversation", conversation.SetConversation)
 		conversationGroup.POST("/batch_set_conversation", conversation.BatchSetConversations)
 		conversationGroup.POST("/set_recv_msg_opt", conversation.SetRecvMsgOpt)
+		conversationGroup.POST("/modify_conversation_field", conversation.ModifyConversationField)
 	}
 	// office
 	officeGroup := r.Group("/office")
@@ -173,7 +175,7 @@ func main() {
 	}
 
 	go apiThird.MinioInit()
-	ginPort := flag.Int("port", 10000, "get ginServerPort from cmd,default 10000 as port")
+	ginPort := flag.Int("port", 10002, "get ginServerPort from cmd,default 10000 as port")
 	flag.Parse()
 	fmt.Println("start api server, port: ", *ginPort)
 	err := r.Run(":" + strconv.Itoa(*ginPort))

cmd/open_im_cms_api/main.go

@@ -14,7 +14,8 @@ func main() {
 	gin.SetMode(gin.ReleaseMode)
 	router := cms_api.NewGinRouter()
 	router.Use(utils.CorsHandler())
-	ginPort := flag.Int("port", 8000, "get ginServerPort from cmd,default 10000 as port")
+	ginPort := flag.Int("port", 10006, "get ginServerPort from cmd,default 8000 as port")
-	fmt.Println("start cms api server, port: ", *ginPort)
+	flag.Parse()
+	fmt.Println("start cms api server, port: ", ginPort)
 	router.Run(":" + strconv.Itoa(*ginPort))
 }

cmd/rpc/open_im_cache/Makefile

@@ -0,0 +1,24 @@
+.PHONY: all build run gotool install clean help
+
+BINARY_NAME=open_im_cache
+BIN_DIR=../../../bin/
+
+all: gotool build
+
+build:
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s"
+
+run:
+	@go run ./
+
+gotool:
+	go fmt ./
+	go vet ./
+
+install:
+	make build
+	mv ${BINARY_NAME} ${BIN_DIR}
+
+clean:
+	@if [ -f ${BINARY_NAME} ] ; then rm ${BINARY_NAME} ; fi
+

cmd/rpc/open_im_cache/main.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	rpcCache "Open_IM/internal/rpc/cache"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	rpcPort := flag.Int("port", 10600, "RpcToken default listen port 10800")
+	flag.Parse()
+	fmt.Println("start auth rpc server, port: ", *rpcPort)
+	rpcServer := rpcCache.NewCacheServer(*rpcPort)
+	rpcServer.Run()
+
+}

cmd/rpc/open_im_conversation/Makefile

@@ -0,0 +1,24 @@
+.PHONY: all build run gotool install clean help
+
+BINARY_NAME=open_im_conversation
+BIN_DIR=../../../bin/
+
+all: gotool build
+
+build:
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s"
+
+run:
+	@go run ./
+
+gotool:
+	go fmt ./
+	go vet ./
+
+install:
+	make build
+	mv ${BINARY_NAME} ${BIN_DIR}
+
+clean:
+	@if [ -f ${BINARY_NAME} ] ; then rm ${BINARY_NAME} ; fi
+

cmd/rpc/open_im_conversation/main.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	rpcConversation "Open_IM/internal/rpc/conversation"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	rpcPort := flag.Int("port", 11400, "RpcConversation default listen port 11300")
+	flag.Parse()
+	fmt.Println("start conversation rpc server, port: ", *rpcPort)
+	rpcServer := rpcConversation.NewRpcConversationServer(*rpcPort)
+	rpcServer.Run()
+
+}

cmd/rpc/open_im_rpc/Makefile

@@ -0,0 +1,23 @@
+.PHONY: all build run gotool install clean help
+
+BINARY_NAME=open_im_office
+BIN_DIR=../../../bin/
+
+all: gotool build
+
+build:
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s"
+
+run:
+	@go run ./
+
+gotool:
+	go fmt ./
+	go vet ./
+
+install:
+	make build
+	mv ${BINARY_NAME} ${BIN_DIR}
+
+clean:
+	@if [ -f ${BINARY_NAME} ] ; then rm ${BINARY_NAME} ; fi

cmd/rpc/open_im_rpc/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	rpc "Open_IM/internal/rpc/cache"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	rpcPort := flag.Int("port", 11500, "rpc listening port")
+	flag.Parse()
+	fmt.Println("start office rpc server, port: ", *rpcPort)
+	rpcServer := rpc.NewOfficeServer(*rpcPort)
+	rpcServer.Run()
+}

config/config.yaml

@@ -113,8 +113,8 @@ credential: #腾讯cos，发送图片、视频、文件时需要，请自行申
 rpcport: #rpc服务端口 默认即可
   openImUserPort: [ 10110 ]
   openImFriendPort: [ 10120 ]
-  openImOfflineMessagePort: [ 10130 ]
+  openImMessagePort: [ 10130 ]
-  openImOnlineRelayPort: [ 10140 ]
+  openImMessageGatewayPort: [ 10140 ]
   openImGroupPort: [ 10150 ]
   openImAuthPort: [ 10160 ]
   openImPushPort: [ 10170 ]
@@ -123,6 +123,8 @@ rpcport: #rpc服务端口 默认即可
   openImAdminCmsPort: [ 10200 ]
   openImOfficePort: [ 10210 ]
   openImOrganizationPort: [ 10220 ]
+  openImConversationPort: [ 10230 ]
+  openImCachePort: [10240]
   c2c:
     callbackBeforeSendMsg:
       switch: false
@@ -146,6 +148,8 @@ rpcregistername: #rpc注册服务名，默认即可
   openImAdminCMSName: AdminCMS
   openImOfficeName: Office
   openImOrganizationName: Organization
+  openImConversationName: Conversation
+  openImCacheName: Cache
 
 log:
   storageLocation: ../logs/

internal/api/auth/auth.go

@@ -17,8 +17,9 @@ import (
 func UserRegister(c *gin.Context) {
 	params := api.UserRegisterReq{}
 	if err := c.BindJSON(&params); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
+		errMsg := " BindJSON failed " + err.Error()
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		log.NewError("0", errMsg)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
 		return
 	}
 
@@ -37,22 +38,24 @@ func UserRegister(c *gin.Context) {
 	client := rpc.NewAuthClient(etcdConn)
 	reply, err := client.UserRegister(context.Background(), req)
 	if err != nil {
-		log.NewError(req.OperationID, "call rpc err ", err.Error())
+		errMsg := req.OperationID + " " + "client.UserRegister failed " + err.Error() + req.String()
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "internal service err"})
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
 	if reply.CommonResp.ErrCode != 0 {
-		log.NewError(req.OperationID, "UserRegister failed ", err)
+		errMsg := req.OperationID + " " + " client.UserRegister failed " + reply.CommonResp.ErrMsg + req.String()
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": reply.CommonResp.ErrMsg})
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
-
 	}
 
 	pbDataToken := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
 	replyToken, err := client.UserToken(context.Background(), pbDataToken)
 	if err != nil {
-		log.NewError(req.OperationID, "UserToken failed ", err.Error(), pbDataToken)
+		errMsg := req.OperationID + " " + " client.UserToken failed " + err.Error() + pbDataToken.String()
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
 	resp := api.UserRegisterResp{CommResp: api.CommResp{ErrCode: replyToken.CommonResp.ErrCode, ErrMsg: replyToken.CommonResp.ErrMsg},
@@ -65,14 +68,16 @@ func UserRegister(c *gin.Context) {
 func UserToken(c *gin.Context) {
 	params := api.UserTokenReq{}
 	if err := c.BindJSON(&params); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
+		errMsg := " BindJSON failed " + err.Error()
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		log.NewError("0", errMsg)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
 		return
 	}
 
 	if params.Secret != config.Config.Secret {
+		errMsg := params.OperationID + " params.Secret != config.Config.Secret "
 		log.NewError(params.OperationID, "params.Secret != config.Config.Secret", params.Secret, config.Config.Secret)
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "not authorized"})
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": errMsg})
 		return
 	}
 	req := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
@@ -81,8 +86,9 @@ func UserToken(c *gin.Context) {
 	client := rpc.NewAuthClient(etcdConn)
 	reply, err := client.UserToken(context.Background(), req)
 	if err != nil {
-		log.NewError(req.OperationID, "UserToken failed ", err.Error(), req.String())
+		errMsg := req.OperationID + " UserToken failed " + err.Error() + req.String()
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
 	resp := api.UserTokenResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg},

internal/api/conversation/conversation.go

@@ -5,6 +5,7 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbConversation "Open_IM/pkg/proto/conversation"
 	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
@@ -44,6 +45,37 @@ func SetConversation(c *gin.Context) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
 	c.JSON(http.StatusOK, resp)
 }
+func ModifyConversationField(c *gin.Context) {
+	var (
+		req   api.ModifyConversationFieldReq
+		resp  api.ModifyConversationFieldResp
+		reqPb pbConversation.ModifyConversationFieldReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	reqPb.Conversation = &pbConversation.Conversation{}
+	err := utils.CopyStructFields(&reqPb, req)
+	err = utils.CopyStructFields(reqPb.Conversation, req.Conversation)
+	if err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", reqPb.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName)
+	client := pbConversation.NewConversationClient(etcdConn)
+	respPb, err := client.ModifyConversationField(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		return
+	}
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
 
 func BatchSetConversations(c *gin.Context) {
 	var (

internal/api/office/work_moments.go

@@ -201,8 +201,7 @@ func GetWorkMomentByID(c *gin.Context) {
 	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	//resp.Data.WorkMoment = respPb.WorkMoment
+	resp.Data.WorkMoment = &apiStruct.WorkMoment{LikeUserList: []*apiStruct.WorkMomentUser{}, Comments: []*apiStruct.Comment{}, AtUserList: []*apiStruct.WorkMomentUser{}}
-	resp.Data.WorkMoment = &apiStruct.WorkMoment{}
 	if err := utils.CopyStructFields(&resp.Data.WorkMoment, respPb.WorkMoment); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
@@ -223,7 +222,7 @@ func GetUserWorkMoments(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	ok, 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"})
@@ -234,7 +233,8 @@ func GetUserWorkMoments(c *gin.Context) {
 		PageNumber: req.PageNumber,
 		ShowNumber: req.ShowNumber,
 	}
-	reqPb.UserID = userID
+	reqPb.OpUserID = opUserID
+	reqPb.UserID = req.UserID
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
 	client := pbOffice.NewOfficeServiceClient(etcdConn)
 	respPb, err := client.GetUserWorkMoments(context.Background(), &reqPb)
@@ -243,11 +243,49 @@ func GetUserWorkMoments(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserWorkMoments rpc server failed" + err.Error()})
 		return
 	}
+	resp.Data.WorkMoments = []*apiStruct.WorkMoment{}
 	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	if err := utils.CopyStructFields(&resp.Data.WorkMoments, respPb.WorkMoments); err != nil {
+	//if err := utils.CopyStructFields(&resp.Data.WorkMoments, respPb.WorkMoments); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	//	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	//}
+	for _, v := range respPb.WorkMoments {
+		workMoment := apiStruct.WorkMoment{
+			WorkMomentID: v.WorkMomentID,
+			UserID:       v.UserID,
+			Content:      v.Content,
+			FaceURL:      v.FaceURL,
+			UserName:     v.UserName,
+			CreateTime:   v.CreateTime,
+			Comments:     make([]*apiStruct.Comment, len(v.Comments)),
+			LikeUserList: make([]*apiStruct.WorkMomentUser, len(v.LikeUserList)),
+			AtUserList:   make([]*apiStruct.WorkMomentUser, len(v.AtUserList)),
+		}
+		for i, comment := range v.Comments {
+			workMoment.Comments[i] = &apiStruct.Comment{
+				UserID:        comment.UserID,
+				UserName:      comment.UserName,
+				ReplyUserID:   comment.ReplyUserID,
+				ReplyUserName: comment.ReplyUserID,
+				ContentID:     comment.ContentID,
+				Content:       comment.Content,
+				CreateTime:    comment.CreateTime,
+			}
+		}
+		for i, likeUser := range v.LikeUserList {
+			workMoment.LikeUserList[i] = &apiStruct.WorkMomentUser{
+				UserID:   likeUser.UserID,
+				UserName: likeUser.UserName,
+			}
+		}
+		for i, atUser := range v.AtUserList {
+			workMoment.AtUserList[i] = &apiStruct.WorkMomentUser{
+				UserID:   atUser.UserID,
+				UserName: atUser.UserName,
+			}
+		}
+		resp.Data.WorkMoments = append(resp.Data.WorkMoments, &workMoment)
 	}
 	resp.Data.ShowNumber = respPb.Pagination.ShowNumber
 	resp.Data.CurrentPage = respPb.Pagination.CurrentPage
@@ -291,8 +329,46 @@ func GetUserFriendWorkMoments(c *gin.Context) {
 	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	if err := utils.CopyStructFields(&resp.Data.WorkMoments, respPb.WorkMoments); err != nil {
+	//if err := utils.CopyStructFields(&resp.Data.WorkMoments, respPb.WorkMoments); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	//	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	//}
+	resp.Data.WorkMoments = []*apiStruct.WorkMoment{}
+	for _, v := range respPb.WorkMoments {
+		workMoment := apiStruct.WorkMoment{
+			WorkMomentID: v.WorkMomentID,
+			UserID:       v.UserID,
+			Content:      v.Content,
+			FaceURL:      v.FaceURL,
+			UserName:     v.UserName,
+			CreateTime:   v.CreateTime,
+			Comments:     make([]*apiStruct.Comment, len(v.Comments)),
+			LikeUserList: make([]*apiStruct.WorkMomentUser, len(v.LikeUserList)),
+			AtUserList:   make([]*apiStruct.WorkMomentUser, len(v.AtUserList)),
+		}
+		for i, comment := range v.Comments {
+			workMoment.Comments[i] = &apiStruct.Comment{
+				UserID:        comment.UserID,
+				UserName:      comment.UserName,
+				ReplyUserID:   comment.ReplyUserID,
+				ReplyUserName: comment.ReplyUserID,
+				ContentID:     comment.ContentID,
+				Content:       comment.Content,
+				CreateTime:    comment.CreateTime,
+			}
+		}
+		for i, likeUser := range v.LikeUserList {
+			workMoment.LikeUserList[i] = &apiStruct.WorkMomentUser{
+				UserID:   likeUser.UserID,
+				UserName: likeUser.UserName,
+			}
+		}
+		for i, atUser := range v.AtUserList {
+			workMoment.AtUserList[i] = &apiStruct.WorkMomentUser{
+				UserID:   atUser.UserID,
+				UserName: atUser.UserName,
+			}
+		}
+		resp.Data.WorkMoments = append(resp.Data.WorkMoments, &workMoment)
 	}
 	resp.Data.ShowNumber = respPb.Pagination.ShowNumber
 	resp.Data.CurrentPage = respPb.Pagination.CurrentPage

internal/api/third/minio_init.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"github.com/minio/minio-go/v7"
 	"github.com/minio/minio-go/v7/pkg/credentials"
+	"github.com/minio/minio-go/v7/pkg/policy"
 	url2 "net/url"
 )
 
@@ -58,10 +59,10 @@ func MinioInit() {
 		}
 	}
 	// 自动化桶public的代码
-	//err = minioClient.SetBucketPolicy(context.Background(), config.Config.Credential.Minio.Bucket, policy.BucketPolicyReadWrite)
+	err = minioClient.SetBucketPolicy(context.Background(), config.Config.Credential.Minio.Bucket, policy.BucketPolicyReadWrite)
-	//if err != nil {
+	if err != nil {
-	//	log.NewError("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
+		log.NewDebug("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
-	//	return
+		return
-	//}
+	}
 	log.NewInfo(operationID, utils.GetSelfFuncName(), "minio create and set policy success")
 }

internal/api/user/user.go

@@ -18,6 +18,156 @@ import (
 	"strings"
 )
 
+//func GetUsersInfoFromCache(c *gin.Context) {
+//	params := api.GetUsersInfoReq{}
+//	if err := c.BindJSON(&params); err != nil {
+//		log.NewError("0", "BindJSON failed ", err.Error())
+//		c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
+//		return
+//	}
+//	getUserInfoReq := &rpc.GetUserInfoReq{}
+//	getUserInfoReq.OperationID = params.OperationID
+//	var ok bool
+//	ok, getUserInfoReq.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), getUserInfoReq.OperationID)
+//	if !ok {
+//		log.NewError(getUserInfoReq.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+//		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+//		return
+//	}
+//	log.NewInfo(params.OperationID, "GetUserInfo args ", getUserInfoReq.String())
+//	reqCacheGetUserInfo := &cacheRpc.GetUserInfoReq{}
+//	utils.CopyStructFields(reqCacheGetUserInfo, &params)
+//	var userInfoList []*open_im_sdk.UserInfo
+//	var publicUserInfoList []*open_im_sdk.PublicUserInfo
+//	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+//	cacheClient := cacheRpc.NewCacheClient(etcdConn)
+//	cacheResp, err := cacheClient.GetUserInfo(context.Background(), reqCacheGetUserInfo)
+//	if err != nil {
+//		log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", err.Error())
+//		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed: " + err.Error()})
+//		return
+//	}
+//	if cacheResp.CommonResp.ErrCode != 0 {
+//		log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", cacheResp.CommonResp)
+//		resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}}
+//		resp.Data = []map[string]interface{}{}
+//		log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp)
+//		c.JSON(http.StatusOK, resp)
+//		return
+//	}
+//	log.NewInfo(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "cacheResp:", cacheResp.String())
+//	userInfoList = cacheResp.UserInfoList
+//	var needCacheUserIDList []string
+//	for _, userID := range reqCacheGetUserInfo.UserIDList {
+//		isGetUserInfoFromCache := false
+//		for _, cacheUser := range userInfoList {
+//			if cacheUser.UserID == userID {
+//				isGetUserInfoFromCache = true
+//			}
+//		}
+//		if !isGetUserInfoFromCache {
+//			needCacheUserIDList = append(needCacheUserIDList, userID)
+//		}
+//	}
+//	if len(needCacheUserIDList) == 0 {
+//		log.NewInfo(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "get all userInfo from cache success")
+//		for _, v := range userInfoList {
+//			publicUserInfoList = append(publicUserInfoList,
+//				&open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex})
+//		}
+//		resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList}
+//		resp.Data = jsonData.JsonDataList(resp.UserInfoList)
+//		log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp)
+//		c.JSON(http.StatusOK, resp)
+//		return
+//	}
+//
+//	log.NewDebug(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "need cache user list", needCacheUserIDList)
+//	getUserInfoReq.UserIDList = needCacheUserIDList
+//	etcdConn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+//	client := rpc.NewUserClient(etcdConn)
+//	rpcResp, err := client.GetUserInfo(context.Background(), getUserInfoReq)
+//	if err != nil {
+//		log.NewError(getUserInfoReq.OperationID, "GetUserInfo failed ", err.Error(), getUserInfoReq.String())
+//		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed" + err.Error()})
+//		return
+//	}
+//	if rpcResp.CommonResp.ErrCode != 0 {
+//		log.NewError(getUserInfoReq.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed", cacheResp.CommonResp)
+//		resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}}
+//		resp.Data = []map[string]interface{}{}
+//		log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp)
+//		c.JSON(http.StatusOK, resp)
+//		return
+//	}
+//	userInfoList = append(userInfoList, rpcResp.UserInfoList...)
+//	cacheUpdateUserInfoReq := &cacheRpc.UpdateUserInfoReq{
+//		UserInfoList: rpcResp.UserInfoList,
+//		OperationID:  getUserInfoReq.OperationID,
+//	}
+//	_, err = cacheClient.UpdateUserInfo(context.Background(), cacheUpdateUserInfoReq)
+//	if err != nil {
+//		log.NewError(getUserInfoReq.OperationID, "GetUserInfo failed ", err.Error())
+//		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed:" + err.Error()})
+//		return
+//	}
+//	userInfoList = rpcResp.UserInfoList
+//	for _, v := range userInfoList {
+//		publicUserInfoList = append(publicUserInfoList,
+//			&open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex})
+//	}
+//	resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: rpcResp.CommonResp.ErrCode, ErrMsg: rpcResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList}
+//	resp.Data = jsonData.JsonDataList(resp.UserInfoList)
+//	log.NewInfo(getUserInfoReq.OperationID, "GetUserInfo api return ", resp)
+//	c.JSON(http.StatusOK, resp)
+//}
+
+func GetUsersInfoFromCache(c *gin.Context) {
+	params := api.GetUsersInfoReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetUserInfoReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "GetUserInfo args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := rpc.NewUserClient(etcdConn)
+	RpcResp, err := client.GetUserInfo(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, "GetUserInfo failed ", err.Error(), req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	var publicUserInfoList []*open_im_sdk.PublicUserInfo
+	for _, v := range RpcResp.UserInfoList {
+		publicUserInfoList = append(publicUserInfoList,
+			&open_im_sdk.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex})
+	}
+
+	resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList}
+	resp.Data = jsonData.JsonDataList(resp.UserInfoList)
+	log.NewInfo(req.OperationID, "GetUserInfo api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetUserFriendFromCache(c *gin.Context) {
+
+}
+
+func GetBlackListFromCache(c *gin.Context) {
+
+}
+
 func GetUsersInfo(c *gin.Context) {
 	params := api.GetUsersInfoReq{}
 	if err := c.BindJSON(&params); err != nil {

internal/cms_api/router.go

@@ -15,7 +15,7 @@ import (
 func NewGinRouter() *gin.Engine {
 	gin.SetMode(gin.ReleaseMode)
 	baseRouter := gin.Default()
-	router := baseRouter.Group("/api")
+	router := baseRouter.Group("/cms")
 	router.Use(middleware.CorsHandler())
 	adminRouterGroup := router.Group("/admin")
 	{

internal/demo/register/login.go

@@ -42,11 +42,11 @@ func Login(c *gin.Context) {
 		return
 	}
 	if r.Password != params.Password {
-		log.NewError(params.OperationID, "password err", params.Password, account, r.Password, r.Account)
+		log.NewError(params.OperationID, "password  err", params.Password, account, r.Password, r.Account)
 		c.JSON(http.StatusOK, gin.H{"errCode": constant.PasswordErr, "errMsg": "password err"})
 		return
 	}
-	url := fmt.Sprintf("http://%s:10000/auth/user_token", utils.ServerIP)
+	url := fmt.Sprintf("http://%s:%d/auth/user_token", utils.ServerIP, config.Config.Api.GinPort[0])
 	openIMGetUserToken := api.UserTokenReq{}
 	openIMGetUserToken.OperationID = params.OperationID
 	openIMGetUserToken.Platform = params.Platform

internal/msg_gateway/gate/ws_server.go

@@ -54,7 +54,7 @@ func (ws *WServer) wsHandler(w http.ResponseWriter, r *http.Request) {
 		query := r.URL.Query()
 		conn, err := ws.wsUpGrader.Upgrade(w, r, nil) //Conn is obtained through the upgraded escalator
 		if err != nil {
-			log.ErrorByKv("upgrade http conn err", "", "err", err)
+			log.ErrorByKv("upgrade http conn err", "", "err", err, query)
 			return
 		} else {
 			//Connection mapping relationship,
@@ -196,6 +196,7 @@ func (ws *WServer) addUserConn(uid string, platformID int32, conn *UserConn, tok
 func (ws *WServer) delUserConn(conn *UserConn) {
 	rwLock.Lock()
 	defer rwLock.Unlock()
+	operationID := utils.OperationIDGenerator()
 	var platform, uid string
 	if oldStringMap, ok := ws.wsConnToUser[conn]; ok {
 		for k, v := range oldStringMap {
@@ -212,9 +213,9 @@ func (ws *WServer) delUserConn(conn *UserConn) {
 			for _, v := range ws.wsUserToConn {
 				count = count + len(v)
 			}
-			log.WarnByKv("WS delete operation", "", "wsUser deleted", ws.wsUserToConn, "disconnection_uid", uid, "disconnection_platform", platform, "online_user_num", len(ws.wsUserToConn), "online_conn_num", count)
+			log.NewWarn(operationID, "WS delete operation", "", "wsUser deleted", ws.wsUserToConn, "disconnection_uid", uid, "disconnection_platform", platform, "online_user_num", len(ws.wsUserToConn), "online_conn_num", count)
 		} else {
-			log.WarnByKv("WS delete operation", "", "wsUser deleted", ws.wsUserToConn, "disconnection_uid", uid, "disconnection_platform", platform, "online_user_num", len(ws.wsUserToConn))
+			log.NewWarn(operationID, "WS delete operation", "", "wsUser deleted", ws.wsUserToConn, "disconnection_uid", uid, "disconnection_platform", platform, "online_user_num", len(ws.wsUserToConn))
 		}
 		userCount = uint64(len(ws.wsUserToConn))
 		delete(ws.wsConnToUser, conn)
@@ -222,8 +223,7 @@ func (ws *WServer) delUserConn(conn *UserConn) {
 	}
 	err := conn.Close()
 	if err != nil {
-		log.ErrorByKv("close err", "", "uid", uid, "platform", platform)
+		log.Error(operationID, " close err", "", "uid", uid, "platform", platform)
-
 	}
 
 }
@@ -267,7 +267,7 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request) bool {
 		operationID = query["operationID"][0]
 	}
 	if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 {
-		if ok, err, msg := token_verify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0]); !ok {
+		if ok, err, msg := token_verify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0], operationID); !ok {
 			//	e := err.(*constant.ErrInfo)
 			log.Error(operationID, "Token verify failed ", "query ", query, msg, err.Error())
 			w.Header().Set("Sec-Websocket-Version", "13")
@@ -281,7 +281,7 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request) bool {
 	} else {
 		log.Error(operationID, "Args err", "query", query)
 		w.Header().Set("Sec-Websocket-Version", "13")
-		w.Header().Set("ws_err_msg", "args err")
+		w.Header().Set("ws_err_msg", "args err, need token, sendID, platformID")
 		http.Error(w, http.StatusText(status), status)
 		return false
 	}

internal/rpc/auth/auth.go

@@ -20,38 +20,41 @@ import (
 )
 
 func (rpc *rpcAuth) UserRegister(_ context.Context, req *pbAuth.UserRegisterReq) (*pbAuth.UserRegisterResp, error) {
-	log.NewInfo(req.OperationID, "UserRegister args ", req.String())
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
 	var user db.User
 	utils.CopyStructFields(&user, req.UserInfo)
 	if req.UserInfo.Birth != 0 {
 		user.Birth = utils.UnixSecondToTime(int64(req.UserInfo.Birth))
 	}
+	log.Debug(req.OperationID, "copy ", user, req.UserInfo)
 	err := imdb.UserRegister(user)
 	if err != nil {
-		log.NewError(req.OperationID, "UserRegister failed ", err.Error(), user)
+		errMsg := req.OperationID + " imdb.UserRegister failed " + err.Error() + user.UserID
-		return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		log.NewError(req.OperationID, errMsg, user)
+		return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
 	}
 
-	log.NewInfo(req.OperationID, "rpc UserRegister return")
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{}})
 	return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{}}, nil
 }
 
 func (rpc *rpcAuth) UserToken(_ context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
-	log.NewInfo(req.OperationID, "UserToken args ", req.String())
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
-
 	_, err := imdb.GetUserByUserID(req.FromUserID)
 	if err != nil {
-		log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.FromUserID)
+		errMsg := req.OperationID + " imdb.GetUserByUserID failed " + err.Error() + req.FromUserID
-		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		log.NewError(req.OperationID, errMsg)
+		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
 	}
 
 	tokens, expTime, err := token_verify.CreateToken(req.FromUserID, req.Platform)
 	if err != nil {
-		log.NewError(req.OperationID, "CreateToken failed ", err.Error(), req.FromUserID, req.Platform)
+		errMsg := req.OperationID + " token_verify.CreateToken failed " + err.Error() + req.FromUserID + utils.Int32ToString(req.Platform)
-		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		log.NewError(req.OperationID, errMsg)
+		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}}, nil
 	}
 
-	log.NewInfo(req.OperationID, "rpc UserToken return ", tokens, expTime)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{}, Token: tokens, ExpiredTime: expTime})
 	return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{}, Token: tokens, ExpiredTime: expTime}, nil
 }
 
@@ -73,15 +76,16 @@ func NewRpcAuthServer(port int) *rpcAuth {
 }
 
 func (rpc *rpcAuth) Run() {
-	log.NewInfo("0", "rpc auth start...")
+	operationID := utils.OperationIDGenerator()
+	log.NewInfo(operationID, "rpc auth start...")
 
 	address := utils.ServerIP + ":" + strconv.Itoa(rpc.rpcPort)
 	listener, err := net.Listen("tcp", address)
 	if err != nil {
-		log.NewError("0", "listen network failed ", err.Error(), address)
+		log.NewError(operationID, "listen network failed ", err.Error(), address)
 		return
 	}
-	log.NewInfo("0", "listen network success, ", address, listener)
+	log.NewInfo(operationID, "listen network success, ", address, listener)
 	//grpc server
 	srv := grpc.NewServer()
 	defer srv.GracefulStop()
@@ -90,15 +94,15 @@ func (rpc *rpcAuth) Run() {
 	pbAuth.RegisterAuthServer(srv, rpc)
 	err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName, 10)
 	if err != nil {
-		log.NewError("0", "RegisterEtcd failed ", err.Error(),
+		log.NewError(operationID, "RegisterEtcd failed ", err.Error(),
 			rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
 		return
 	}
-	log.NewInfo("0", "RegisterAuthServer ok ", rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
+	log.NewInfo(operationID, "RegisterAuthServer ok ", rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
 	err = srv.Serve(listener)
 	if err != nil {
-		log.NewError("0", "Serve failed ", err.Error())
+		log.NewError(operationID, "Serve failed ", err.Error())
 		return
 	}
-	log.NewInfo("0", "rpc auth ok")
+	log.NewInfo(operationID, "rpc auth ok")
 }

internal/rpc/cache/cache.go

@@ -0,0 +1,118 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbCache "Open_IM/pkg/proto/cache"
+	commonPb "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"google.golang.org/grpc"
+	"net"
+	"strconv"
+	"strings"
+)
+
+type cacheServer struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func NewCacheServer(port int) *cacheServer {
+	log.NewPrivateLog(constant.LogFileName)
+	return &cacheServer{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImCacheName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (s *cacheServer) Run() {
+	log.NewInfo("0", "cacheServer 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()
+	pbCache.RegisterCacheServer(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 *cacheServer) GetUserInfo(_ context.Context, req *pbCache.GetUserInfoReq) (resp *pbCache.GetUserInfoResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.GetUserInfoResp{
+		UserInfoList: []*commonPb.UserInfo{},
+		CommonResp:   &pbCache.CommonResp{},
+	}
+	for _, userID := range req.UserIDList {
+		userInfo, err := db.DB.GetUserInfo(userID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "get userInfo from cache failed", err.Error())
+			continue
+		}
+		resp.UserInfoList = append(resp.UserInfoList, userInfo)
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) UpdateUserInfo(_ context.Context, req *pbCache.UpdateUserInfoReq) (resp *pbCache.UpdateUserInfoResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.UpdateUserInfoResp{
+		CommonResp: &pbCache.CommonResp{},
+	}
+	for _, userInfo := range req.UserInfoList {
+		if err := db.DB.SetUserInfo(userInfo); err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "set userInfo to cache failed", err.Error())
+			return resp, nil
+		}
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) GetBlackList(_ context.Context, req *pbCache.GetBlackListReq) (resp *pbCache.GetBlackListResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	return nil, nil
+}
+
+func (s *cacheServer) UpdateBlackList(_ context.Context, req *pbCache.UpdateBlackListReq) (resp *pbCache.UpdateBlackListResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	return nil, nil
+}
+
+func (s *cacheServer) GetFriendInfo(_ context.Context, req *pbCache.GetFriendInfoReq) (resp *pbCache.GetFriendInfoResp, err error) {
+	return nil, nil
+}
+
+func (s *cacheServer) UpdateFriendInfo(_ context.Context, req *pbCache.UpdateFriendInfoReq) (resp *pbCache.UpdateFriendInfoResp, err error) {
+	return nil, nil
+}

internal/rpc/conversation/conversaion.go

@@ -0,0 +1,167 @@
+package conversation
+
+import (
+	chat "Open_IM/internal/rpc/msg"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbConversation "Open_IM/pkg/proto/conversation"
+	"Open_IM/pkg/utils"
+	"context"
+	"net"
+	"strconv"
+	"strings"
+
+	"Open_IM/pkg/common/config"
+
+	"google.golang.org/grpc"
+)
+
+type rpcConversation struct {
+	rpcPort         int
+	rpcRegisterName string
+	etcdSchema      string
+	etcdAddr        []string
+}
+
+func (rpc *rpcConversation) ModifyConversationField(c context.Context, req *pbConversation.ModifyConversationFieldReq) (*pbConversation.ModifyConversationFieldResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbConversation.ModifyConversationFieldResp{}
+	var err error
+	if req.Conversation.ConversationType == constant.GroupChatType {
+		groupInfo, err := imdb.GetGroupInfoByGroupID(req.Conversation.GroupID)
+		if err != nil {
+			log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.Conversation.GroupID, err.Error())
+			resp.CommonResp = &pbConversation.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+			return resp, nil
+		}
+		if groupInfo.Status == constant.GroupStatusDismissed && !req.Conversation.IsNotInGroup {
+			errMsg := "group status is dismissed"
+			resp.CommonResp = &pbConversation.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}
+			return resp, nil
+		}
+	}
+	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())
+	}
+	haveUserID, _ := imdb.GetExistConversationUserIDList(req.UserIDList, req.Conversation.ConversationID)
+	switch req.FieldType {
+	case constant.FieldRecvMsgOpt:
+		for _, v := range req.UserIDList {
+			if err = db.DB.SetSingleConversationRecvMsgOpt(v, req.Conversation.ConversationID, req.Conversation.RecvMsgOpt); err != nil {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "cache failed, rpc return", err.Error())
+				resp.CommonResp = &pbConversation.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+				return resp, nil
+			}
+		}
+		err = imdb.UpdateColumnsConversations(haveUserID, req.Conversation.ConversationID, map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt})
+	case constant.FieldGroupAtType:
+		err = imdb.UpdateColumnsConversations(haveUserID, req.Conversation.ConversationID, map[string]interface{}{"group_at_type": conversation.GroupAtType})
+	case constant.FieldIsNotInGroup:
+		err = imdb.UpdateColumnsConversations(haveUserID, req.Conversation.ConversationID, map[string]interface{}{"is_not_in_group": conversation.IsNotInGroup})
+	case constant.FieldIsPinned:
+		err = imdb.UpdateColumnsConversations(haveUserID, req.Conversation.ConversationID, map[string]interface{}{"is_pinned": conversation.IsPinned})
+	case constant.FieldIsPrivateChat:
+		err = imdb.UpdateColumnsConversations(haveUserID, req.Conversation.ConversationID, map[string]interface{}{"is_private_chat": conversation.IsPrivateChat})
+	case constant.FieldEx:
+		err = imdb.UpdateColumnsConversations(haveUserID, req.Conversation.ConversationID, map[string]interface{}{"ex": conversation.Ex})
+	case constant.FieldAttachedInfo:
+		err = imdb.UpdateColumnsConversations(haveUserID, req.Conversation.ConversationID, map[string]interface{}{"attached_info": conversation.AttachedInfo})
+	}
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "UpdateColumnsConversations error", err.Error())
+		resp.CommonResp = &pbConversation.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	for _, v := range utils.DifferenceString(haveUserID, req.UserIDList) {
+		conversation.OwnerUserID = v
+		err := imdb.SetOneConversation(conversation)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
+			resp.CommonResp = &pbConversation.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+			return resp, nil
+		}
+	}
+	// notification
+	if req.Conversation.ConversationType == constant.SingleChatType && req.FieldType == constant.FieldIsPrivateChat {
+		//sync peer user conversation if conversation is singleChatType
+		if err := syncPeerUserConversation(req.Conversation, req.OperationID); err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "syncPeerUserConversation", err.Error())
+			resp.CommonResp = &pbConversation.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+			return resp, nil
+		}
+	} else {
+		for _, v := range req.UserIDList {
+			chat.ConversationChangeNotification(req.OperationID, v)
+		}
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
+	resp.CommonResp = &pbConversation.CommonResp{}
+	return resp, nil
+}
+func syncPeerUserConversation(conversation *pbConversation.Conversation, operationID string) error {
+	peerUserConversation := db.Conversation{
+		OwnerUserID:      conversation.UserID,
+		ConversationID:   utils.GetConversationIDBySessionType(conversation.OwnerUserID, constant.SingleChatType),
+		ConversationType: constant.SingleChatType,
+		UserID:           conversation.OwnerUserID,
+		GroupID:          "",
+		RecvMsgOpt:       0,
+		UnreadCount:      0,
+		DraftTextTime:    0,
+		IsPinned:         false,
+		IsPrivateChat:    conversation.IsPrivateChat,
+		AttachedInfo:     "",
+		Ex:               "",
+	}
+	err := imdb.PeerUserSetConversation(peerUserConversation)
+	if err != nil {
+		log.NewError(operationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
+		return err
+	}
+	chat.ConversationSetPrivateNotification(operationID, conversation.OwnerUserID, conversation.UserID, conversation.IsPrivateChat)
+	return nil
+}
+func NewRpcConversationServer(port int) *rpcConversation {
+	log.NewPrivateLog(constant.LogFileName)
+	return &rpcConversation{
+		rpcPort:         port,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImConversationName,
+		etcdSchema:      config.Config.Etcd.EtcdSchema,
+		etcdAddr:        config.Config.Etcd.EtcdAddr,
+	}
+}
+
+func (rpc *rpcConversation) Run() {
+	log.NewInfo("0", "rpc conversation start...")
+
+	address := utils.ServerIP + ":" + strconv.Itoa(rpc.rpcPort)
+	listener, err := net.Listen("tcp", address)
+	if err != nil {
+		log.NewError("0", "listen network failed ", err.Error(), address)
+		return
+	}
+	log.NewInfo("0", "listen network success, ", address, listener)
+	//grpc server
+	srv := grpc.NewServer()
+	defer srv.GracefulStop()
+
+	//service registers with etcd
+	pbConversation.RegisterConversationServer(srv, rpc)
+	err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName, 10)
+	if err != nil {
+		log.NewError("0", "RegisterEtcd failed ", err.Error(),
+			rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
+		return
+	}
+	log.NewInfo("0", "RegisterConversationServer ok ", rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), utils.ServerIP, rpc.rpcPort, rpc.rpcRegisterName)
+	err = srv.Serve(listener)
+	if err != nil {
+		log.NewError("0", "Serve failed ", err.Error())
+		return
+	}
+	log.NewInfo("0", "rpc conversation ok")
+}

internal/rpc/msg/send_msg.go

@@ -7,6 +7,7 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbChat "Open_IM/pkg/proto/chat"
+	pbConversation "Open_IM/pkg/proto/conversation"
 	rpc "Open_IM/pkg/proto/friend"
 	pbGroup "Open_IM/pkg/proto/group"
 	sdk_ws "Open_IM/pkg/proto/sdk_ws"
@@ -227,6 +228,12 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 			log.Error(pb.Token, pb.OperationID, "rpc send_msg getGroupInfo failed, err = %s", reply.ErrMsg)
 			return returnMsg(&replay, pb, reply.ErrCode, reply.ErrMsg, "", 0)
 		}
+		memberUserIDList := func(all []*sdk_ws.GroupMemberFullInfo) (result []string) {
+			for _, v := range all {
+				result = append(result, v.UserID)
+			}
+			return result
+		}(reply.MemberList)
 		var addUidList []string
 		switch pb.MsgData.ContentType {
 		case constant.MemberKickedNotification:
@@ -247,31 +254,66 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 		case constant.MemberQuitNotification:
 			addUidList = append(addUidList, pb.MsgData.SendID)
 		case constant.AtText:
-			//tagMe := utils.IsContain(c.loginUserID, s.AtElem.AtUserList)
+			go func() {
-			//tagAll := utils.IsContain(constant.AtAllString, pb.MsgData.AtUserIDList)
+				var conversationReq pbConversation.ModifyConversationFieldReq
-			//if tagAll {
+				var tag bool
-			//	if tagMe {
+				var atUserID []string
-			//		lc.GroupAtType = constant.AtAllAtMe
+				conversation := pbConversation.Conversation{
-			//		return
+					OwnerUserID:      pb.MsgData.SendID,
-			//	}
+					ConversationID:   utils.GetConversationIDBySessionType(pb.MsgData.GroupID, constant.GroupChatType),
-			//	lc.GroupAtType = constant.AtAll
+					ConversationType: constant.GroupChatType,
-			//	return
+					GroupID:          pb.MsgData.GroupID,
-			//}
+				}
-			//if tagMe {
+				conversationReq.Conversation = &conversation
-			//	lc.GroupAtType = constant.AtMe
+				conversationReq.OperationID = pb.OperationID
-			//}
+				conversationReq.FieldType = constant.FieldGroupAtType
-
+				tagAll := utils.IsContain(constant.AtAllString, pb.MsgData.AtUserIDList)
+				if tagAll {
+					atUserID = utils.DifferenceString([]string{constant.AtAllString}, pb.MsgData.AtUserIDList)
+					if len(atUserID) == 0 { //just @everyone
+						conversationReq.UserIDList = memberUserIDList
+						conversation.GroupAtType = constant.AtAll
+					} else { //@Everyone and @other people
+						conversationReq.UserIDList = atUserID
+						conversation.GroupAtType = constant.AtAllAtMe
+						tag = true
+					}
+				} else {
+					conversationReq.UserIDList = pb.MsgData.AtUserIDList
+					conversation.GroupAtType = constant.AtMe
+				}
+				etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName)
+				client := pbConversation.NewConversationClient(etcdConn)
+				conversationReply, err := client.ModifyConversationField(context.Background(), &conversationReq)
+				if err != nil {
+					log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), err.Error())
+				} else if conversationReply.CommonResp.ErrCode != 0 {
+					log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), conversationReply.String())
+				}
+				if tag {
+					conversationReq.UserIDList = utils.DifferenceString(atUserID, memberUserIDList)
+					conversation.GroupAtType = constant.AtAll
+					etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName)
+					client := pbConversation.NewConversationClient(etcdConn)
+					conversationReply, err := client.ModifyConversationField(context.Background(), &conversationReq)
+					if err != nil {
+						log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), err.Error())
+					} else if conversationReply.CommonResp.ErrCode != 0 {
+						log.NewError(conversationReq.OperationID, "ModifyConversationField rpc failed, ", conversationReq.String(), conversationReply.String())
+					}
+				}
+			}()
 		default:
 		}
 		groupID := pb.MsgData.GroupID
-		for _, v := range reply.MemberList {
+		for _, v := range memberUserIDList {
-			pb.MsgData.RecvID = v.UserID
+			pb.MsgData.RecvID = v
-			isSend := modifyMessageByUserMessageReceiveOpt(v.UserID, groupID, constant.GroupChatType, pb)
+			isSend := modifyMessageByUserMessageReceiveOpt(v, groupID, constant.GroupChatType, pb)
 			if isSend {
 				msgToMQ.MsgData = pb.MsgData
-				err := rpc.sendMsgToKafka(&msgToMQ, v.UserID)
+				err := rpc.sendMsgToKafka(&msgToMQ, v)
 				if err != nil {
-					log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v.UserID, msgToMQ.String())
+					log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v, msgToMQ.String())
 					return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
 				}
 			}

internal/rpc/msg/work_moments_notification.go

@@ -10,12 +10,9 @@ import (
 	"github.com/golang/protobuf/proto"
 )
 
-func WorkMomentSendNotification(operationID, sendID, recvID string, notificationMsg *pbOffice.WorkMomentNotificationMsg) {
+func WorkMomentSendNotification(operationID, recvID string, notificationMsg *pbOffice.WorkMomentNotificationMsg) {
-	log.NewInfo(operationID, utils.GetSelfFuncName(), sendID, recvID, notificationMsg)
+	log.NewInfo(operationID, utils.GetSelfFuncName(), recvID, notificationMsg)
-	//if sendID == recvID {
+	WorkMomentNotification(operationID, recvID, recvID, notificationMsg)
-	//	return
-	//}
-	WorkMomentNotification(operationID, sendID, recvID, notificationMsg)
 }
 
 func WorkMomentNotification(operationID, sendID, recvID string, m proto.Message) {

internal/rpc/office/office.go

@@ -303,8 +303,9 @@ func (s *officeServer) CreateOneWorkMoment(_ context.Context, req *pbOffice.Crea
 			UserID:              workMoment.UserID,
 			FaceURL:             createUser.FaceURL,
 			UserName:            createUser.Nickname,
+			CreateTime:          workMoment.CreateTime,
 		}
-		msg.WorkMomentSendNotification(req.OperationID, workMoment.UserID, atUser.UserID, workMomentNotificationMsg)
+		msg.WorkMomentSendNotification(req.OperationID, atUser.UserID, workMomentNotificationMsg)
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
@@ -375,13 +376,13 @@ func isUserCanSeeWorkMoment(userID string, workMoment db.WorkMoment) bool {
 func (s *officeServer) LikeOneWorkMoment(_ context.Context, req *pbOffice.LikeOneWorkMomentReq) (resp *pbOffice.LikeOneWorkMomentResp, err error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
 	resp = &pbOffice.LikeOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
-	userName, err := imdb.GetUserNameByUserID(req.UserID)
+	user, err := imdb.GetUserByUserID(req.UserID)
 	if err != nil {
 		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID failed", err.Error())
 		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
 		return resp, nil
 	}
-	workMoment, like, err := db.DB.LikeOneWorkMoment(req.UserID, userName, req.WorkMomentID)
+	workMoment, like, err := db.DB.LikeOneWorkMoment(req.UserID, user.Nickname, req.WorkMomentID)
 	if err != nil {
 		log.NewError(req.OperationID, utils.GetSelfFuncName(), "LikeOneWorkMoment failed ", err.Error())
 		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
@@ -391,13 +392,14 @@ func (s *officeServer) LikeOneWorkMoment(_ context.Context, req *pbOffice.LikeOn
 		NotificationMsgType: constant.WorkMomentLikeNotification,
 		WorkMomentID:        workMoment.WorkMomentID,
 		WorkMomentContent:   workMoment.Content,
-		UserID:              workMoment.UserID,
+		UserID:              user.UserID,
-		FaceURL:             workMoment.FaceURL,
+		FaceURL:             user.FaceURL,
-		UserName:            workMoment.UserName,
+		UserName:            user.Nickname,
+		CreateTime:          int32(time.Now().Unix()),
 	}
 	// send notification
-	if like {
+	if like && workMoment.UserID != req.UserID {
-		msg.WorkMomentSendNotification(req.OperationID, req.UserID, workMoment.UserID, workMomentNotificationMsg)
+		msg.WorkMomentSendNotification(req.OperationID, workMoment.UserID, workMomentNotificationMsg)
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
@@ -442,20 +444,17 @@ func (s *officeServer) CommentOneWorkMoment(_ context.Context, req *pbOffice.Com
 		UserID:              workMoment.UserID,
 		FaceURL:             workMoment.FaceURL,
 		UserName:            workMoment.UserName,
-		Comment: &pbOffice.Comment{
+		ReplyUserID:         comment.ReplyUserID,
-			UserID:        comment.UserID,
+		ReplyUserName:       comment.ReplyUserName,
-			UserName:      comment.UserName,
+		ContentID:           comment.ContentID,
-			FaceURL:       commentUser.FaceURL,
+		Content:             comment.Content,
-			ReplyUserID:   comment.ReplyUserID,
+		CreateTime:          comment.CreateTime,
-			ReplyUserName: comment.ReplyUserName,
-			ContentID:     comment.ContentID,
-			Content:       comment.Content,
-			CreateTime:    comment.CreateTime,
-		},
 	}
-	msg.WorkMomentSendNotification(req.OperationID, req.UserID, workMoment.UserID, workMomentNotificationMsg)
+	if req.UserID != workMoment.UserID {
-	if req.ReplyUserID != "" {
+		msg.WorkMomentSendNotification(req.OperationID, workMoment.UserID, workMomentNotificationMsg)
-		msg.WorkMomentSendNotification(req.OperationID, req.UserID, req.ReplyUserID, workMomentNotificationMsg)
+	}
+	if req.ReplyUserID != "" && req.ReplyUserID != workMoment.UserID && req.ReplyUserID != req.UserID {
+		msg.WorkMomentSendNotification(req.OperationID, req.ReplyUserID, workMomentNotificationMsg)
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
@@ -488,17 +487,21 @@ func (s *officeServer) GetWorkMomentByID(_ context.Context, req *pbOffice.GetWor
 func (s *officeServer) GetUserWorkMoments(_ context.Context, req *pbOffice.GetUserWorkMomentsReq) (resp *pbOffice.GetUserWorkMomentsResp, err error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
 	resp = &pbOffice.GetUserWorkMomentsResp{CommonResp: &pbOffice.CommonResp{}, WorkMoments: []*pbOffice.WorkMoment{}}
-	//resp.WorkMoments = make([]*pbOffice.WorkMoment, 0)
+	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
-	workMoments, err := db.DB.GetUserWorkMoments(req.UserID, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	var workMoments []db.WorkMoment
+	if req.UserID == req.OpUserID {
+		workMoments, err = db.DB.GetUserSelfWorkMoments(req.UserID, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	} else {
+		workMoments, err = db.DB.GetUserWorkMoments(req.OpUserID, req.UserID, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	}
 	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err)
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserWorkMoments failed", err.Error())
 		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
 		return resp, nil
 	}
 	if err := utils.CopyStructFields(&resp.WorkMoments, workMoments); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
 }
@@ -506,14 +509,16 @@ func (s *officeServer) GetUserWorkMoments(_ context.Context, req *pbOffice.GetUs
 func (s *officeServer) GetUserFriendWorkMoments(_ context.Context, req *pbOffice.GetUserFriendWorkMomentsReq) (resp *pbOffice.GetUserFriendWorkMomentsResp, err error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
 	resp = &pbOffice.GetUserFriendWorkMomentsResp{CommonResp: &pbOffice.CommonResp{}, WorkMoments: []*pbOffice.WorkMoment{}}
-	//resp.WorkMoments = make([]*pbOffice.WorkMoment, 0)
+	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
 	friendIDList, err := imdb.GetFriendIDListByUserID(req.UserID)
 	if err != nil {
 		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListByUserID", err.Error())
 		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
 		return resp, nil
 	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "friendIDList: ", friendIDList)
+	for _, friendID := range friendIDList {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), friendID)
+	}
 	workMoments, err := db.DB.GetUserFriendWorkMoments(friendIDList, req.Pagination.ShowNumber, req.Pagination.PageNumber, req.UserID)
 	if err != nil {
 		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserFriendWorkMoments", err.Error())
@@ -523,7 +528,6 @@ func (s *officeServer) GetUserFriendWorkMoments(_ context.Context, req *pbOffice
 	if err := utils.CopyStructFields(&resp.WorkMoments, workMoments); err != nil {
 		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
 	}
-	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
 }

internal/rpc/user/user.go

@@ -389,6 +389,10 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 		log.Info(req.OperationID, "UserInfoUpdatedNotification ", req.UserInfo.UserID, v.FriendUser.UserID)
 		chat.UserInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID, v.FriendUser.UserID)
 	}
+
+	//etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
+	//client := pbFriend.NewFriendClient(etcdConn)
+
 	chat.UserInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID, req.OpUserID)
 	log.Info(req.OperationID, "UserInfoUpdatedNotification ", req.UserInfo.UserID, req.OpUserID)
 	return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil

pkg/base_info/conversation_api_struct.go

@@ -58,6 +58,15 @@ type SetConversationReq struct {
 type SetConversationResp struct {
 	CommResp
 }
+type ModifyConversationFieldReq struct {
+	Conversation
+	FieldType   int32    `json:"fieldType" binding:"required"`
+	UserIDList  []string `json:"userIDList" binding:"required"`
+	OperationID string   `json:"operationID" binding:"required"`
+}
+type ModifyConversationFieldResp struct {
+	CommResp
+}
 
 type BatchSetConversationsReq struct {
 	Conversations    []Conversation `json:"conversations" binding:"required"`

pkg/base_info/work_moments_struct.go

@@ -50,13 +50,10 @@ type WorkMoment struct {
 	Content      string            `json:"content"`
 	LikeUserList []*WorkMomentUser `json:"likeUsers"`
 	Comments     []*Comment        `json:"comments"`
-	FaceURL      string            `json:"faceUrl"`
+	FaceURL      string            `json:"faceURL"`
 	UserName     string            `json:"userName"`
-	//Permission            int32       `json:"permission"`
+	AtUserList   []*WorkMomentUser `json:"atUsers"`
-	//PermissionUserIDList  []string    `json:"permissionUserIDList"`
+	CreateTime   int32             `json:"createTime"`
-	//PermissionGroupIDList []string    `json:"permissionGroupIDList"`
-	AtUserList []*WorkMomentUser `json:"atUsers"`
-	CreateTime int32             `json:"createTime"`
 }
 
 type WorkMomentUser struct {
@@ -83,6 +80,7 @@ type GetWorkMomentByIDResp struct {
 
 type GetUserWorkMomentsReq struct {
 	WorkMomentsUserCommonReq
+	UserID string `json:"userID"`
 }
 
 type GetUserWorkMomentsResp struct {

pkg/common/config/config.go

@@ -118,6 +118,8 @@ type config struct {
 		OpenImAdminCMSName           string `yaml:"openImAdminCMSName"`
 		OpenImOfficeName             string `yaml:"openImOfficeName"`
 		OpenImOrganizationName       string `yaml:"openImOrganizationName"`
+		OpenImConversationName       string `yaml:"openImConversationName"`
+		OpenImCacheName              string `yaml:"openImCacheName"`
 	}
 	Etcd struct {
 		EtcdSchema string   `yaml:"etcdSchema"`

pkg/common/constant/constant.go

@@ -214,6 +214,16 @@ var ContentType2PushContent = map[int64]string{
 	Common:   "你收到一条新消息",
 }
 
+const (
+	FieldRecvMsgOpt    = 1
+	FieldIsPinned      = 2
+	FieldAttachedInfo  = 3
+	FieldIsPrivateChat = 4
+	FieldGroupAtType   = 5
+	FieldIsNotInGroup  = 6
+	FieldEx            = 7
+)
+
 const (
 	AppOrdinaryUsers = 1
 	AppAdmin         = 2

pkg/common/db/model.go

@@ -71,24 +71,14 @@ func init() {
 	opts := options.CreateIndexes().SetMaxTime(10 * time.Second)
 	dataBase := mongoClient.Database(config.Config.Mongo.DBDatabase)
 
-	cCommentMsgModels := []mongo.IndexModel{
-		{
-			Keys: bson.M{"create_time": -1, "user_id": -1},
-		},
-	}
-	result, err := dataBase.Collection(cCommentMsg).Indexes().CreateMany(context.Background(), cCommentMsgModels, opts)
-	if err != nil {
-		fmt.Println("mongodb create cCommentMsgModels failed", result, err.Error())
-	}
-
 	cSendLogModels := []mongo.IndexModel{
 		{
-			Keys: bson.M{"user_id": -1, "send_time": -1},
+			Keys: bson.M{"user_id": -1},
 		},
 	}
-	result, err = dataBase.Collection(cSendLog).Indexes().CreateMany(context.Background(), cSendLogModels, opts)
+	result, err := dataBase.Collection(cSendLog).Indexes().CreateMany(context.Background(), cSendLogModels, opts)
 	if err != nil {
-		fmt.Println("mongodb create cSendLogModels failed", result, err.Error())
+		//fmt.Println("mongodb create cSendLogModels failed", result, err.Error())
 	}
 
 	cChatModels := []mongo.IndexModel{
@@ -106,12 +96,12 @@ func init() {
 			Keys: bson.M{"work_moment_id": -1},
 		},
 		{
-			Keys: bson.M{"user_id": -1, "create_time": -1},
+			Keys: bson.M{"user_id": -1},
 		},
 	}
 	result, err = dataBase.Collection(cWorkMoment).Indexes().CreateMany(context.Background(), cWorkMomentModels, opts)
 	if err != nil {
-		fmt.Println("mongodb create cWorkMomentModels failed", result, err.Error())
+		//fmt.Println("mongodb create cWorkMomentModels failed", result, err.Error())
 	}
 
 	cTagModels := []mongo.IndexModel{
@@ -119,12 +109,12 @@ func init() {
 			Keys: bson.M{"tag_id": -1},
 		},
 		{
-			Keys: bson.M{"user_id": -1, "tag_id": -1},
+			Keys: bson.M{"user_id": -1},
 		},
 	}
 	result, err = dataBase.Collection(cTag).Indexes().CreateMany(context.Background(), cTagModels, opts)
 	if err != nil {
-		fmt.Println("mongodb create cTagModels failed", result, err.Error())
+		//fmt.Println("mongodb create cTagModels failed", result, err.Error())
 	}
 	DB.mongoClient = mongoClient
 

pkg/common/db/mongoModel.go

@@ -16,7 +16,7 @@ import (
 
 	//"github.com/garyburd/redigo/redis"
 	"github.com/golang/protobuf/proto"
-	"gopkg.in/mgo.v2/bson"
+	"go.mongodb.org/mongo-driver/bson"
 
 	"strconv"
 	"time"
@@ -659,7 +659,7 @@ func (d *DataBases) CommentOneWorkMoment(comment *Comment, workMomentID string)
 	return workMoment, err
 }
 
-func (d *DataBases) GetUserWorkMoments(userID string, showNumber, pageNumber int32) ([]WorkMoment, error) {
+func (d *DataBases) GetUserSelfWorkMoments(userID string, showNumber, pageNumber int32) ([]WorkMoment, error) {
 	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
 	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cWorkMoment)
 	var workMomentList []WorkMoment
@@ -672,15 +672,43 @@ func (d *DataBases) GetUserWorkMoments(userID string, showNumber, pageNumber int
 	return workMomentList, err
 }
 
-func (d *DataBases) GetUserFriendWorkMoments(friendIDList []*string, showNumber, pageNumber int32, userID string) ([]WorkMoment, error) {
+func (d *DataBases) GetUserWorkMoments(opUserID, userID string, showNumber, pageNumber int32) ([]WorkMoment, error) {
 	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
 	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cWorkMoment)
 	var workMomentList []WorkMoment
 	findOpts := options.Find().SetLimit(int64(showNumber)).SetSkip(int64(showNumber) * (int64(pageNumber) - 1)).SetSort(bson.M{"create_time": -1})
-	result, err := c.Find(ctx,
+	result, err := c.Find(ctx, bson.D{ // 等价条件: select * from
-		bson.M{"user_id": friendIDList, "$or": bson.M{"who_can_see_user_id_list": bson.M{"$elemMatch": bson.M{"$eq": userID}},
+		{"user_id", userID},
-			"who_cant_see_user_id_list": bson.M{"$nin": userID}},
+		{"$or", bson.A{
-		}, findOpts)
+			bson.D{{"permission", constant.WorkMomentPermissionCantSee}, {"permission_user_id_list", bson.D{{"$nin", bson.A{userID}}}}},
+			bson.D{{"permission", constant.WorkMomentPermissionCanSee}, {"permission_user_id_list", bson.D{{"$in", bson.A{userID}}}}},
+			bson.D{{"permission", constant.WorkMomentPublic}},
+		}},
+	}, findOpts)
+	if err != nil {
+		return workMomentList, nil
+	}
+	err = result.All(ctx, &workMomentList)
+	return workMomentList, err
+}
+
+func (d *DataBases) GetUserFriendWorkMoments(friendIDList []string, showNumber, pageNumber int32, userID string) ([]WorkMoment, error) {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cWorkMoment)
+	var workMomentList []WorkMoment
+	findOpts := options.Find().SetLimit(int64(showNumber)).SetSkip(int64(showNumber) * (int64(pageNumber) - 1)).SetSort(bson.M{"create_time": -1})
+	result, err := c.Find(ctx, bson.D{
+		{"$or", bson.A{
+			bson.D{{"user_id", userID}}, //self
+			bson.D{{"user_id", bson.D{{"$in", friendIDList}}},
+				{"$or", bson.A{
+					bson.D{{"permission", constant.WorkMomentPermissionCantSee}, {"permission_user_id_list", bson.D{{"$nin", bson.A{userID}}}}},
+					bson.D{{"permission", constant.WorkMomentPermissionCanSee}, {"permission_user_id_list", bson.D{{"$in", bson.A{userID}}}}},
+					bson.D{{"permission", constant.WorkMomentPublic}},
+				}}},
+		},
+		},
+	}, findOpts)
 	if err != nil {
 		return workMomentList, err
 	}

pkg/common/db/mysql_model/im_mysql_model/conversation_model.go

@@ -0,0 +1,145 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+)
+
+func SetConversation(conversation db.Conversation) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	newConversation := conversation
+	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
+		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
+		// if exist, then update record
+	} else {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
+		//force update
+		return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
+			Update(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt, "is_pinned": conversation.IsPinned, "is_private_chat": conversation.IsPrivateChat,
+				"group_at_type": conversation.GroupAtType, "is_not_in_group": conversation.IsNotInGroup}).Error
+	}
+}
+func SetOneConversation(conversation db.Conversation) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	return dbConn.Model(&db.Conversation{}).Create(conversation).Error
+
+}
+
+func PeerUserSetConversation(conversation db.Conversation) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	newConversation := conversation
+	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
+		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
+		// if exist, then update record
+	}
+	log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
+	//force update
+	return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
+		Update(map[string]interface{}{"is_private_chat": conversation.IsPrivateChat}).Error
+
+}
+
+func SetRecvMsgOpt(conversation db.Conversation) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	newConversation := conversation
+	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
+		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
+		// if exist, then update record
+	} else {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
+		//force update
+		return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
+			Update(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt}).Error
+	}
+}
+
+func GetUserAllConversations(ownerUserID string) ([]db.Conversation, error) {
+	var conversations []db.Conversation
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return conversations, err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Model(&db.Conversation{}).Where("owner_user_id=?", ownerUserID).Find(&conversations).Error
+	return conversations, err
+}
+func GetMultipleUserConversationByConversationID(ownerUserIDList []string, conversationID string) ([]db.Conversation, error) {
+	var conversations []db.Conversation
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return conversations, err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Model(&db.Conversation{}).Where("owner_user_id IN ? and  conversation_id=?", ownerUserIDList, conversationID).Find(&conversations).Error
+	return conversations, err
+}
+func GetExistConversationUserIDList(ownerUserIDList []string, conversationID string) ([]string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var resultArr []string
+	err = dbConn.Table("conversations").Where(" owner_user_id IN (?) and conversation_id=?", ownerUserIDList, conversationID).Pluck("owner_user_id", &resultArr).Error
+	if err != nil {
+		return nil, err
+	}
+	return resultArr, nil
+}
+
+func GetConversation(OwnerUserID, conversationID string) (db.Conversation, error) {
+	var conversation db.Conversation
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return conversation, err
+	}
+	err = dbConn.Table("conversations").Where("owner_user_id=? and conversation_id=?", OwnerUserID, conversationID).Take(&conversation).Error
+	return conversation, err
+}
+
+func GetConversations(OwnerUserID string, conversationIDs []string) ([]db.Conversation, error) {
+	var conversations []db.Conversation
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return conversations, err
+	}
+	err = dbConn.Model(&db.Conversation{}).Where("conversation_id IN (?) and  owner_user_id=?", conversationIDs, OwnerUserID).Find(&conversations).Error
+	return conversations, err
+}
+func GetConversationsByConversationIDMultipleOwner(OwnerUserIDList []string, conversationID string) ([]db.Conversation, error) {
+	var conversations []db.Conversation
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return conversations, err
+	}
+	err = dbConn.Model(&db.Conversation{}).Where("owner_user_id IN (?) and  conversation_id=?", OwnerUserIDList, conversationID).Find(&conversations).Error
+	return conversations, err
+}
+func UpdateColumnsConversations(ownerUserIDList []string, conversationID string, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	return dbConn.Debug().Model(&db.Conversation{}).Where("owner_user_id IN (?) and  conversation_id=?", ownerUserIDList, conversationID).Updates(args).Error
+
+}

pkg/common/db/mysql_model/im_mysql_model/friend_model.go

@@ -49,13 +49,13 @@ func GetFriendListByUserID(OwnerUserID string) ([]db.Friend, error) {
 	return friends, nil
 }
 
-func GetFriendIDListByUserID(OwnerUserID string) ([]*string, error) {
+func GetFriendIDListByUserID(OwnerUserID string) ([]string, error) {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
 	if err != nil {
 		return nil, err
 	}
-	var friendIDList []*string
+	var friendIDList []string
-	err = dbConn.Table("friends").Select("friend_user_id").Where("owner_user_id=?", OwnerUserID).Find(&friendIDList).Error
+	err = dbConn.Table("friends").Where("owner_user_id=?", OwnerUserID).Pluck("friend_user_id", &friendIDList).Error
 	if err != nil {
 		return nil, err
 	}

pkg/common/db/mysql_model/im_mysql_model/user_model.go

@@ -4,7 +4,6 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
 	"fmt"
 	"time"
@@ -305,101 +304,3 @@ func GetBlockUsersNumCount() (int32, error) {
 	}
 	return count, nil
 }
-
-func SetConversation(conversation db.Conversation) error {
-	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	if err != nil {
-		return err
-	}
-	dbConn.LogMode(false)
-	newConversation := conversation
-	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
-		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
-		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
-		// if exist, then update record
-	} else {
-		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
-		//force update
-		return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
-			Update(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt, "is_pinned": conversation.IsPinned, "is_private_chat": conversation.IsPrivateChat,
-				"group_at_type": conversation.GroupAtType, "is_not_in_group": conversation.IsNotInGroup}).Error
-	}
-}
-
-func PeerUserSetConversation(conversation db.Conversation) error {
-	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	if err != nil {
-		return err
-	}
-	dbConn.LogMode(false)
-	newConversation := conversation
-	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
-		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
-		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
-		// if exist, then update record
-	}
-	log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
-	//force update
-	return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
-		Update(map[string]interface{}{"is_private_chat": conversation.IsPrivateChat}).Error
-
-}
-
-func SetRecvMsgOpt(conversation db.Conversation) error {
-	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	if err != nil {
-		return err
-	}
-	dbConn.LogMode(false)
-	newConversation := conversation
-	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
-		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
-		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
-		// if exist, then update record
-	} else {
-		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
-		//force update
-		return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
-			Update(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt}).Error
-	}
-}
-
-func GetUserAllConversations(ownerUserID string) ([]db.Conversation, error) {
-	var conversations []db.Conversation
-	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	if err != nil {
-		return conversations, err
-	}
-	dbConn.LogMode(false)
-	err = dbConn.Model(&db.Conversation{}).Where("owner_user_id=?", ownerUserID).Find(&conversations).Error
-	return conversations, err
-}
-
-func GetConversation(OwnerUserID, conversationID string) (db.Conversation, error) {
-	var conversation db.Conversation
-	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	if err != nil {
-		return conversation, err
-	}
-	err = dbConn.Table("conversations").Where("owner_user_id=? and conversation_id=?", OwnerUserID, conversationID).Take(&conversation).Error
-	return conversation, err
-}
-
-func GetConversations(OwnerUserID string, conversationIDs []string) ([]db.Conversation, error) {
-	var conversations []db.Conversation
-	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	if err != nil {
-		return conversations, err
-	}
-	err = dbConn.Model(&db.Conversation{}).Where("conversation_id IN (?) and  owner_user_id=?", conversationIDs, OwnerUserID).Find(&conversations).Error
-	return conversations, err
-}
-func GetConversationsByConversationIDMultipleOwner(OwnerUserIDList []string, conversationID string) ([]db.Conversation, error) {
-	var conversations []db.Conversation
-	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	if err != nil {
-		return conversations, err
-	}
-	err = dbConn.Model(&db.Conversation{}).Where("owner_user_id IN (?) and  conversation_id=?", OwnerUserIDList, conversationID).Find(&conversations).Error
-	return conversations, err
-}

pkg/common/db/redisModel.go

@@ -3,6 +3,8 @@ package db
 import (
 	"Open_IM/pkg/common/constant"
 	log2 "Open_IM/pkg/common/log"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"encoding/json"
 	"github.com/garyburd/redigo/redis"
 )
 
@@ -15,6 +17,7 @@ const (
 	uidPidToken                   = "UID_PID_TOKEN_STATUS:"
 	conversationReceiveMessageOpt = "CON_RECV_MSG_OPT:"
 	GetuiToken                    = "GETUI"
+	UserInfoCache                 = "USER_INFO_CACHE:"
 )
 
 func (d *DataBases) Exec(cmd string, key interface{}, args ...interface{}) (interface{}, error) {
@@ -155,3 +158,23 @@ func (d *DataBases) GetGetuiToken() (string, error) {
 	result, err := redis.String(d.Exec("GET", GetuiToken))
 	return result, err
 }
+
+func (d *DataBases) SetUserInfo(userInfo *pbCommon.UserInfo) error {
+	b, _ := json.Marshal(&userInfo)
+	m := map[string]interface{}{}
+	if err := json.Unmarshal(b, &m); err != nil {
+		return err
+	}
+	_, err := d.Exec("hmset", UserInfoCache+userInfo.UserID, redis.Args{}.Add().AddFlat(m)...)
+	return err
+}
+
+func (d *DataBases) GetUserInfo(userID string) (*pbCommon.UserInfo, error) {
+	result, err := redis.String(d.Exec("HGETALL", UserInfoCache+userID))
+	if err != nil {
+		return nil, err
+	}
+	userInfo := &pbCommon.UserInfo{}
+	err = json.Unmarshal([]byte(result), userInfo)
+	return userInfo, err
+}

pkg/common/token_verify/jwt_token.go

@@ -206,7 +206,7 @@ func ParseRedisInterfaceToken(redisToken interface{}) (*Claims, error) {
 func VerifyToken(token, uid string) (bool, error) {
 	claims, err := ParseToken(token, "")
 	if err != nil {
-		return false, err
+		return false, utils.Wrap(err, "ParseToken failed")
 	}
 	if claims.UID != uid {
 		return false, &constant.ErrTokenUnknown
@@ -215,8 +215,8 @@ func VerifyToken(token, uid string) (bool, error) {
 	log.NewDebug("", claims.UID, claims.Platform)
 	return true, nil
 }
-func WsVerifyToken(token, uid string, platformID string) (bool, error, string) {
+func WsVerifyToken(token, uid string, platformID string, operationID string) (bool, error, string) {
-	claims, err := ParseToken(token, "")
+	claims, err := ParseToken(token, operationID)
 	if err != nil {
 		return false, utils.Wrap(err, "parse token err"), "parse token err"
 	}
@@ -226,6 +226,6 @@ func WsVerifyToken(token, uid string, platformID string) (bool, error, string) {
 	if claims.Platform != constant.PlatformIDToName(utils.StringToInt32(platformID)) {
 		return false, utils.Wrap(&constant.ErrTokenUnknown, "platform is not same to token platform"), "platform is not same to token platform"
 	}
-	log.NewDebug("", claims.UID, claims.Platform)
+	log.NewDebug(operationID, utils.GetSelfFuncName(), " check ok ", claims.UID, uid, claims.Platform)
 	return true, nil, ""
 }

pkg/proto/cache/cache.pb.go

@@ -0,0 +1,883 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cache/cache.proto
+
+package cache // import "./cache"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import sdk_ws "Open_IM/pkg/proto/sdk_ws"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type CommonResp struct {
+	ErrCode              int32    `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"`
+	ErrMsg               string   `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CommonResp) Reset()         { *m = CommonResp{} }
+func (m *CommonResp) String() string { return proto.CompactTextString(m) }
+func (*CommonResp) ProtoMessage()    {}
+func (*CommonResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{0}
+}
+func (m *CommonResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CommonResp.Unmarshal(m, b)
+}
+func (m *CommonResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CommonResp.Marshal(b, m, deterministic)
+}
+func (dst *CommonResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CommonResp.Merge(dst, src)
+}
+func (m *CommonResp) XXX_Size() int {
+	return xxx_messageInfo_CommonResp.Size(m)
+}
+func (m *CommonResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_CommonResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommonResp proto.InternalMessageInfo
+
+func (m *CommonResp) GetErrCode() int32 {
+	if m != nil {
+		return m.ErrCode
+	}
+	return 0
+}
+
+func (m *CommonResp) GetErrMsg() string {
+	if m != nil {
+		return m.ErrMsg
+	}
+	return ""
+}
+
+type GetUserInfoReq struct {
+	UserIDList           []string `protobuf:"bytes,1,rep,name=userIDList" json:"userIDList,omitempty"`
+	OperationID          string   `protobuf:"bytes,3,opt,name=operationID" json:"operationID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetUserInfoReq) Reset()         { *m = GetUserInfoReq{} }
+func (m *GetUserInfoReq) String() string { return proto.CompactTextString(m) }
+func (*GetUserInfoReq) ProtoMessage()    {}
+func (*GetUserInfoReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{1}
+}
+func (m *GetUserInfoReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetUserInfoReq.Unmarshal(m, b)
+}
+func (m *GetUserInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetUserInfoReq.Marshal(b, m, deterministic)
+}
+func (dst *GetUserInfoReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetUserInfoReq.Merge(dst, src)
+}
+func (m *GetUserInfoReq) XXX_Size() int {
+	return xxx_messageInfo_GetUserInfoReq.Size(m)
+}
+func (m *GetUserInfoReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetUserInfoReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetUserInfoReq proto.InternalMessageInfo
+
+func (m *GetUserInfoReq) GetUserIDList() []string {
+	if m != nil {
+		return m.UserIDList
+	}
+	return nil
+}
+
+func (m *GetUserInfoReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+type GetUserInfoResp struct {
+	CommonResp           *CommonResp        `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"`
+	UserInfoList         []*sdk_ws.UserInfo `protobuf:"bytes,2,rep,name=userInfoList" json:"userInfoList,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *GetUserInfoResp) Reset()         { *m = GetUserInfoResp{} }
+func (m *GetUserInfoResp) String() string { return proto.CompactTextString(m) }
+func (*GetUserInfoResp) ProtoMessage()    {}
+func (*GetUserInfoResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{2}
+}
+func (m *GetUserInfoResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetUserInfoResp.Unmarshal(m, b)
+}
+func (m *GetUserInfoResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetUserInfoResp.Marshal(b, m, deterministic)
+}
+func (dst *GetUserInfoResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetUserInfoResp.Merge(dst, src)
+}
+func (m *GetUserInfoResp) XXX_Size() int {
+	return xxx_messageInfo_GetUserInfoResp.Size(m)
+}
+func (m *GetUserInfoResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetUserInfoResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetUserInfoResp proto.InternalMessageInfo
+
+func (m *GetUserInfoResp) GetCommonResp() *CommonResp {
+	if m != nil {
+		return m.CommonResp
+	}
+	return nil
+}
+
+func (m *GetUserInfoResp) GetUserInfoList() []*sdk_ws.UserInfo {
+	if m != nil {
+		return m.UserInfoList
+	}
+	return nil
+}
+
+type UpdateUserInfoReq struct {
+	UserInfoList         []*sdk_ws.UserInfo `protobuf:"bytes,1,rep,name=userInfoList" json:"userInfoList,omitempty"`
+	OperationID          string             `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *UpdateUserInfoReq) Reset()         { *m = UpdateUserInfoReq{} }
+func (m *UpdateUserInfoReq) String() string { return proto.CompactTextString(m) }
+func (*UpdateUserInfoReq) ProtoMessage()    {}
+func (*UpdateUserInfoReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{3}
+}
+func (m *UpdateUserInfoReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UpdateUserInfoReq.Unmarshal(m, b)
+}
+func (m *UpdateUserInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UpdateUserInfoReq.Marshal(b, m, deterministic)
+}
+func (dst *UpdateUserInfoReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateUserInfoReq.Merge(dst, src)
+}
+func (m *UpdateUserInfoReq) XXX_Size() int {
+	return xxx_messageInfo_UpdateUserInfoReq.Size(m)
+}
+func (m *UpdateUserInfoReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateUserInfoReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateUserInfoReq proto.InternalMessageInfo
+
+func (m *UpdateUserInfoReq) GetUserInfoList() []*sdk_ws.UserInfo {
+	if m != nil {
+		return m.UserInfoList
+	}
+	return nil
+}
+
+func (m *UpdateUserInfoReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+type UpdateUserInfoResp struct {
+	CommonResp           *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *UpdateUserInfoResp) Reset()         { *m = UpdateUserInfoResp{} }
+func (m *UpdateUserInfoResp) String() string { return proto.CompactTextString(m) }
+func (*UpdateUserInfoResp) ProtoMessage()    {}
+func (*UpdateUserInfoResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{4}
+}
+func (m *UpdateUserInfoResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UpdateUserInfoResp.Unmarshal(m, b)
+}
+func (m *UpdateUserInfoResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UpdateUserInfoResp.Marshal(b, m, deterministic)
+}
+func (dst *UpdateUserInfoResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateUserInfoResp.Merge(dst, src)
+}
+func (m *UpdateUserInfoResp) XXX_Size() int {
+	return xxx_messageInfo_UpdateUserInfoResp.Size(m)
+}
+func (m *UpdateUserInfoResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateUserInfoResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateUserInfoResp proto.InternalMessageInfo
+
+func (m *UpdateUserInfoResp) GetCommonResp() *CommonResp {
+	if m != nil {
+		return m.CommonResp
+	}
+	return nil
+}
+
+type GetFriendInfoReq struct {
+	UserID               string   `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
+	OperationID          string   `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetFriendInfoReq) Reset()         { *m = GetFriendInfoReq{} }
+func (m *GetFriendInfoReq) String() string { return proto.CompactTextString(m) }
+func (*GetFriendInfoReq) ProtoMessage()    {}
+func (*GetFriendInfoReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{5}
+}
+func (m *GetFriendInfoReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetFriendInfoReq.Unmarshal(m, b)
+}
+func (m *GetFriendInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetFriendInfoReq.Marshal(b, m, deterministic)
+}
+func (dst *GetFriendInfoReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetFriendInfoReq.Merge(dst, src)
+}
+func (m *GetFriendInfoReq) XXX_Size() int {
+	return xxx_messageInfo_GetFriendInfoReq.Size(m)
+}
+func (m *GetFriendInfoReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetFriendInfoReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetFriendInfoReq proto.InternalMessageInfo
+
+func (m *GetFriendInfoReq) GetUserID() string {
+	if m != nil {
+		return m.UserID
+	}
+	return ""
+}
+
+func (m *GetFriendInfoReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+type GetFriendInfoResp struct {
+	FriendInfoList       []*sdk_ws.FriendInfo `protobuf:"bytes,1,rep,name=friendInfoList" json:"friendInfoList,omitempty"`
+	CommonResp           *CommonResp          `protobuf:"bytes,2,opt,name=commonResp" json:"commonResp,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *GetFriendInfoResp) Reset()         { *m = GetFriendInfoResp{} }
+func (m *GetFriendInfoResp) String() string { return proto.CompactTextString(m) }
+func (*GetFriendInfoResp) ProtoMessage()    {}
+func (*GetFriendInfoResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{6}
+}
+func (m *GetFriendInfoResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetFriendInfoResp.Unmarshal(m, b)
+}
+func (m *GetFriendInfoResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetFriendInfoResp.Marshal(b, m, deterministic)
+}
+func (dst *GetFriendInfoResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetFriendInfoResp.Merge(dst, src)
+}
+func (m *GetFriendInfoResp) XXX_Size() int {
+	return xxx_messageInfo_GetFriendInfoResp.Size(m)
+}
+func (m *GetFriendInfoResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetFriendInfoResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetFriendInfoResp proto.InternalMessageInfo
+
+func (m *GetFriendInfoResp) GetFriendInfoList() []*sdk_ws.FriendInfo {
+	if m != nil {
+		return m.FriendInfoList
+	}
+	return nil
+}
+
+func (m *GetFriendInfoResp) GetCommonResp() *CommonResp {
+	if m != nil {
+		return m.CommonResp
+	}
+	return nil
+}
+
+type UpdateBlackListReq struct {
+	BlackList            []*sdk_ws.BlackInfo `protobuf:"bytes,1,rep,name=blackList" json:"blackList,omitempty"`
+	OperationID          string              `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
+	XXX_unrecognized     []byte              `json:"-"`
+	XXX_sizecache        int32               `json:"-"`
+}
+
+func (m *UpdateBlackListReq) Reset()         { *m = UpdateBlackListReq{} }
+func (m *UpdateBlackListReq) String() string { return proto.CompactTextString(m) }
+func (*UpdateBlackListReq) ProtoMessage()    {}
+func (*UpdateBlackListReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{7}
+}
+func (m *UpdateBlackListReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UpdateBlackListReq.Unmarshal(m, b)
+}
+func (m *UpdateBlackListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UpdateBlackListReq.Marshal(b, m, deterministic)
+}
+func (dst *UpdateBlackListReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateBlackListReq.Merge(dst, src)
+}
+func (m *UpdateBlackListReq) XXX_Size() int {
+	return xxx_messageInfo_UpdateBlackListReq.Size(m)
+}
+func (m *UpdateBlackListReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateBlackListReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateBlackListReq proto.InternalMessageInfo
+
+func (m *UpdateBlackListReq) GetBlackList() []*sdk_ws.BlackInfo {
+	if m != nil {
+		return m.BlackList
+	}
+	return nil
+}
+
+func (m *UpdateBlackListReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+type UpdateBlackListResp struct {
+	CommonResp           *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *UpdateBlackListResp) Reset()         { *m = UpdateBlackListResp{} }
+func (m *UpdateBlackListResp) String() string { return proto.CompactTextString(m) }
+func (*UpdateBlackListResp) ProtoMessage()    {}
+func (*UpdateBlackListResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{8}
+}
+func (m *UpdateBlackListResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UpdateBlackListResp.Unmarshal(m, b)
+}
+func (m *UpdateBlackListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UpdateBlackListResp.Marshal(b, m, deterministic)
+}
+func (dst *UpdateBlackListResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateBlackListResp.Merge(dst, src)
+}
+func (m *UpdateBlackListResp) XXX_Size() int {
+	return xxx_messageInfo_UpdateBlackListResp.Size(m)
+}
+func (m *UpdateBlackListResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateBlackListResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateBlackListResp proto.InternalMessageInfo
+
+func (m *UpdateBlackListResp) GetCommonResp() *CommonResp {
+	if m != nil {
+		return m.CommonResp
+	}
+	return nil
+}
+
+type GetBlackListReq struct {
+	UserID               string   `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
+	OperationID          string   `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetBlackListReq) Reset()         { *m = GetBlackListReq{} }
+func (m *GetBlackListReq) String() string { return proto.CompactTextString(m) }
+func (*GetBlackListReq) ProtoMessage()    {}
+func (*GetBlackListReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{9}
+}
+func (m *GetBlackListReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetBlackListReq.Unmarshal(m, b)
+}
+func (m *GetBlackListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetBlackListReq.Marshal(b, m, deterministic)
+}
+func (dst *GetBlackListReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetBlackListReq.Merge(dst, src)
+}
+func (m *GetBlackListReq) XXX_Size() int {
+	return xxx_messageInfo_GetBlackListReq.Size(m)
+}
+func (m *GetBlackListReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetBlackListReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetBlackListReq proto.InternalMessageInfo
+
+func (m *GetBlackListReq) GetUserID() string {
+	if m != nil {
+		return m.UserID
+	}
+	return ""
+}
+
+func (m *GetBlackListReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+type GetBlackListResp struct {
+	BlackList            []*sdk_ws.BlackInfo `protobuf:"bytes,1,rep,name=blackList" json:"blackList,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
+	XXX_unrecognized     []byte              `json:"-"`
+	XXX_sizecache        int32               `json:"-"`
+}
+
+func (m *GetBlackListResp) Reset()         { *m = GetBlackListResp{} }
+func (m *GetBlackListResp) String() string { return proto.CompactTextString(m) }
+func (*GetBlackListResp) ProtoMessage()    {}
+func (*GetBlackListResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{10}
+}
+func (m *GetBlackListResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetBlackListResp.Unmarshal(m, b)
+}
+func (m *GetBlackListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetBlackListResp.Marshal(b, m, deterministic)
+}
+func (dst *GetBlackListResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetBlackListResp.Merge(dst, src)
+}
+func (m *GetBlackListResp) XXX_Size() int {
+	return xxx_messageInfo_GetBlackListResp.Size(m)
+}
+func (m *GetBlackListResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetBlackListResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetBlackListResp proto.InternalMessageInfo
+
+func (m *GetBlackListResp) GetBlackList() []*sdk_ws.BlackInfo {
+	if m != nil {
+		return m.BlackList
+	}
+	return nil
+}
+
+type UpdateFriendInfoReq struct {
+	FriendInfoList       []*sdk_ws.FriendInfo `protobuf:"bytes,1,rep,name=friendInfoList" json:"friendInfoList,omitempty"`
+	OperationID          string               `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *UpdateFriendInfoReq) Reset()         { *m = UpdateFriendInfoReq{} }
+func (m *UpdateFriendInfoReq) String() string { return proto.CompactTextString(m) }
+func (*UpdateFriendInfoReq) ProtoMessage()    {}
+func (*UpdateFriendInfoReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{11}
+}
+func (m *UpdateFriendInfoReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UpdateFriendInfoReq.Unmarshal(m, b)
+}
+func (m *UpdateFriendInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UpdateFriendInfoReq.Marshal(b, m, deterministic)
+}
+func (dst *UpdateFriendInfoReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateFriendInfoReq.Merge(dst, src)
+}
+func (m *UpdateFriendInfoReq) XXX_Size() int {
+	return xxx_messageInfo_UpdateFriendInfoReq.Size(m)
+}
+func (m *UpdateFriendInfoReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateFriendInfoReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateFriendInfoReq proto.InternalMessageInfo
+
+func (m *UpdateFriendInfoReq) GetFriendInfoList() []*sdk_ws.FriendInfo {
+	if m != nil {
+		return m.FriendInfoList
+	}
+	return nil
+}
+
+func (m *UpdateFriendInfoReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+type UpdateFriendInfoResp struct {
+	CommonResp           *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *UpdateFriendInfoResp) Reset()         { *m = UpdateFriendInfoResp{} }
+func (m *UpdateFriendInfoResp) String() string { return proto.CompactTextString(m) }
+func (*UpdateFriendInfoResp) ProtoMessage()    {}
+func (*UpdateFriendInfoResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cache_c95b22de9c135769, []int{12}
+}
+func (m *UpdateFriendInfoResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UpdateFriendInfoResp.Unmarshal(m, b)
+}
+func (m *UpdateFriendInfoResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UpdateFriendInfoResp.Marshal(b, m, deterministic)
+}
+func (dst *UpdateFriendInfoResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateFriendInfoResp.Merge(dst, src)
+}
+func (m *UpdateFriendInfoResp) XXX_Size() int {
+	return xxx_messageInfo_UpdateFriendInfoResp.Size(m)
+}
+func (m *UpdateFriendInfoResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_UpdateFriendInfoResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateFriendInfoResp proto.InternalMessageInfo
+
+func (m *UpdateFriendInfoResp) GetCommonResp() *CommonResp {
+	if m != nil {
+		return m.CommonResp
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*CommonResp)(nil), "cache.CommonResp")
+	proto.RegisterType((*GetUserInfoReq)(nil), "cache.GetUserInfoReq")
+	proto.RegisterType((*GetUserInfoResp)(nil), "cache.GetUserInfoResp")
+	proto.RegisterType((*UpdateUserInfoReq)(nil), "cache.UpdateUserInfoReq")
+	proto.RegisterType((*UpdateUserInfoResp)(nil), "cache.UpdateUserInfoResp")
+	proto.RegisterType((*GetFriendInfoReq)(nil), "cache.GetFriendInfoReq")
+	proto.RegisterType((*GetFriendInfoResp)(nil), "cache.GetFriendInfoResp")
+	proto.RegisterType((*UpdateBlackListReq)(nil), "cache.UpdateBlackListReq")
+	proto.RegisterType((*UpdateBlackListResp)(nil), "cache.UpdateBlackListResp")
+	proto.RegisterType((*GetBlackListReq)(nil), "cache.GetBlackListReq")
+	proto.RegisterType((*GetBlackListResp)(nil), "cache.GetBlackListResp")
+	proto.RegisterType((*UpdateFriendInfoReq)(nil), "cache.UpdateFriendInfoReq")
+	proto.RegisterType((*UpdateFriendInfoResp)(nil), "cache.UpdateFriendInfoResp")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Cache service
+
+type CacheClient interface {
+	GetUserInfo(ctx context.Context, in *GetUserInfoReq, opts ...grpc.CallOption) (*GetUserInfoResp, error)
+	UpdateUserInfo(ctx context.Context, in *UpdateUserInfoReq, opts ...grpc.CallOption) (*UpdateUserInfoResp, error)
+	GetFriendInfo(ctx context.Context, in *GetFriendInfoReq, opts ...grpc.CallOption) (*GetFriendInfoResp, error)
+	UpdateFriendInfo(ctx context.Context, in *UpdateFriendInfoReq, opts ...grpc.CallOption) (*UpdateFriendInfoResp, error)
+	UpdateBlackList(ctx context.Context, in *UpdateBlackListReq, opts ...grpc.CallOption) (*UpdateBlackListResp, error)
+	GetBlackList(ctx context.Context, in *GetBlackListReq, opts ...grpc.CallOption) (*GetBlackListResp, error)
+}
+
+type cacheClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewCacheClient(cc *grpc.ClientConn) CacheClient {
+	return &cacheClient{cc}
+}
+
+func (c *cacheClient) GetUserInfo(ctx context.Context, in *GetUserInfoReq, opts ...grpc.CallOption) (*GetUserInfoResp, error) {
+	out := new(GetUserInfoResp)
+	err := grpc.Invoke(ctx, "/cache.cache/GetUserInfo", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *cacheClient) UpdateUserInfo(ctx context.Context, in *UpdateUserInfoReq, opts ...grpc.CallOption) (*UpdateUserInfoResp, error) {
+	out := new(UpdateUserInfoResp)
+	err := grpc.Invoke(ctx, "/cache.cache/UpdateUserInfo", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *cacheClient) GetFriendInfo(ctx context.Context, in *GetFriendInfoReq, opts ...grpc.CallOption) (*GetFriendInfoResp, error) {
+	out := new(GetFriendInfoResp)
+	err := grpc.Invoke(ctx, "/cache.cache/GetFriendInfo", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *cacheClient) UpdateFriendInfo(ctx context.Context, in *UpdateFriendInfoReq, opts ...grpc.CallOption) (*UpdateFriendInfoResp, error) {
+	out := new(UpdateFriendInfoResp)
+	err := grpc.Invoke(ctx, "/cache.cache/UpdateFriendInfo", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *cacheClient) UpdateBlackList(ctx context.Context, in *UpdateBlackListReq, opts ...grpc.CallOption) (*UpdateBlackListResp, error) {
+	out := new(UpdateBlackListResp)
+	err := grpc.Invoke(ctx, "/cache.cache/UpdateBlackList", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *cacheClient) GetBlackList(ctx context.Context, in *GetBlackListReq, opts ...grpc.CallOption) (*GetBlackListResp, error) {
+	out := new(GetBlackListResp)
+	err := grpc.Invoke(ctx, "/cache.cache/GetBlackList", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Cache service
+
+type CacheServer interface {
+	GetUserInfo(context.Context, *GetUserInfoReq) (*GetUserInfoResp, error)
+	UpdateUserInfo(context.Context, *UpdateUserInfoReq) (*UpdateUserInfoResp, error)
+	GetFriendInfo(context.Context, *GetFriendInfoReq) (*GetFriendInfoResp, error)
+	UpdateFriendInfo(context.Context, *UpdateFriendInfoReq) (*UpdateFriendInfoResp, error)
+	UpdateBlackList(context.Context, *UpdateBlackListReq) (*UpdateBlackListResp, error)
+	GetBlackList(context.Context, *GetBlackListReq) (*GetBlackListResp, error)
+}
+
+func RegisterCacheServer(s *grpc.Server, srv CacheServer) {
+	s.RegisterService(&_Cache_serviceDesc, srv)
+}
+
+func _Cache_GetUserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetUserInfoReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CacheServer).GetUserInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cache.cache/GetUserInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CacheServer).GetUserInfo(ctx, req.(*GetUserInfoReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cache_UpdateUserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateUserInfoReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CacheServer).UpdateUserInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cache.cache/UpdateUserInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CacheServer).UpdateUserInfo(ctx, req.(*UpdateUserInfoReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cache_GetFriendInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetFriendInfoReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CacheServer).GetFriendInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cache.cache/GetFriendInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CacheServer).GetFriendInfo(ctx, req.(*GetFriendInfoReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cache_UpdateFriendInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateFriendInfoReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CacheServer).UpdateFriendInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cache.cache/UpdateFriendInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CacheServer).UpdateFriendInfo(ctx, req.(*UpdateFriendInfoReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cache_UpdateBlackList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateBlackListReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CacheServer).UpdateBlackList(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cache.cache/UpdateBlackList",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CacheServer).UpdateBlackList(ctx, req.(*UpdateBlackListReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cache_GetBlackList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetBlackListReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CacheServer).GetBlackList(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cache.cache/GetBlackList",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CacheServer).GetBlackList(ctx, req.(*GetBlackListReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Cache_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "cache.cache",
+	HandlerType: (*CacheServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetUserInfo",
+			Handler:    _Cache_GetUserInfo_Handler,
+		},
+		{
+			MethodName: "UpdateUserInfo",
+			Handler:    _Cache_UpdateUserInfo_Handler,
+		},
+		{
+			MethodName: "GetFriendInfo",
+			Handler:    _Cache_GetFriendInfo_Handler,
+		},
+		{
+			MethodName: "UpdateFriendInfo",
+			Handler:    _Cache_UpdateFriendInfo_Handler,
+		},
+		{
+			MethodName: "UpdateBlackList",
+			Handler:    _Cache_UpdateBlackList_Handler,
+		},
+		{
+			MethodName: "GetBlackList",
+			Handler:    _Cache_GetBlackList_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "cache/cache.proto",
+}
+
+func init() { proto.RegisterFile("cache/cache.proto", fileDescriptor_cache_c95b22de9c135769) }
+
+var fileDescriptor_cache_c95b22de9c135769 = []byte{
+	// 527 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x4d, 0x6f, 0xd3, 0x40,
+	0x10, 0x95, 0x13, 0x35, 0x28, 0x13, 0xda, 0x34, 0x03, 0xa4, 0xc6, 0x05, 0x64, 0x7c, 0xca, 0xc9,
+	0x16, 0xe1, 0x06, 0x08, 0xa4, 0xb4, 0x90, 0x46, 0x6d, 0x41, 0x5a, 0xa9, 0x17, 0x2e, 0x91, 0x9b,
+	0x6c, 0x4b, 0x14, 0xe2, 0x5d, 0x76, 0xdd, 0xf6, 0xc6, 0x8d, 0x23, 0xff, 0x83, 0x9f, 0x89, 0xb2,
+	0xb6, 0x93, 0xdd, 0x8d, 0x23, 0x42, 0xe0, 0x62, 0x69, 0xf6, 0xe3, 0xcd, 0x7b, 0x6f, 0xc6, 0xb3,
+	0xd0, 0x1a, 0xc5, 0xa3, 0x2f, 0x34, 0x52, 0xdf, 0x90, 0x0b, 0x96, 0x32, 0xdc, 0x51, 0x81, 0xf7,
+	0xfc, 0x13, 0xa7, 0xc9, 0x70, 0x70, 0x1e, 0xf1, 0xe9, 0x75, 0xa4, 0x76, 0x22, 0x39, 0x9e, 0x0e,
+	0xef, 0x64, 0x74, 0x27, 0xb3, 0x93, 0xc1, 0x5b, 0x80, 0x23, 0x36, 0x9b, 0xb1, 0x84, 0x50, 0xc9,
+	0xd1, 0x85, 0x7b, 0x54, 0x88, 0x23, 0x36, 0xa6, 0xae, 0xe3, 0x3b, 0x9d, 0x1d, 0x52, 0x84, 0xd8,
+	0x86, 0x1a, 0x15, 0xe2, 0x5c, 0x5e, 0xbb, 0x15, 0xdf, 0xe9, 0xd4, 0x49, 0x1e, 0x05, 0x04, 0xf6,
+	0xfa, 0x34, 0xbd, 0x90, 0x54, 0x0c, 0x92, 0x2b, 0x46, 0xe8, 0x37, 0x7c, 0x06, 0x70, 0x33, 0x0f,
+	0x8f, 0xcf, 0x26, 0x32, 0x75, 0x1d, 0xbf, 0xda, 0xa9, 0x13, 0x6d, 0x05, 0x7d, 0x68, 0x30, 0x4e,
+	0x45, 0x9c, 0x4e, 0x58, 0x32, 0x38, 0x76, 0xab, 0x0a, 0x4e, 0x5f, 0x0a, 0x7e, 0x38, 0xd0, 0x34,
+	0x40, 0x25, 0xc7, 0x17, 0x00, 0xa3, 0x05, 0x4f, 0x45, 0xae, 0xd1, 0x6d, 0x85, 0x99, 0xe6, 0xa5,
+	0x00, 0xa2, 0x1d, 0xc2, 0x77, 0x70, 0xff, 0x26, 0x87, 0x50, 0x54, 0x2a, 0x7e, 0xb5, 0xd3, 0xe8,
+	0x1e, 0x86, 0x92, 0x8a, 0x5b, 0x2a, 0x86, 0x31, 0x9f, 0x0c, 0x79, 0x2c, 0xe2, 0x99, 0x0c, 0x17,
+	0x99, 0x8c, 0x0b, 0xc1, 0x2d, 0xb4, 0x2e, 0xf8, 0x38, 0x4e, 0xa9, 0x2e, 0xcf, 0x46, 0x75, 0xfe,
+	0x12, 0xd5, 0xd6, 0x5f, 0x59, 0xd5, 0xdf, 0x07, 0xb4, 0xf3, 0x6e, 0xe5, 0x40, 0x70, 0x06, 0xfb,
+	0x7d, 0x9a, 0x7e, 0x10, 0x13, 0x9a, 0x8c, 0x0b, 0xfe, 0x6d, 0xa8, 0x65, 0xc5, 0x50, 0x10, 0x75,
+	0x92, 0x47, 0x1b, 0xd0, 0xfa, 0xe9, 0x40, 0xcb, 0x82, 0x93, 0x1c, 0xdf, 0xc3, 0xde, 0xd5, 0x62,
+	0x45, 0x73, 0xe4, 0x69, 0x89, 0x23, 0xda, 0x55, 0xeb, 0x92, 0xa5, 0xae, 0xb2, 0x89, 0x3a, 0x51,
+	0xd8, 0xd4, 0xfb, 0x1a, 0x8f, 0xa6, 0x73, 0x94, 0xb9, 0xbe, 0x57, 0x50, 0xbf, 0x2c, 0xe2, 0x9c,
+	0xca, 0x93, 0x12, 0x2a, 0xea, 0x8e, 0x62, 0xb2, 0x3c, 0xbe, 0x81, 0x07, 0x27, 0xf0, 0x60, 0x25,
+	0xe7, 0x76, 0xb5, 0x39, 0x55, 0x3d, 0x6e, 0x50, 0xdf, 0xbe, 0x34, 0x1f, 0x55, 0xa1, 0x4d, 0x4e,
+	0xff, 0x60, 0x44, 0xf0, 0xbd, 0x90, 0x69, 0xf6, 0xce, 0x7f, 0xaa, 0xf5, 0x9f, 0xf5, 0x0c, 0xe0,
+	0xe1, 0x6a, 0xfe, 0xad, 0x7c, 0xee, 0xfe, 0xaa, 0x42, 0x36, 0x0d, 0xf1, 0x0d, 0x34, 0xb4, 0xa9,
+	0x82, 0x8f, 0xf2, 0x7b, 0xe6, 0xf8, 0xf2, 0xda, 0x65, 0xcb, 0x59, 0x9f, 0x9b, 0x3f, 0x25, 0xba,
+	0xf9, 0xc9, 0x95, 0x19, 0xe1, 0x3d, 0x5e, 0xb3, 0x23, 0x39, 0xf6, 0x60, 0xd7, 0xf8, 0x87, 0xf0,
+	0x60, 0x99, 0xcf, 0x30, 0xdb, 0x73, 0xcb, 0x37, 0x24, 0xc7, 0x53, 0xd8, 0xb7, 0xdd, 0x41, 0xcf,
+	0x48, 0x69, 0x22, 0x1d, 0xae, 0xdd, 0x93, 0x1c, 0x4f, 0xa0, 0x69, 0x75, 0x34, 0x9a, 0xf4, 0xf5,
+	0x16, 0xf5, 0xbc, 0x75, 0x5b, 0xd9, 0xbc, 0xd5, 0x9b, 0x10, 0x35, 0x27, 0x0d, 0x8c, 0x83, 0xd2,
+	0x75, 0xc9, 0x7b, 0xcd, 0xcf, 0xbb, 0x61, 0xf6, 0x8c, 0xbd, 0x56, 0xdf, 0xcb, 0x9a, 0x7a, 0xa3,
+	0x5e, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x17, 0x6d, 0x42, 0xe2, 0x06, 0x00, 0x00,
+}

pkg/proto/cache/cache.proto

@@ -0,0 +1,78 @@
+syntax = "proto3";
+import "Open_IM/pkg/proto/sdk_ws/ws.proto";
+option go_package = "./cache;cache";
+package cache;
+
+message CommonResp{
+  int32  errCode = 1;
+  string errMsg = 2;
+}
+
+message GetUserInfoReq{
+  repeated string userIDList = 1;
+  string operationID = 3;
+}
+
+message GetUserInfoResp{
+  CommonResp  commonResp = 1;
+  repeated server_api_params.UserInfo userInfoList = 2;
+}
+
+
+message UpdateUserInfoReq{
+  repeated server_api_params.UserInfo userInfoList = 1;
+  string operationID = 2;
+}
+
+message UpdateUserInfoResp{
+  CommonResp commonResp = 1;
+}
+
+message GetFriendInfoReq {
+  string userID = 1;
+  string operationID = 2;
+}
+
+message GetFriendInfoResp {
+  repeated server_api_params.FriendInfo friendInfoList = 1;
+  CommonResp commonResp = 2;
+}
+
+message UpdateBlackListReq {
+  repeated server_api_params.BlackInfo blackList = 1;
+  string operationID = 2;
+}
+
+message UpdateBlackListResp {
+  CommonResp commonResp = 1;
+}
+
+message GetBlackListReq {
+  string userID = 1;
+  string operationID = 2;
+}
+
+message GetBlackListResp {
+  repeated server_api_params.BlackInfo blackList = 1;
+}
+
+
+message UpdateFriendInfoReq{
+  repeated server_api_params.FriendInfo friendInfoList = 1;
+  string operationID = 2;
+}
+
+message UpdateFriendInfoResp{
+  CommonResp commonResp = 1;
+}
+
+service cache{
+  rpc GetUserInfo(GetUserInfoReq) returns(GetUserInfoResp);
+  rpc UpdateUserInfo(UpdateUserInfoReq) returns(UpdateUserInfoResp);
+  rpc GetFriendInfo(GetFriendInfoReq) returns(GetFriendInfoResp);
+  rpc UpdateFriendInfo(UpdateFriendInfoReq) returns(UpdateFriendInfoResp);
+  rpc UpdateBlackList(UpdateBlackListReq) returns(UpdateBlackListResp);
+  rpc GetBlackList(GetBlackListReq) returns(GetBlackListResp);
+}
+
+

pkg/proto/conversation/conversation.pb.go

@@ -0,0 +1,429 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: conversation/conversation.proto
+
+package conversation // import "./conversation"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type CommonResp struct {
+	ErrCode              int32    `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"`
+	ErrMsg               string   `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CommonResp) Reset()         { *m = CommonResp{} }
+func (m *CommonResp) String() string { return proto.CompactTextString(m) }
+func (*CommonResp) ProtoMessage()    {}
+func (*CommonResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_conversation_e6bf38f800b9bed2, []int{0}
+}
+func (m *CommonResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CommonResp.Unmarshal(m, b)
+}
+func (m *CommonResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CommonResp.Marshal(b, m, deterministic)
+}
+func (dst *CommonResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CommonResp.Merge(dst, src)
+}
+func (m *CommonResp) XXX_Size() int {
+	return xxx_messageInfo_CommonResp.Size(m)
+}
+func (m *CommonResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_CommonResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CommonResp proto.InternalMessageInfo
+
+func (m *CommonResp) GetErrCode() int32 {
+	if m != nil {
+		return m.ErrCode
+	}
+	return 0
+}
+
+func (m *CommonResp) GetErrMsg() string {
+	if m != nil {
+		return m.ErrMsg
+	}
+	return ""
+}
+
+type Conversation struct {
+	OwnerUserID          string   `protobuf:"bytes,1,opt,name=ownerUserID" json:"ownerUserID,omitempty"`
+	ConversationID       string   `protobuf:"bytes,2,opt,name=conversationID" json:"conversationID,omitempty"`
+	RecvMsgOpt           int32    `protobuf:"varint,3,opt,name=recvMsgOpt" json:"recvMsgOpt,omitempty"`
+	ConversationType     int32    `protobuf:"varint,4,opt,name=conversationType" json:"conversationType,omitempty"`
+	UserID               string   `protobuf:"bytes,5,opt,name=userID" json:"userID,omitempty"`
+	GroupID              string   `protobuf:"bytes,6,opt,name=groupID" json:"groupID,omitempty"`
+	UnreadCount          int32    `protobuf:"varint,7,opt,name=unreadCount" json:"unreadCount,omitempty"`
+	DraftTextTime        int64    `protobuf:"varint,8,opt,name=draftTextTime" json:"draftTextTime,omitempty"`
+	IsPinned             bool     `protobuf:"varint,9,opt,name=isPinned" json:"isPinned,omitempty"`
+	AttachedInfo         string   `protobuf:"bytes,10,opt,name=attachedInfo" json:"attachedInfo,omitempty"`
+	IsPrivateChat        bool     `protobuf:"varint,11,opt,name=isPrivateChat" json:"isPrivateChat,omitempty"`
+	GroupAtType          int32    `protobuf:"varint,12,opt,name=groupAtType" json:"groupAtType,omitempty"`
+	IsNotInGroup         bool     `protobuf:"varint,13,opt,name=isNotInGroup" json:"isNotInGroup,omitempty"`
+	Ex                   string   `protobuf:"bytes,14,opt,name=ex" json:"ex,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Conversation) Reset()         { *m = Conversation{} }
+func (m *Conversation) String() string { return proto.CompactTextString(m) }
+func (*Conversation) ProtoMessage()    {}
+func (*Conversation) Descriptor() ([]byte, []int) {
+	return fileDescriptor_conversation_e6bf38f800b9bed2, []int{1}
+}
+func (m *Conversation) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Conversation.Unmarshal(m, b)
+}
+func (m *Conversation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Conversation.Marshal(b, m, deterministic)
+}
+func (dst *Conversation) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Conversation.Merge(dst, src)
+}
+func (m *Conversation) XXX_Size() int {
+	return xxx_messageInfo_Conversation.Size(m)
+}
+func (m *Conversation) XXX_DiscardUnknown() {
+	xxx_messageInfo_Conversation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Conversation proto.InternalMessageInfo
+
+func (m *Conversation) GetOwnerUserID() string {
+	if m != nil {
+		return m.OwnerUserID
+	}
+	return ""
+}
+
+func (m *Conversation) GetConversationID() string {
+	if m != nil {
+		return m.ConversationID
+	}
+	return ""
+}
+
+func (m *Conversation) GetRecvMsgOpt() int32 {
+	if m != nil {
+		return m.RecvMsgOpt
+	}
+	return 0
+}
+
+func (m *Conversation) GetConversationType() int32 {
+	if m != nil {
+		return m.ConversationType
+	}
+	return 0
+}
+
+func (m *Conversation) GetUserID() string {
+	if m != nil {
+		return m.UserID
+	}
+	return ""
+}
+
+func (m *Conversation) GetGroupID() string {
+	if m != nil {
+		return m.GroupID
+	}
+	return ""
+}
+
+func (m *Conversation) GetUnreadCount() int32 {
+	if m != nil {
+		return m.UnreadCount
+	}
+	return 0
+}
+
+func (m *Conversation) GetDraftTextTime() int64 {
+	if m != nil {
+		return m.DraftTextTime
+	}
+	return 0
+}
+
+func (m *Conversation) GetIsPinned() bool {
+	if m != nil {
+		return m.IsPinned
+	}
+	return false
+}
+
+func (m *Conversation) GetAttachedInfo() string {
+	if m != nil {
+		return m.AttachedInfo
+	}
+	return ""
+}
+
+func (m *Conversation) GetIsPrivateChat() bool {
+	if m != nil {
+		return m.IsPrivateChat
+	}
+	return false
+}
+
+func (m *Conversation) GetGroupAtType() int32 {
+	if m != nil {
+		return m.GroupAtType
+	}
+	return 0
+}
+
+func (m *Conversation) GetIsNotInGroup() bool {
+	if m != nil {
+		return m.IsNotInGroup
+	}
+	return false
+}
+
+func (m *Conversation) GetEx() string {
+	if m != nil {
+		return m.Ex
+	}
+	return ""
+}
+
+type ModifyConversationFieldReq struct {
+	Conversation         *Conversation `protobuf:"bytes,1,opt,name=conversation" json:"conversation,omitempty"`
+	FieldType            int32         `protobuf:"varint,2,opt,name=fieldType" json:"fieldType,omitempty"`
+	UserIDList           []string      `protobuf:"bytes,3,rep,name=userIDList" json:"userIDList,omitempty"`
+	OperationID          string        `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *ModifyConversationFieldReq) Reset()         { *m = ModifyConversationFieldReq{} }
+func (m *ModifyConversationFieldReq) String() string { return proto.CompactTextString(m) }
+func (*ModifyConversationFieldReq) ProtoMessage()    {}
+func (*ModifyConversationFieldReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_conversation_e6bf38f800b9bed2, []int{2}
+}
+func (m *ModifyConversationFieldReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ModifyConversationFieldReq.Unmarshal(m, b)
+}
+func (m *ModifyConversationFieldReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ModifyConversationFieldReq.Marshal(b, m, deterministic)
+}
+func (dst *ModifyConversationFieldReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ModifyConversationFieldReq.Merge(dst, src)
+}
+func (m *ModifyConversationFieldReq) XXX_Size() int {
+	return xxx_messageInfo_ModifyConversationFieldReq.Size(m)
+}
+func (m *ModifyConversationFieldReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_ModifyConversationFieldReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ModifyConversationFieldReq proto.InternalMessageInfo
+
+func (m *ModifyConversationFieldReq) GetConversation() *Conversation {
+	if m != nil {
+		return m.Conversation
+	}
+	return nil
+}
+
+func (m *ModifyConversationFieldReq) GetFieldType() int32 {
+	if m != nil {
+		return m.FieldType
+	}
+	return 0
+}
+
+func (m *ModifyConversationFieldReq) GetUserIDList() []string {
+	if m != nil {
+		return m.UserIDList
+	}
+	return nil
+}
+
+func (m *ModifyConversationFieldReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+type ModifyConversationFieldResp struct {
+	CommonResp           *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *ModifyConversationFieldResp) Reset()         { *m = ModifyConversationFieldResp{} }
+func (m *ModifyConversationFieldResp) String() string { return proto.CompactTextString(m) }
+func (*ModifyConversationFieldResp) ProtoMessage()    {}
+func (*ModifyConversationFieldResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_conversation_e6bf38f800b9bed2, []int{3}
+}
+func (m *ModifyConversationFieldResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ModifyConversationFieldResp.Unmarshal(m, b)
+}
+func (m *ModifyConversationFieldResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ModifyConversationFieldResp.Marshal(b, m, deterministic)
+}
+func (dst *ModifyConversationFieldResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ModifyConversationFieldResp.Merge(dst, src)
+}
+func (m *ModifyConversationFieldResp) XXX_Size() int {
+	return xxx_messageInfo_ModifyConversationFieldResp.Size(m)
+}
+func (m *ModifyConversationFieldResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_ModifyConversationFieldResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ModifyConversationFieldResp proto.InternalMessageInfo
+
+func (m *ModifyConversationFieldResp) GetCommonResp() *CommonResp {
+	if m != nil {
+		return m.CommonResp
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*CommonResp)(nil), "conversation.CommonResp")
+	proto.RegisterType((*Conversation)(nil), "conversation.Conversation")
+	proto.RegisterType((*ModifyConversationFieldReq)(nil), "conversation.ModifyConversationFieldReq")
+	proto.RegisterType((*ModifyConversationFieldResp)(nil), "conversation.ModifyConversationFieldResp")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Conversation service
+
+type ConversationClient interface {
+	ModifyConversationField(ctx context.Context, in *ModifyConversationFieldReq, opts ...grpc.CallOption) (*ModifyConversationFieldResp, error)
+}
+
+type conversationClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewConversationClient(cc *grpc.ClientConn) ConversationClient {
+	return &conversationClient{cc}
+}
+
+func (c *conversationClient) ModifyConversationField(ctx context.Context, in *ModifyConversationFieldReq, opts ...grpc.CallOption) (*ModifyConversationFieldResp, error) {
+	out := new(ModifyConversationFieldResp)
+	err := grpc.Invoke(ctx, "/conversation.conversation/ModifyConversationField", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Conversation service
+
+type ConversationServer interface {
+	ModifyConversationField(context.Context, *ModifyConversationFieldReq) (*ModifyConversationFieldResp, error)
+}
+
+func RegisterConversationServer(s *grpc.Server, srv ConversationServer) {
+	s.RegisterService(&_Conversation_serviceDesc, srv)
+}
+
+func _Conversation_ModifyConversationField_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ModifyConversationFieldReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ConversationServer).ModifyConversationField(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/conversation.conversation/ModifyConversationField",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ConversationServer).ModifyConversationField(ctx, req.(*ModifyConversationFieldReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Conversation_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "conversation.conversation",
+	HandlerType: (*ConversationServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "ModifyConversationField",
+			Handler:    _Conversation_ModifyConversationField_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "conversation/conversation.proto",
+}
+
+func init() {
+	proto.RegisterFile("conversation/conversation.proto", fileDescriptor_conversation_e6bf38f800b9bed2)
+}
+
+var fileDescriptor_conversation_e6bf38f800b9bed2 = []byte{
+	// 475 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xdf, 0x8a, 0xd3, 0x40,
+	0x14, 0x87, 0x49, 0xbb, 0xdb, 0x6d, 0x4e, 0xbb, 0x45, 0xe6, 0x42, 0x87, 0xae, 0x7f, 0x42, 0x10,
+	0x89, 0x5e, 0x54, 0x58, 0x6f, 0x04, 0x61, 0x41, 0x53, 0x94, 0x80, 0xd5, 0x65, 0xa8, 0x08, 0xde,
+	0xc5, 0xe6, 0xb4, 0x3b, 0x60, 0x67, 0xe2, 0xcc, 0xb4, 0x76, 0x6f, 0x7c, 0x32, 0x9f, 0xc4, 0xa7,
+	0x91, 0x99, 0xb4, 0xbb, 0x33, 0x95, 0xc2, 0x5e, 0x9e, 0x2f, 0x27, 0xbf, 0xf9, 0x26, 0xe7, 0x04,
+	0x9e, 0xcc, 0xa4, 0x58, 0xa3, 0xd2, 0xa5, 0xe1, 0x52, 0xbc, 0xf4, 0x8b, 0x51, 0xad, 0xa4, 0x91,
+	0xa4, 0xef, 0xb3, 0xf4, 0x02, 0x20, 0x97, 0xcb, 0xa5, 0x14, 0x0c, 0x75, 0x4d, 0x28, 0x9c, 0xa0,
+	0x52, 0xb9, 0xac, 0x90, 0x46, 0x49, 0x94, 0x1d, 0xb3, 0x5d, 0x49, 0xee, 0x43, 0x07, 0x95, 0x9a,
+	0xe8, 0x05, 0x6d, 0x25, 0x51, 0x16, 0xb3, 0x6d, 0x95, 0xfe, 0x6d, 0x43, 0x3f, 0xf7, 0x02, 0x49,
+	0x02, 0x3d, 0xf9, 0x4b, 0xa0, 0xfa, 0xa2, 0x51, 0x15, 0x63, 0x17, 0x13, 0x33, 0x1f, 0x91, 0x67,
+	0x30, 0xf0, 0x15, 0x8a, 0xf1, 0x36, 0x72, 0x8f, 0x92, 0xc7, 0x00, 0x0a, 0x67, 0xeb, 0x89, 0x5e,
+	0x7c, 0xae, 0x0d, 0x6d, 0x3b, 0x1f, 0x8f, 0x90, 0x17, 0x70, 0xcf, 0x7f, 0x63, 0x7a, 0x5d, 0x23,
+	0x3d, 0x72, 0x5d, 0xff, 0x71, 0xab, 0xbf, 0x6a, 0x84, 0x8e, 0x1b, 0xfd, 0xa6, 0xb2, 0x17, 0x5e,
+	0x28, 0xb9, 0xaa, 0x8b, 0x31, 0xed, 0xb8, 0x07, 0xbb, 0xd2, 0xde, 0x63, 0x25, 0x14, 0x96, 0x55,
+	0x2e, 0x57, 0xc2, 0xd0, 0x13, 0x17, 0xec, 0x23, 0xf2, 0x14, 0x4e, 0x2b, 0x55, 0xce, 0xcd, 0x14,
+	0x37, 0x66, 0xca, 0x97, 0x48, 0xbb, 0x49, 0x94, 0xb5, 0x59, 0x08, 0xc9, 0x10, 0xba, 0x5c, 0x5f,
+	0x72, 0x21, 0xb0, 0xa2, 0x71, 0x12, 0x65, 0x5d, 0x76, 0x53, 0x93, 0x14, 0xfa, 0xa5, 0x31, 0xe5,
+	0xec, 0x0a, 0xab, 0x42, 0xcc, 0x25, 0x05, 0xa7, 0x10, 0x30, 0x7b, 0x0a, 0xd7, 0x97, 0x8a, 0xaf,
+	0x4b, 0x83, 0xf9, 0x55, 0x69, 0x68, 0xcf, 0x85, 0x84, 0xd0, 0xda, 0x3a, 0xf1, 0xb7, 0xc6, 0x7d,
+	0x86, 0x7e, 0x63, 0xeb, 0x21, 0x7b, 0x16, 0xd7, 0x9f, 0xa4, 0x29, 0xc4, 0x07, 0x4b, 0xe9, 0xa9,
+	0x8b, 0x09, 0x18, 0x19, 0x40, 0x0b, 0x37, 0x74, 0xe0, 0x2c, 0x5a, 0xb8, 0x49, 0xff, 0x44, 0x30,
+	0x9c, 0xc8, 0x8a, 0xcf, 0xaf, 0xfd, 0x11, 0xbf, 0xe7, 0xf8, 0xa3, 0x62, 0xf8, 0x93, 0x5c, 0x40,
+	0xb0, 0x4b, 0x6e, 0xd6, 0xbd, 0xf3, 0xe1, 0x28, 0x58, 0x3a, 0xff, 0x4d, 0x16, 0xf4, 0x93, 0x87,
+	0x10, 0xcf, 0x6d, 0x96, 0x53, 0x6e, 0x39, 0xe5, 0x5b, 0x60, 0xc7, 0xdf, 0x0c, 0xe9, 0x23, 0xd7,
+	0x76, 0xfc, 0xed, 0x2c, 0x66, 0x1e, 0x71, 0x8b, 0x56, 0xa3, 0xda, 0xed, 0xd0, 0xd1, 0x76, 0xd1,
+	0x6e, 0x51, 0xfa, 0x15, 0xce, 0x0e, 0xda, 0xeb, 0x9a, 0xbc, 0x06, 0x98, 0xdd, 0xac, 0xfe, 0x56,
+	0x9e, 0xee, 0xcb, 0xef, 0x9e, 0x33, 0xaf, 0xf7, 0xfc, 0x77, 0x78, 0x71, 0x22, 0xe0, 0xc1, 0x81,
+	0x83, 0x48, 0x16, 0x06, 0x1e, 0xfe, 0x9a, 0xc3, 0xe7, 0x77, 0xec, 0xd4, 0xf5, 0xbb, 0x47, 0xdf,
+	0xce, 0x46, 0xc1, 0xaf, 0xfd, 0xc6, 0x2f, 0xbe, 0x77, 0xdc, 0x8f, 0xfe, 0xea, 0x5f, 0x00, 0x00,
+	0x00, 0xff, 0xff, 0x8d, 0x8a, 0xf6, 0x60, 0x0b, 0x04, 0x00, 0x00,
+}

pkg/proto/conversation/conversation.proto

@@ -32,7 +32,7 @@ message ModifyConversationFieldReq{
 message ModifyConversationFieldResp{
   CommonResp  commonResp = 1;
 }
-service user {
+service conversation {
   rpc ModifyConversationField(ModifyConversationFieldReq)returns(ModifyConversationFieldResp);
 
 }

pkg/proto/friend/friend.proto

@@ -166,4 +166,7 @@ service friend{
   rpc addFriendResponse(AddFriendResponseReq) returns(AddFriendResponseResp);
   rpc setFriendRemark(SetFriendRemarkReq) returns(SetFriendRemarkResp);
   rpc importFriend(ImportFriendReq)  returns(ImportFriendResp);
+
+  rpc CheckFriendFromCache(IsFriendReq) returns(IsFriendResp);
+  rpc CheckBlockFromCache(IsInBlackListReq) returns(IsFriendResp);
 }

pkg/proto/office/office.pb.go

@@ -36,7 +36,7 @@ func (m *CommonResp) Reset()         { *m = CommonResp{} }
 func (m *CommonResp) String() string { return proto.CompactTextString(m) }
 func (*CommonResp) ProtoMessage()    {}
 func (*CommonResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{0}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{0}
 }
 func (m *CommonResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@@ -82,7 +82,7 @@ func (m *TagUser) Reset()         { *m = TagUser{} }
 func (m *TagUser) String() string { return proto.CompactTextString(m) }
 func (*TagUser) ProtoMessage()    {}
 func (*TagUser) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{1}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{1}
 }
 func (m *TagUser) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TagUser.Unmarshal(m, b)
@@ -129,7 +129,7 @@ func (m *Tag) Reset()         { *m = Tag{} }
 func (m *Tag) String() string { return proto.CompactTextString(m) }
 func (*Tag) ProtoMessage()    {}
 func (*Tag) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{2}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{2}
 }
 func (m *Tag) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Tag.Unmarshal(m, b)
@@ -182,7 +182,7 @@ func (m *GetUserTagsReq) Reset()         { *m = GetUserTagsReq{} }
 func (m *GetUserTagsReq) String() string { return proto.CompactTextString(m) }
 func (*GetUserTagsReq) ProtoMessage()    {}
 func (*GetUserTagsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{3}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{3}
 }
 func (m *GetUserTagsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserTagsReq.Unmarshal(m, b)
@@ -228,7 +228,7 @@ func (m *GetUserTagsResp) Reset()         { *m = GetUserTagsResp{} }
 func (m *GetUserTagsResp) String() string { return proto.CompactTextString(m) }
 func (*GetUserTagsResp) ProtoMessage()    {}
 func (*GetUserTagsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{4}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{4}
 }
 func (m *GetUserTagsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserTagsResp.Unmarshal(m, b)
@@ -276,7 +276,7 @@ func (m *CreateTagReq) Reset()         { *m = CreateTagReq{} }
 func (m *CreateTagReq) String() string { return proto.CompactTextString(m) }
 func (*CreateTagReq) ProtoMessage()    {}
 func (*CreateTagReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{5}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{5}
 }
 func (m *CreateTagReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateTagReq.Unmarshal(m, b)
@@ -335,7 +335,7 @@ func (m *CreateTagResp) Reset()         { *m = CreateTagResp{} }
 func (m *CreateTagResp) String() string { return proto.CompactTextString(m) }
 func (*CreateTagResp) ProtoMessage()    {}
 func (*CreateTagResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{6}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{6}
 }
 func (m *CreateTagResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateTagResp.Unmarshal(m, b)
@@ -375,7 +375,7 @@ func (m *DeleteTagReq) Reset()         { *m = DeleteTagReq{} }
 func (m *DeleteTagReq) String() string { return proto.CompactTextString(m) }
 func (*DeleteTagReq) ProtoMessage()    {}
 func (*DeleteTagReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{7}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{7}
 }
 func (m *DeleteTagReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteTagReq.Unmarshal(m, b)
@@ -427,7 +427,7 @@ func (m *DeleteTagResp) Reset()         { *m = DeleteTagResp{} }
 func (m *DeleteTagResp) String() string { return proto.CompactTextString(m) }
 func (*DeleteTagResp) ProtoMessage()    {}
 func (*DeleteTagResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{8}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{8}
 }
 func (m *DeleteTagResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteTagResp.Unmarshal(m, b)
@@ -470,7 +470,7 @@ func (m *SetTagReq) Reset()         { *m = SetTagReq{} }
 func (m *SetTagReq) String() string { return proto.CompactTextString(m) }
 func (*SetTagReq) ProtoMessage()    {}
 func (*SetTagReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{9}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{9}
 }
 func (m *SetTagReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetTagReq.Unmarshal(m, b)
@@ -543,7 +543,7 @@ func (m *SetTagResp) Reset()         { *m = SetTagResp{} }
 func (m *SetTagResp) String() string { return proto.CompactTextString(m) }
 func (*SetTagResp) ProtoMessage()    {}
 func (*SetTagResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{10}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{10}
 }
 func (m *SetTagResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetTagResp.Unmarshal(m, b)
@@ -587,7 +587,7 @@ func (m *SendMsg2TagReq) Reset()         { *m = SendMsg2TagReq{} }
 func (m *SendMsg2TagReq) String() string { return proto.CompactTextString(m) }
 func (*SendMsg2TagReq) ProtoMessage()    {}
 func (*SendMsg2TagReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{11}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{11}
 }
 func (m *SendMsg2TagReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SendMsg2TagReq.Unmarshal(m, b)
@@ -667,7 +667,7 @@ func (m *SendMsg2TagResp) Reset()         { *m = SendMsg2TagResp{} }
 func (m *SendMsg2TagResp) String() string { return proto.CompactTextString(m) }
 func (*SendMsg2TagResp) ProtoMessage()    {}
 func (*SendMsg2TagResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{12}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{12}
 }
 func (m *SendMsg2TagResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SendMsg2TagResp.Unmarshal(m, b)
@@ -707,7 +707,7 @@ func (m *GetTagSendLogsReq) Reset()         { *m = GetTagSendLogsReq{} }
 func (m *GetTagSendLogsReq) String() string { return proto.CompactTextString(m) }
 func (*GetTagSendLogsReq) ProtoMessage()    {}
 func (*GetTagSendLogsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{13}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{13}
 }
 func (m *GetTagSendLogsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetTagSendLogsReq.Unmarshal(m, b)
@@ -761,7 +761,7 @@ func (m *TagSendLog) Reset()         { *m = TagSendLog{} }
 func (m *TagSendLog) String() string { return proto.CompactTextString(m) }
 func (*TagSendLog) ProtoMessage()    {}
 func (*TagSendLog) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{14}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{14}
 }
 func (m *TagSendLog) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TagSendLog.Unmarshal(m, b)
@@ -815,7 +815,7 @@ func (m *GetTagSendLogsResp) Reset()         { *m = GetTagSendLogsResp{} }
 func (m *GetTagSendLogsResp) String() string { return proto.CompactTextString(m) }
 func (*GetTagSendLogsResp) ProtoMessage()    {}
 func (*GetTagSendLogsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{15}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{15}
 }
 func (m *GetTagSendLogsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetTagSendLogsResp.Unmarshal(m, b)
@@ -869,7 +869,7 @@ func (m *GetUserTagByIDReq) Reset()         { *m = GetUserTagByIDReq{} }
 func (m *GetUserTagByIDReq) String() string { return proto.CompactTextString(m) }
 func (*GetUserTagByIDReq) ProtoMessage()    {}
 func (*GetUserTagByIDReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{16}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{16}
 }
 func (m *GetUserTagByIDReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserTagByIDReq.Unmarshal(m, b)
@@ -922,7 +922,7 @@ func (m *GetUserTagByIDResp) Reset()         { *m = GetUserTagByIDResp{} }
 func (m *GetUserTagByIDResp) String() string { return proto.CompactTextString(m) }
 func (*GetUserTagByIDResp) ProtoMessage()    {}
 func (*GetUserTagByIDResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{17}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{17}
 }
 func (m *GetUserTagByIDResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserTagByIDResp.Unmarshal(m, b)
@@ -968,7 +968,7 @@ func (m *LikeUser) Reset()         { *m = LikeUser{} }
 func (m *LikeUser) String() string { return proto.CompactTextString(m) }
 func (*LikeUser) ProtoMessage()    {}
 func (*LikeUser) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{18}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{18}
 }
 func (m *LikeUser) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LikeUser.Unmarshal(m, b)
@@ -1014,7 +1014,7 @@ func (m *NotificationUser) Reset()         { *m = NotificationUser{} }
 func (m *NotificationUser) String() string { return proto.CompactTextString(m) }
 func (*NotificationUser) ProtoMessage()    {}
 func (*NotificationUser) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{19}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{19}
 }
 func (m *NotificationUser) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_NotificationUser.Unmarshal(m, b)
@@ -1066,7 +1066,7 @@ func (m *Comment) Reset()         { *m = Comment{} }
 func (m *Comment) String() string { return proto.CompactTextString(m) }
 func (*Comment) ProtoMessage()    {}
 func (*Comment) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{20}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{20}
 }
 func (m *Comment) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Comment.Unmarshal(m, b)
@@ -1154,7 +1154,7 @@ func (m *PermissionGroup) Reset()         { *m = PermissionGroup{} }
 func (m *PermissionGroup) String() string { return proto.CompactTextString(m) }
 func (*PermissionGroup) ProtoMessage()    {}
 func (*PermissionGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{21}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{21}
 }
 func (m *PermissionGroup) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PermissionGroup.Unmarshal(m, b)
@@ -1200,7 +1200,7 @@ func (m *WorkMomentUser) Reset()         { *m = WorkMomentUser{} }
 func (m *WorkMomentUser) String() string { return proto.CompactTextString(m) }
 func (*WorkMomentUser) ProtoMessage()    {}
 func (*WorkMomentUser) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{22}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{22}
 }
 func (m *WorkMomentUser) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WorkMomentUser.Unmarshal(m, b)
@@ -1256,7 +1256,7 @@ func (m *WorkMoment) Reset()         { *m = WorkMoment{} }
 func (m *WorkMoment) String() string { return proto.CompactTextString(m) }
 func (*WorkMoment) ProtoMessage()    {}
 func (*WorkMoment) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{23}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{23}
 }
 func (m *WorkMoment) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WorkMoment.Unmarshal(m, b)
@@ -1372,7 +1372,7 @@ func (m *CreateOneWorkMomentReq) Reset()         { *m = CreateOneWorkMomentReq{}
 func (m *CreateOneWorkMomentReq) String() string { return proto.CompactTextString(m) }
 func (*CreateOneWorkMomentReq) ProtoMessage()    {}
 func (*CreateOneWorkMomentReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{24}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{24}
 }
 func (m *CreateOneWorkMomentReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateOneWorkMomentReq.Unmarshal(m, b)
@@ -1417,7 +1417,7 @@ func (m *CreateOneWorkMomentResp) Reset()         { *m = CreateOneWorkMomentResp
 func (m *CreateOneWorkMomentResp) String() string { return proto.CompactTextString(m) }
 func (*CreateOneWorkMomentResp) ProtoMessage()    {}
 func (*CreateOneWorkMomentResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{25}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{25}
 }
 func (m *CreateOneWorkMomentResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateOneWorkMomentResp.Unmarshal(m, b)
@@ -1457,7 +1457,7 @@ func (m *DeleteOneWorkMomentReq) Reset()         { *m = DeleteOneWorkMomentReq{}
 func (m *DeleteOneWorkMomentReq) String() string { return proto.CompactTextString(m) }
 func (*DeleteOneWorkMomentReq) ProtoMessage()    {}
 func (*DeleteOneWorkMomentReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{26}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{26}
 }
 func (m *DeleteOneWorkMomentReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteOneWorkMomentReq.Unmarshal(m, b)
@@ -1509,7 +1509,7 @@ func (m *DeleteOneWorkMomentResp) Reset()         { *m = DeleteOneWorkMomentResp
 func (m *DeleteOneWorkMomentResp) String() string { return proto.CompactTextString(m) }
 func (*DeleteOneWorkMomentResp) ProtoMessage()    {}
 func (*DeleteOneWorkMomentResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{27}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{27}
 }
 func (m *DeleteOneWorkMomentResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteOneWorkMomentResp.Unmarshal(m, b)
@@ -1549,7 +1549,7 @@ func (m *LikeOneWorkMomentReq) Reset()         { *m = LikeOneWorkMomentReq{} }
 func (m *LikeOneWorkMomentReq) String() string { return proto.CompactTextString(m) }
 func (*LikeOneWorkMomentReq) ProtoMessage()    {}
 func (*LikeOneWorkMomentReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{28}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{28}
 }
 func (m *LikeOneWorkMomentReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LikeOneWorkMomentReq.Unmarshal(m, b)
@@ -1601,7 +1601,7 @@ func (m *LikeOneWorkMomentResp) Reset()         { *m = LikeOneWorkMomentResp{} }
 func (m *LikeOneWorkMomentResp) String() string { return proto.CompactTextString(m) }
 func (*LikeOneWorkMomentResp) ProtoMessage()    {}
 func (*LikeOneWorkMomentResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{29}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{29}
 }
 func (m *LikeOneWorkMomentResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LikeOneWorkMomentResp.Unmarshal(m, b)
@@ -1643,7 +1643,7 @@ func (m *CommentOneWorkMomentReq) Reset()         { *m = CommentOneWorkMomentReq
 func (m *CommentOneWorkMomentReq) String() string { return proto.CompactTextString(m) }
 func (*CommentOneWorkMomentReq) ProtoMessage()    {}
 func (*CommentOneWorkMomentReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{30}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{30}
 }
 func (m *CommentOneWorkMomentReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommentOneWorkMomentReq.Unmarshal(m, b)
@@ -1709,7 +1709,7 @@ func (m *CommentOneWorkMomentResp) Reset()         { *m = CommentOneWorkMomentRe
 func (m *CommentOneWorkMomentResp) String() string { return proto.CompactTextString(m) }
 func (*CommentOneWorkMomentResp) ProtoMessage()    {}
 func (*CommentOneWorkMomentResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{31}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{31}
 }
 func (m *CommentOneWorkMomentResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommentOneWorkMomentResp.Unmarshal(m, b)
@@ -1749,7 +1749,7 @@ func (m *GetWorkMomentByIDReq) Reset()         { *m = GetWorkMomentByIDReq{} }
 func (m *GetWorkMomentByIDReq) String() string { return proto.CompactTextString(m) }
 func (*GetWorkMomentByIDReq) ProtoMessage()    {}
 func (*GetWorkMomentByIDReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{32}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{32}
 }
 func (m *GetWorkMomentByIDReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetWorkMomentByIDReq.Unmarshal(m, b)
@@ -1802,7 +1802,7 @@ func (m *GetWorkMomentByIDResp) Reset()         { *m = GetWorkMomentByIDResp{} }
 func (m *GetWorkMomentByIDResp) String() string { return proto.CompactTextString(m) }
 func (*GetWorkMomentByIDResp) ProtoMessage()    {}
 func (*GetWorkMomentByIDResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{33}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{33}
 }
 func (m *GetWorkMomentByIDResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetWorkMomentByIDResp.Unmarshal(m, b)
@@ -1851,7 +1851,7 @@ func (m *ChangeWorkMomentPermissionReq) Reset()         { *m = ChangeWorkMomentP
 func (m *ChangeWorkMomentPermissionReq) String() string { return proto.CompactTextString(m) }
 func (*ChangeWorkMomentPermissionReq) ProtoMessage()    {}
 func (*ChangeWorkMomentPermissionReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{34}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{34}
 }
 func (m *ChangeWorkMomentPermissionReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ChangeWorkMomentPermissionReq.Unmarshal(m, b)
@@ -1917,7 +1917,7 @@ func (m *ChangeWorkMomentPermissionResp) Reset()         { *m = ChangeWorkMoment
 func (m *ChangeWorkMomentPermissionResp) String() string { return proto.CompactTextString(m) }
 func (*ChangeWorkMomentPermissionResp) ProtoMessage()    {}
 func (*ChangeWorkMomentPermissionResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{35}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{35}
 }
 func (m *ChangeWorkMomentPermissionResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ChangeWorkMomentPermissionResp.Unmarshal(m, b)
@@ -1946,8 +1946,9 @@ func (m *ChangeWorkMomentPermissionResp) GetCommonResp() *CommonResp {
 
 type GetUserWorkMomentsReq struct {
 	UserID               string                    `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
-	Pagination           *sdk_ws.RequestPagination `protobuf:"bytes,2,opt,name=Pagination" json:"Pagination,omitempty"`
+	OpUserID             string                    `protobuf:"bytes,2,opt,name=opUserID" json:"opUserID,omitempty"`
-	OperationID          string                    `protobuf:"bytes,3,opt,name=operationID" json:"operationID,omitempty"`
+	Pagination           *sdk_ws.RequestPagination `protobuf:"bytes,3,opt,name=Pagination" json:"Pagination,omitempty"`
+	OperationID          string                    `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
 	XXX_unrecognized     []byte                    `json:"-"`
 	XXX_sizecache        int32                     `json:"-"`
@@ -1957,7 +1958,7 @@ func (m *GetUserWorkMomentsReq) Reset()         { *m = GetUserWorkMomentsReq{} }
 func (m *GetUserWorkMomentsReq) String() string { return proto.CompactTextString(m) }
 func (*GetUserWorkMomentsReq) ProtoMessage()    {}
 func (*GetUserWorkMomentsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{36}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{36}
 }
 func (m *GetUserWorkMomentsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserWorkMomentsReq.Unmarshal(m, b)
@@ -1984,6 +1985,13 @@ func (m *GetUserWorkMomentsReq) GetUserID() string {
 	return ""
 }
 
+func (m *GetUserWorkMomentsReq) GetOpUserID() string {
+	if m != nil {
+		return m.OpUserID
+	}
+	return ""
+}
+
 func (m *GetUserWorkMomentsReq) GetPagination() *sdk_ws.RequestPagination {
 	if m != nil {
 		return m.Pagination
@@ -2011,7 +2019,7 @@ func (m *GetUserWorkMomentsResp) Reset()         { *m = GetUserWorkMomentsResp{}
 func (m *GetUserWorkMomentsResp) String() string { return proto.CompactTextString(m) }
 func (*GetUserWorkMomentsResp) ProtoMessage()    {}
 func (*GetUserWorkMomentsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{37}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{37}
 }
 func (m *GetUserWorkMomentsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserWorkMomentsResp.Unmarshal(m, b)
@@ -2065,7 +2073,7 @@ func (m *GetUserFriendWorkMomentsReq) Reset()         { *m = GetUserFriendWorkMo
 func (m *GetUserFriendWorkMomentsReq) String() string { return proto.CompactTextString(m) }
 func (*GetUserFriendWorkMomentsReq) ProtoMessage()    {}
 func (*GetUserFriendWorkMomentsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{38}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{38}
 }
 func (m *GetUserFriendWorkMomentsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserFriendWorkMomentsReq.Unmarshal(m, b)
@@ -2119,7 +2127,7 @@ func (m *GetUserFriendWorkMomentsResp) Reset()         { *m = GetUserFriendWorkM
 func (m *GetUserFriendWorkMomentsResp) String() string { return proto.CompactTextString(m) }
 func (*GetUserFriendWorkMomentsResp) ProtoMessage()    {}
 func (*GetUserFriendWorkMomentsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{39}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{39}
 }
 func (m *GetUserFriendWorkMomentsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserFriendWorkMomentsResp.Unmarshal(m, b)
@@ -2162,12 +2170,16 @@ func (m *GetUserFriendWorkMomentsResp) GetPagination() *sdk_ws.ResponsePaginatio
 
 type WorkMomentNotificationMsg struct {
 	NotificationMsgType  int32    `protobuf:"varint,1,opt,name=notificationMsgType" json:"notificationMsgType,omitempty"`
-	Comment              *Comment `protobuf:"bytes,2,opt,name=comment" json:"comment,omitempty"`
+	ReplyUserName        string   `protobuf:"bytes,2,opt,name=replyUserName" json:"replyUserName,omitempty"`
-	WorkMomentID         string   `protobuf:"bytes,3,opt,name=workMomentID" json:"workMomentID,omitempty"`
+	ReplyUserID          string   `protobuf:"bytes,3,opt,name=replyUserID" json:"replyUserID,omitempty"`
-	UserID               string   `protobuf:"bytes,4,opt,name=userID" json:"userID,omitempty"`
+	Content              string   `protobuf:"bytes,4,opt,name=content" json:"content,omitempty"`
-	UserName             string   `protobuf:"bytes,5,opt,name=userName" json:"userName,omitempty"`
+	ContentID            string   `protobuf:"bytes,5,opt,name=contentID" json:"contentID,omitempty"`
-	FaceURL              string   `protobuf:"bytes,6,opt,name=faceURL" json:"faceURL,omitempty"`
+	WorkMomentID         string   `protobuf:"bytes,6,opt,name=workMomentID" json:"workMomentID,omitempty"`
-	WorkMomentContent    string   `protobuf:"bytes,7,opt,name=workMomentContent" json:"workMomentContent,omitempty"`
+	UserID               string   `protobuf:"bytes,7,opt,name=userID" json:"userID,omitempty"`
+	UserName             string   `protobuf:"bytes,8,opt,name=userName" json:"userName,omitempty"`
+	FaceURL              string   `protobuf:"bytes,9,opt,name=faceURL" json:"faceURL,omitempty"`
+	WorkMomentContent    string   `protobuf:"bytes,10,opt,name=workMomentContent" json:"workMomentContent,omitempty"`
+	CreateTime           int32    `protobuf:"varint,11,opt,name=createTime" json:"createTime,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -2177,7 +2189,7 @@ func (m *WorkMomentNotificationMsg) Reset()         { *m = WorkMomentNotificatio
 func (m *WorkMomentNotificationMsg) String() string { return proto.CompactTextString(m) }
 func (*WorkMomentNotificationMsg) ProtoMessage()    {}
 func (*WorkMomentNotificationMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{40}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{40}
 }
 func (m *WorkMomentNotificationMsg) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_WorkMomentNotificationMsg.Unmarshal(m, b)
@@ -2204,11 +2216,32 @@ func (m *WorkMomentNotificationMsg) GetNotificationMsgType() int32 {
 	return 0
 }
 
-func (m *WorkMomentNotificationMsg) GetComment() *Comment {
+func (m *WorkMomentNotificationMsg) GetReplyUserName() string {
 	if m != nil {
-		return m.Comment
+		return m.ReplyUserName
 	}
-	return nil
+	return ""
+}
+
+func (m *WorkMomentNotificationMsg) GetReplyUserID() string {
+	if m != nil {
+		return m.ReplyUserID
+	}
+	return ""
+}
+
+func (m *WorkMomentNotificationMsg) GetContent() string {
+	if m != nil {
+		return m.Content
+	}
+	return ""
+}
+
+func (m *WorkMomentNotificationMsg) GetContentID() string {
+	if m != nil {
+		return m.ContentID
+	}
+	return ""
 }
 
 func (m *WorkMomentNotificationMsg) GetWorkMomentID() string {
@@ -2246,6 +2279,13 @@ func (m *WorkMomentNotificationMsg) GetWorkMomentContent() string {
 	return ""
 }
 
+func (m *WorkMomentNotificationMsg) GetCreateTime() int32 {
+	if m != nil {
+		return m.CreateTime
+	}
+	return 0
+}
+
 type SetUserWorkMomentsLevelReq struct {
 	UserID               string   `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
 	Level                int32    `protobuf:"varint,2,opt,name=level" json:"level,omitempty"`
@@ -2259,7 +2299,7 @@ func (m *SetUserWorkMomentsLevelReq) Reset()         { *m = SetUserWorkMomentsLe
 func (m *SetUserWorkMomentsLevelReq) String() string { return proto.CompactTextString(m) }
 func (*SetUserWorkMomentsLevelReq) ProtoMessage()    {}
 func (*SetUserWorkMomentsLevelReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{41}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{41}
 }
 func (m *SetUserWorkMomentsLevelReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetUserWorkMomentsLevelReq.Unmarshal(m, b)
@@ -2311,7 +2351,7 @@ func (m *SetUserWorkMomentsLevelResp) Reset()         { *m = SetUserWorkMomentsL
 func (m *SetUserWorkMomentsLevelResp) String() string { return proto.CompactTextString(m) }
 func (*SetUserWorkMomentsLevelResp) ProtoMessage()    {}
 func (*SetUserWorkMomentsLevelResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_office_02f43b66ea327245, []int{42}
+	return fileDescriptor_office_45d86d1784e03bf7, []int{42}
 }
 func (m *SetUserWorkMomentsLevelResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetUserWorkMomentsLevelResp.Unmarshal(m, b)
@@ -2955,109 +2995,110 @@ var _OfficeService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "office/office.proto",
 }
 
-func init() { proto.RegisterFile("office/office.proto", fileDescriptor_office_02f43b66ea327245) }
+func init() { proto.RegisterFile("office/office.proto", fileDescriptor_office_45d86d1784e03bf7) }
-
+
-var fileDescriptor_office_02f43b66ea327245 = []byte{
+var fileDescriptor_office_45d86d1784e03bf7 = []byte{
-	// 1604 bytes of a gzipped FileDescriptorProto
+	// 1621 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6e, 0x1c, 0xc5,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0x4f, 0x6f, 0xdc, 0x44,
-	0x13, 0xd7, 0xec, 0xa7, 0xb7, 0xd6, 0x89, 0xe3, 0xb6, 0x63, 0x6f, 0x26, 0xb1, 0xe3, 0xff, 0x24,
+	0x14, 0x97, 0x77, 0xb3, 0xd9, 0xec, 0xdb, 0xb4, 0x69, 0x26, 0xff, 0xb6, 0x6e, 0x93, 0x06, 0xb7,
-	0xf9, 0x2b, 0x7c, 0xc8, 0x46, 0x4b, 0x84, 0x10, 0x88, 0x08, 0xc5, 0x9b, 0x58, 0x0b, 0xde, 0xc4,
+	0x45, 0x15, 0xa0, 0x04, 0x85, 0x0a, 0x21, 0x10, 0x15, 0x6a, 0xb6, 0x8d, 0x16, 0xb2, 0x6d, 0x70,
-	0x8c, 0x6d, 0x22, 0x38, 0x60, 0x4d, 0xd6, 0xed, 0x61, 0xe4, 0xdd, 0x99, 0xc9, 0xf4, 0xd8, 0x26,
+	0x12, 0x2a, 0x38, 0x10, 0xb9, 0x9b, 0x89, 0xb1, 0xb2, 0xb1, 0x5d, 0x8f, 0x93, 0xd0, 0x13, 0x52,
-	0x27, 0xa4, 0x9c, 0xb9, 0x71, 0x80, 0x0b, 0x4f, 0xc1, 0x33, 0x70, 0xe0, 0x84, 0x38, 0xf0, 0x06,
+	0xcf, 0x70, 0xe2, 0xcc, 0xa7, 0xe0, 0x33, 0x70, 0xe0, 0x84, 0x38, 0xf0, 0x0d, 0xf8, 0x0e, 0x5c,
-	0xbc, 0x03, 0x57, 0xd4, 0x3d, 0x33, 0xfd, 0x31, 0x1f, 0xbb, 0x9b, 0x01, 0x24, 0x38, 0x79, 0xab,
+	0xd1, 0x8c, 0xed, 0xf9, 0x63, 0x8f, 0x77, 0x17, 0x17, 0x0e, 0x9c, 0xd6, 0xef, 0xcd, 0x9b, 0x37,
-	0xbb, 0xba, 0xba, 0xea, 0xd7, 0xd5, 0xbf, 0xae, 0x29, 0xc3, 0x92, 0x77, 0x72, 0xe2, 0x0c, 0xf1,
+	0xef, 0xfd, 0xe6, 0xcd, 0x9b, 0x37, 0x6f, 0x61, 0x21, 0x38, 0x39, 0xf1, 0x06, 0x78, 0x33, 0xf9,
-	0x56, 0xf4, 0x67, 0xd3, 0x0f, 0xbc, 0xd0, 0x43, 0x8d, 0x48, 0xd2, 0xff, 0xf7, 0xc4, 0xc7, 0xee,
+	0xd9, 0x08, 0xa3, 0x20, 0x0e, 0xd0, 0x74, 0x42, 0x99, 0x6f, 0x3c, 0x0d, 0xb1, 0x7f, 0xd4, 0xeb,
-	0x51, 0x7f, 0xb0, 0xe5, 0x9f, 0xda, 0x5b, 0x6c, 0x6a, 0x8b, 0x1c, 0x9f, 0x1e, 0x5d, 0x90, 0xad,
+	0x6f, 0x86, 0xa7, 0xee, 0x26, 0x1b, 0xda, 0x24, 0xc7, 0xa7, 0x47, 0x97, 0x64, 0xf3, 0x92, 0x24,
-	0x0b, 0x12, 0xa9, 0x1a, 0xf7, 0x01, 0xb6, 0xbd, 0xf1, 0xd8, 0x73, 0x4d, 0x4c, 0x7c, 0xd4, 0x81,
+	0xa2, 0xd6, 0x03, 0x80, 0xed, 0xe0, 0xec, 0x2c, 0xf0, 0x6d, 0x4c, 0x42, 0xd4, 0x81, 0x26, 0x8e,
-	0x26, 0x0e, 0x82, 0x6d, 0xef, 0x18, 0x77, 0xb4, 0x0d, 0xed, 0x6e, 0xdd, 0x4c, 0x44, 0xb4, 0x02,
+	0xa2, 0xed, 0xe0, 0x18, 0x77, 0x8c, 0x75, 0xe3, 0x5e, 0xc3, 0xce, 0x48, 0xb4, 0x0c, 0xd3, 0x38,
-	0x0d, 0x1c, 0x04, 0x03, 0x62, 0x77, 0x2a, 0x1b, 0xda, 0xdd, 0x96, 0x19, 0x4b, 0xc6, 0x07, 0xd0,
+	0x8a, 0xfa, 0xc4, 0xed, 0xd4, 0xd6, 0x8d, 0x7b, 0x2d, 0x3b, 0xa5, 0xac, 0x8f, 0xa1, 0x79, 0xe0,
-	0x3c, 0xb0, 0xec, 0x43, 0x82, 0x03, 0xaa, 0x72, 0x46, 0x70, 0xd0, 0xef, 0xb1, 0xb5, 0x2d, 0x33,
+	0xb8, 0x87, 0x04, 0x47, 0x54, 0xe4, 0x9c, 0xe0, 0xa8, 0xd7, 0x65, 0x73, 0x5b, 0x76, 0x4a, 0x21,
-	0x96, 0x90, 0x0e, 0x73, 0xf4, 0xd7, 0x63, 0x6b, 0x8c, 0xe3, 0xc5, 0x5c, 0x36, 0x9e, 0x41, 0xf5,
+	0x13, 0x66, 0xe8, 0xd7, 0x13, 0xe7, 0x0c, 0xa7, 0x93, 0x39, 0x6d, 0x3d, 0x87, 0xfa, 0x81, 0xe3,
-	0xc0, 0xb2, 0xd1, 0x32, 0xd4, 0x43, 0xcb, 0xe6, 0x2b, 0x23, 0x81, 0x7a, 0x13, 0x5a, 0xb6, 0xb4,
+	0xa2, 0x45, 0x68, 0xc4, 0x8e, 0xcb, 0x67, 0x26, 0x04, 0xb5, 0x26, 0x76, 0x5c, 0x69, 0x5e, 0x46,
-	0x2e, 0x11, 0xd1, 0x1b, 0x91, 0xc9, 0x5d, 0x87, 0x84, 0x9d, 0xea, 0x46, 0xf5, 0x6e, 0xbb, 0xbb,
+	0xa2, 0xb7, 0x13, 0x95, 0xbb, 0x1e, 0x89, 0x3b, 0xf5, 0xf5, 0xfa, 0xbd, 0xf6, 0xd6, 0xdc, 0x46,
-	0xb0, 0x19, 0x23, 0x10, 0x7b, 0x63, 0x72, 0x05, 0xe3, 0x23, 0xb8, 0xbc, 0x83, 0x43, 0x3a, 0x78,
+	0x8a, 0x40, 0x6a, 0x8d, 0xcd, 0x05, 0xac, 0x4f, 0xe1, 0xea, 0x0e, 0x8e, 0x29, 0xf3, 0xc0, 0x71,
-	0x60, 0xd9, 0xc4, 0xc4, 0xcf, 0x0b, 0x3d, 0xdd, 0x80, 0xb6, 0xe7, 0xe3, 0xc0, 0x0a, 0x1d, 0xcf,
+	0x89, 0x8d, 0x5f, 0x94, 0x5a, 0xba, 0x0e, 0xed, 0x20, 0xc4, 0x91, 0x13, 0x7b, 0x81, 0xdf, 0xeb,
-	0xed, 0xf7, 0xe2, 0x4d, 0xe5, 0x21, 0xe3, 0x04, 0x16, 0x14, 0x5b, 0xc4, 0x47, 0x5d, 0x80, 0x21,
+	0xa6, 0x8b, 0xca, 0x2c, 0xeb, 0x04, 0xe6, 0x14, 0x5d, 0x24, 0x44, 0x5b, 0x00, 0x03, 0x8e, 0x20,
-	0x47, 0x90, 0x19, 0x6c, 0x77, 0x51, 0xe2, 0x8d, 0xc0, 0xd6, 0x94, 0xb4, 0xd0, 0x4d, 0xa8, 0x85,
+	0x53, 0xd8, 0xde, 0x42, 0x99, 0x35, 0x02, 0x5b, 0x5b, 0x92, 0x42, 0xb7, 0x60, 0x2a, 0x76, 0x5c,
-	0x96, 0x4d, 0x3a, 0x15, 0xe6, 0x7b, 0x5b, 0xf2, 0xdd, 0x64, 0x13, 0xc6, 0x4b, 0x0d, 0xe6, 0xb7,
+	0xd2, 0xa9, 0x31, 0xdb, 0xdb, 0x92, 0xed, 0x36, 0x1b, 0xb0, 0x5e, 0x19, 0x30, 0xbb, 0x1d, 0x61,
-	0x03, 0x6c, 0x85, 0x98, 0x8e, 0xe1, 0xe7, 0x32, 0x16, 0x9a, 0x8a, 0x85, 0x08, 0xa6, 0xa2, 0x04,
+	0x27, 0xc6, 0x94, 0x87, 0x5f, 0xc8, 0x58, 0x18, 0x2a, 0x16, 0xc2, 0x99, 0x9a, 0xe2, 0xcc, 0x1a,
-	0xb3, 0x0e, 0x10, 0xfd, 0xe2, 0x28, 0xb5, 0x4c, 0x69, 0x24, 0x1d, 0x6c, 0x2d, 0x1b, 0xec, 0x36,
+	0x40, 0xf2, 0xc5, 0x51, 0x6a, 0xd9, 0x12, 0x27, 0xef, 0xec, 0x54, 0xd1, 0xd9, 0x6d, 0xb8, 0x22,
-	0x5c, 0x92, 0x7c, 0x28, 0x17, 0xaa, 0xf1, 0x05, 0xcc, 0xf7, 0xf0, 0x08, 0xf3, 0x40, 0x8a, 0xb0,
+	0xd9, 0x50, 0xcd, 0x55, 0xeb, 0x6b, 0x98, 0xed, 0xe2, 0x21, 0xe6, 0x8e, 0x94, 0x61, 0xcf, 0x43,
-	0xe7, 0x29, 0x50, 0x91, 0x53, 0x20, 0xe5, 0x64, 0x35, 0xd7, 0x49, 0xc9, 0x7e, 0x49, 0x27, 0x7f,
+	0xa0, 0x26, 0x87, 0x40, 0xce, 0xc8, 0xba, 0xd6, 0x48, 0x49, 0x7f, 0x45, 0x23, 0x7f, 0x37, 0xa0,
-	0xd5, 0xa0, 0xb5, 0x8f, 0xc3, 0x52, 0x2e, 0x76, 0xa0, 0xe9, 0xe2, 0x0b, 0x76, 0x32, 0x91, 0x7b,
+	0xb5, 0x8f, 0xe3, 0x4a, 0x26, 0x76, 0xa0, 0xe9, 0xe3, 0x4b, 0xb6, 0x33, 0x89, 0x79, 0x19, 0x89,
-	0x89, 0x88, 0x36, 0x01, 0x39, 0xee, 0x30, 0xc0, 0x16, 0xc1, 0x87, 0xe2, 0x24, 0x6a, 0xec, 0x24,
+	0x36, 0x00, 0x79, 0xfe, 0x20, 0xc2, 0x0e, 0xc1, 0x87, 0x62, 0x27, 0xa6, 0xd8, 0x4e, 0x68, 0x46,
-	0x72, 0x66, 0xd0, 0xeb, 0x70, 0x25, 0xc0, 0xc7, 0x67, 0x43, 0x59, 0xbb, 0xce, 0xb4, 0x33, 0xe3,
+	0xd0, 0x5b, 0x70, 0x2d, 0xc2, 0xc7, 0xe7, 0x03, 0x59, 0xba, 0xc1, 0xa4, 0x0b, 0xfc, 0x3c, 0x30,
-	0x69, 0x60, 0x1a, 0x59, 0x60, 0x3e, 0x04, 0x48, 0x42, 0x2a, 0x89, 0xca, 0xef, 0x1a, 0x5c, 0xde,
+	0xd3, 0x45, 0x60, 0x3e, 0x01, 0xc8, 0x5c, 0xaa, 0x88, 0xca, 0x9f, 0x06, 0x5c, 0xdd, 0xc7, 0xfe,
-	0xc7, 0xee, 0xf1, 0x80, 0xd8, 0x5d, 0x25, 0x0d, 0x99, 0x67, 0x1a, 0xf3, 0x2c, 0x11, 0xe9, 0x2d,
+	0x71, 0x9f, 0xb8, 0x5b, 0x4a, 0x18, 0x32, 0xcb, 0x0c, 0x66, 0x59, 0x46, 0xd2, 0x53, 0x7e, 0x98,
-	0x3f, 0x4c, 0xae, 0x64, 0x85, 0x4d, 0x71, 0x19, 0xdd, 0x80, 0xd6, 0x4e, 0xe0, 0x9d, 0xf9, 0x52,
+	0x1d, 0xc9, 0x1a, 0x1b, 0xe2, 0x34, 0xba, 0x09, 0xad, 0x9d, 0x28, 0x38, 0x0f, 0xa5, 0x48, 0x14,
-	0x26, 0x8a, 0x01, 0x0a, 0x37, 0xc1, 0xee, 0x31, 0xcf, 0xc1, 0x58, 0xa2, 0x70, 0xd0, 0x5f, 0x38,
+	0x0c, 0x0a, 0x37, 0xc1, 0xfe, 0x31, 0x8f, 0xc1, 0x94, 0xa2, 0x70, 0xd0, 0x2f, 0x1c, 0xed, 0x0d,
-	0xd8, 0x1b, 0x59, 0xe1, 0x89, 0x17, 0x8c, 0xfb, 0xbd, 0x4e, 0x9d, 0xb1, 0x52, 0x66, 0x9c, 0xfa,
+	0x9d, 0xf8, 0x24, 0x88, 0xce, 0x7a, 0xdd, 0x4e, 0x83, 0x65, 0xa5, 0x02, 0x9f, 0xda, 0x35, 0x08,
-	0x35, 0xf4, 0xdc, 0x10, 0xbb, 0x61, 0x0c, 0x45, 0x22, 0xa6, 0x81, 0x6a, 0x66, 0x81, 0x7a, 0x08,
+	0xfc, 0x18, 0xfb, 0x71, 0x0a, 0x45, 0x46, 0xe6, 0x81, 0x6a, 0x16, 0x81, 0x7a, 0x04, 0x73, 0x8a,
-	0x0b, 0x4a, 0x94, 0x25, 0xd1, 0xfa, 0x56, 0x83, 0xc5, 0x1d, 0x06, 0x38, 0xb5, 0xb6, 0xeb, 0x45,
+	0x97, 0x15, 0xd1, 0xfa, 0xd1, 0x80, 0xf9, 0x1d, 0x06, 0x38, 0xd5, 0xb6, 0x1b, 0x24, 0xa9, 0xa6,
-	0x54, 0xd3, 0x03, 0xd8, 0xb3, 0x6c, 0xc7, 0x65, 0x9b, 0xc5, 0x96, 0x6e, 0x6f, 0x12, 0x1c, 0x9c,
+	0x0b, 0xb0, 0xe7, 0xb8, 0x9e, 0xcf, 0x16, 0x4b, 0x35, 0xdd, 0xd9, 0x20, 0x38, 0xba, 0xc0, 0xd1,
-	0xe3, 0xe0, 0xc8, 0xf2, 0x9d, 0x23, 0xdf, 0x0a, 0xac, 0x31, 0xd9, 0x34, 0xf1, 0xf3, 0x33, 0x4c,
+	0x91, 0x13, 0x7a, 0x47, 0xa1, 0x13, 0x39, 0x67, 0x64, 0xc3, 0xc6, 0x2f, 0xce, 0x31, 0x89, 0x85,
-	0x42, 0xa1, 0x6b, 0x4a, 0xeb, 0x0a, 0xef, 0xf8, 0xf4, 0xeb, 0xe1, 0x01, 0x08, 0x8f, 0x14, 0xde,
+	0xac, 0x2d, 0xcd, 0x2b, 0x3d, 0xe3, 0xe3, 0x8f, 0x47, 0x00, 0x20, 0x2c, 0x52, 0xf2, 0xa6, 0x31,
-	0xd4, 0xa6, 0xf0, 0xa6, 0x8c, 0x69, 0x45, 0xc5, 0x54, 0x87, 0x39, 0x7a, 0x02, 0x07, 0x4e, 0x9c,
+	0x26, 0x6f, 0xca, 0x98, 0xd6, 0x54, 0x4c, 0x4d, 0x98, 0xa1, 0x3b, 0x70, 0xe0, 0xa5, 0x31, 0x5f,
-	0xf3, 0x55, 0x93, 0xcb, 0xc6, 0x4f, 0x1a, 0xa0, 0x34, 0x0c, 0x25, 0x59, 0xf2, 0xa1, 0x82, 0x5d,
+	0xb7, 0x39, 0x6d, 0xfd, 0x62, 0x00, 0xca, 0xc3, 0x50, 0x31, 0x4b, 0x3e, 0x52, 0xb0, 0xab, 0xb1,
-	0x85, 0xad, 0xb9, 0x93, 0x8b, 0x1d, 0xf1, 0x3d, 0x97, 0xe0, 0x02, 0xf0, 0xee, 0x41, 0x3b, 0x14,
+	0x39, 0x77, 0xb5, 0xd8, 0x91, 0x30, 0xf0, 0x09, 0x2e, 0x01, 0xef, 0x3e, 0xb4, 0x63, 0x61, 0x4d,
-	0xde, 0xc4, 0xef, 0x05, 0x92, 0xe2, 0x8e, 0xa7, 0x4c, 0x59, 0xcd, 0x18, 0xb2, 0xd3, 0x8c, 0x99,
+	0x7a, 0x5f, 0x20, 0xc9, 0xef, 0x74, 0xc8, 0x96, 0xc5, 0xac, 0x01, 0xdb, 0xcd, 0x34, 0xd3, 0x3f,
-	0xfe, 0xc1, 0x8b, 0x7e, 0xef, 0x9f, 0x20, 0x2f, 0x9b, 0x61, 0xa5, 0x6c, 0x52, 0x12, 0xab, 0x35,
+	0x7c, 0xd9, 0xeb, 0xfe, 0x17, 0xc9, 0xcb, 0x65, 0x58, 0x29, 0x8b, 0x54, 0xc4, 0x6a, 0x15, 0xea,
-	0xa8, 0x86, 0x96, 0x1d, 0x83, 0xa4, 0x3c, 0x28, 0x74, 0xdc, 0xb8, 0x0f, 0x73, 0xbb, 0xce, 0x29,
+	0xb1, 0xe3, 0xa6, 0x20, 0x29, 0x17, 0x0a, 0xe5, 0x5b, 0x0f, 0x60, 0x66, 0xd7, 0x3b, 0xc5, 0x95,
-	0x2e, 0xfd, 0x4e, 0x3f, 0x82, 0x2b, 0x8f, 0xbd, 0xd0, 0x39, 0x71, 0x86, 0xcc, 0xf5, 0xd2, 0x76,
+	0xef, 0xe9, 0xc7, 0x70, 0xed, 0x49, 0x10, 0x7b, 0x27, 0xde, 0x80, 0x99, 0x5e, 0x59, 0xcf, 0x5f,
-	0xfe, 0xd0, 0xa0, 0x49, 0x23, 0xa0, 0x59, 0x54, 0x62, 0x3d, 0xcd, 0xc9, 0x13, 0x6b, 0x88, 0x0f,
+	0x06, 0x34, 0xa9, 0x07, 0x34, 0x8a, 0x2a, 0xcc, 0xa7, 0x31, 0x79, 0xe2, 0x0c, 0xf0, 0xa1, 0xbd,
-	0xcd, 0xdd, 0x84, 0x6c, 0x63, 0x91, 0x82, 0x1d, 0x60, 0x7f, 0xf4, 0x22, 0xe2, 0xc8, 0xe4, 0x39,
+	0x9b, 0x25, 0xdb, 0x94, 0xa4, 0x60, 0x47, 0x38, 0x1c, 0xbe, 0x4c, 0x72, 0x64, 0x76, 0x9d, 0x49,
-	0x93, 0x86, 0xd0, 0x6d, 0xb8, 0xc4, 0x45, 0x66, 0xbc, 0xce, 0x74, 0xd4, 0x41, 0xca, 0x55, 0x71,
+	0x2c, 0x74, 0x07, 0xae, 0x70, 0x92, 0x29, 0x6f, 0x30, 0x19, 0x95, 0x49, 0x73, 0x55, 0x1a, 0xe6,
-	0x9a, 0x73, 0x5a, 0x15, 0x03, 0xf2, 0x9d, 0x68, 0xaa, 0x77, 0x62, 0x1d, 0x60, 0x18, 0x3d, 0x96,
+	0x3c, 0xad, 0x0a, 0x86, 0x7c, 0x26, 0x9a, 0xea, 0x99, 0x58, 0x03, 0x18, 0x24, 0x97, 0x25, 0x3d,
-	0xf4, 0x56, 0xcc, 0x31, 0x9e, 0x92, 0x46, 0x8c, 0x3e, 0x2c, 0xec, 0xe1, 0x60, 0xec, 0x10, 0xe2,
+	0x15, 0x33, 0x2c, 0x4f, 0x49, 0x1c, 0xab, 0x07, 0x73, 0x7b, 0x38, 0x3a, 0xf3, 0x08, 0xf1, 0x02,
-	0x78, 0x2e, 0x23, 0x3f, 0xba, 0x95, 0x4d, 0x7f, 0x48, 0xaf, 0xba, 0x18, 0xa0, 0x5b, 0x31, 0x81,
+	0x9f, 0x25, 0x3f, 0xba, 0x94, 0x4b, 0x3f, 0xa4, 0x5b, 0x5d, 0x30, 0xe8, 0x52, 0x8c, 0xe0, 0x51,
-	0x67, 0x55, 0x22, 0x1a, 0x3d, 0xb8, 0xfc, 0xd4, 0x0b, 0x4e, 0x07, 0x1e, 0x85, 0xb1, 0xf4, 0x51,
+	0x95, 0x91, 0x56, 0x17, 0xae, 0x3e, 0x0b, 0xa2, 0xd3, 0x7e, 0x40, 0x61, 0xac, 0xbc, 0x15, 0xdf,
-	0x7c, 0x53, 0x03, 0x10, 0x66, 0x90, 0x01, 0xf3, 0x17, 0x5c, 0xe2, 0x86, 0x94, 0xb1, 0x42, 0x1a,
+	0x4f, 0x01, 0x08, 0x35, 0xc8, 0x82, 0xd9, 0x4b, 0x4e, 0x71, 0x45, 0x0a, 0xaf, 0x34, 0x0d, 0xc9,
-	0x92, 0xb7, 0xa9, 0x16, 0x9f, 0x58, 0x4d, 0x3d, 0x31, 0x09, 0xcb, 0xba, 0x8a, 0xe5, 0x7b, 0x30,
+	0xcb, 0xd4, 0xcb, 0x77, 0x6c, 0x4a, 0xdd, 0x31, 0x09, 0xcb, 0x86, 0x8a, 0xe5, 0x87, 0x30, 0x3b,
-	0x3f, 0x8a, 0xb3, 0x95, 0x51, 0x55, 0x83, 0x5d, 0xd9, 0x95, 0x24, 0xab, 0xd5, 0xe0, 0x4d, 0x45,
+	0x4c, 0xa3, 0x95, 0xa5, 0xaa, 0x69, 0x76, 0x64, 0x97, 0xb3, 0xa8, 0x56, 0x9d, 0xb7, 0x15, 0x59,
-	0x97, 0x52, 0xdc, 0x30, 0x4a, 0x30, 0xd2, 0x69, 0xaa, 0x14, 0x17, 0x27, 0x9e, 0xc9, 0x15, 0xe8,
+	0x9a, 0xe2, 0x06, 0x49, 0x80, 0x91, 0x4e, 0x53, 0x4d, 0x71, 0x69, 0xe0, 0xd9, 0x5c, 0x80, 0x6e,
-	0xa1, 0xf9, 0xfc, 0x50, 0x92, 0x43, 0x13, 0x23, 0xe8, 0x11, 0x20, 0x21, 0x71, 0x77, 0x5a, 0x13,
+	0x5a, 0xc8, 0x37, 0x25, 0xdb, 0x34, 0xc1, 0x41, 0x8f, 0x01, 0x09, 0x8a, 0x9b, 0xd3, 0x1a, 0x69,
-	0xdd, 0xc9, 0x59, 0x81, 0xfa, 0xb0, 0xe4, 0xab, 0x87, 0xcf, 0x0c, 0x01, 0x33, 0xb4, 0x9a, 0x18,
+	0x8e, 0x66, 0x06, 0xea, 0xc1, 0x42, 0xa8, 0x6e, 0x3e, 0x53, 0x04, 0x4c, 0xd1, 0x4a, 0xa6, 0x28,
-	0x4a, 0xe5, 0x87, 0x99, 0xb7, 0x06, 0xbd, 0x03, 0x60, 0x85, 0xdc, 0x95, 0xf6, 0x44, 0x57, 0x24,
+	0x17, 0x1f, 0xb6, 0x6e, 0x0e, 0x7a, 0x1f, 0xc0, 0x89, 0xb9, 0x29, 0xed, 0x91, 0xa6, 0x48, 0x92,
-	0xcd, 0x54, 0x7e, 0xce, 0x67, 0xf2, 0xd3, 0x85, 0x95, 0xa8, 0xd8, 0x7b, 0xe2, 0x62, 0x61, 0x86,
+	0xb9, 0xf8, 0x9c, 0x2d, 0xc4, 0xa7, 0x0f, 0xcb, 0x49, 0xb1, 0xf7, 0xd4, 0xc7, 0x42, 0x0d, 0x4d,
-	0x92, 0x5e, 0x17, 0x40, 0x64, 0x41, 0x9a, 0x8e, 0x24, 0x55, 0x49, 0x6b, 0x86, 0x4a, 0x7a, 0x00,
+	0x7a, 0x5b, 0x00, 0x22, 0x0a, 0xf2, 0xe9, 0x48, 0x12, 0x95, 0xa4, 0x26, 0xa8, 0xa4, 0xfb, 0xb0,
-	0xab, 0xb9, 0xfb, 0x95, 0x7c, 0x7d, 0xcf, 0x61, 0x25, 0x2a, 0x03, 0x33, 0xee, 0xff, 0x95, 0xc4,
+	0xa2, 0x5d, 0xaf, 0xe2, 0xed, 0x7b, 0x01, 0xcb, 0x49, 0x19, 0x58, 0x30, 0xff, 0x75, 0x02, 0x7b,
-	0x9e, 0xce, 0xe0, 0x03, 0x58, 0xcd, 0xdd, 0xb7, 0x64, 0x18, 0x21, 0x2c, 0x53, 0x9e, 0xce, 0x04,
+	0x7c, 0x06, 0xef, 0xc3, 0x8a, 0x76, 0xdd, 0x8a, 0x6e, 0xc4, 0xb0, 0x48, 0xf3, 0x74, 0xc1, 0x89,
-	0x51, 0x74, 0xc1, 0x0d, 0x98, 0x7f, 0x2a, 0x07, 0x17, 0xb9, 0xaf, 0x8c, 0xcd, 0x10, 0xc4, 0xc7,
+	0xb2, 0x03, 0x6e, 0xc1, 0xec, 0x33, 0xd9, 0xb9, 0xc4, 0x7c, 0x85, 0x37, 0x81, 0x13, 0x9f, 0xc1,
-	0x70, 0x35, 0x67, 0xd7, 0x92, 0x21, 0xfc, 0xa8, 0xc1, 0x6a, 0x7c, 0xd3, 0x5e, 0x25, 0x8c, 0x8b,
+	0x92, 0x66, 0xd5, 0x8a, 0x2e, 0xfc, 0x6c, 0xc0, 0x4a, 0x7a, 0xd2, 0xfe, 0x89, 0x1b, 0x97, 0x1a,
-	0x9c, 0x30, 0x2e, 0x52, 0x61, 0xc8, 0x04, 0x5f, 0xcd, 0x12, 0xbc, 0x44, 0x28, 0xb5, 0x89, 0x45,
+	0x37, 0x2e, 0x73, 0x6e, 0xc8, 0x09, 0xbe, 0x5e, 0x4c, 0xf0, 0x52, 0x42, 0x99, 0x1a, 0x59, 0x04,
-	0x60, 0x3d, 0x0b, 0xc1, 0x63, 0xe8, 0xe4, 0x3b, 0x5d, 0x12, 0x85, 0xaf, 0x60, 0x79, 0x07, 0x87,
+	0x36, 0x8a, 0x10, 0x3c, 0x81, 0x8e, 0xde, 0xe8, 0x8a, 0x28, 0x7c, 0x0b, 0x8b, 0x3b, 0x38, 0x16,
-	0xc2, 0x50, 0x52, 0x41, 0xcc, 0x92, 0x8d, 0x3a, 0xcc, 0x79, 0xfe, 0xa1, 0x9c, 0x8f, 0x5c, 0x9e,
+	0x8a, 0xb2, 0x0a, 0x62, 0x92, 0x68, 0x34, 0x61, 0x26, 0x08, 0x0f, 0xe5, 0x78, 0xe4, 0xf4, 0x04,
-	0xe1, 0x30, 0xbf, 0x86, 0xab, 0x39, 0x3b, 0x97, 0x2c, 0x2b, 0xd4, 0xbb, 0x5f, 0x99, 0xe5, 0xee,
+	0x9b, 0xf9, 0x1d, 0x2c, 0x69, 0x56, 0xae, 0x58, 0x56, 0xa8, 0x67, 0xbf, 0x36, 0xc9, 0xd9, 0xb7,
-	0x1b, 0xbf, 0x69, 0xb0, 0xb6, 0xfd, 0xa5, 0xe5, 0xda, 0x12, 0x8e, 0x82, 0xda, 0xfe, 0x0e, 0x10,
+	0xfe, 0x30, 0x60, 0x75, 0xfb, 0x1b, 0xc7, 0x77, 0x25, 0x1c, 0x45, 0x6a, 0xfb, 0x37, 0x40, 0x50,
-	0x54, 0xda, 0xae, 0x66, 0x68, 0xbb, 0x0b, 0xcb, 0x2a, 0x09, 0x2b, 0x9f, 0x5e, 0xb9, 0x73, 0x33,
+	0xd3, 0x76, 0xbd, 0x90, 0xb6, 0xb7, 0x60, 0x51, 0x4d, 0xc2, 0xca, 0xd3, 0x4b, 0x3b, 0x36, 0x41,
-	0xa4, 0xc8, 0x01, 0xac, 0x4f, 0x0a, 0xab, 0x64, 0xa2, 0x7c, 0xa7, 0xb1, 0xf3, 0xa2, 0x9e, 0x08,
+	0x88, 0x1c, 0xc0, 0xda, 0x28, 0xb7, 0xaa, 0x1f, 0x97, 0xa5, 0xb4, 0x06, 0x14, 0x7a, 0x47, 0x76,
-	0xbb, 0x13, 0xbb, 0x14, 0xbd, 0x9c, 0xb2, 0xf8, 0xd5, 0x3f, 0x29, 0xa6, 0x27, 0xd2, 0xcf, 0x1a,
+	0x29, 0x46, 0x21, 0xa3, 0x3e, 0x37, 0xea, 0x15, 0x9f, 0x1b, 0xe3, 0x5b, 0x03, 0xbf, 0x1a, 0xb0,
-	0xac, 0xe4, 0x79, 0x56, 0x32, 0x95, 0xee, 0x41, 0x5b, 0x1c, 0x70, 0xd2, 0xfa, 0xc8, 0xcb, 0x25,
+	0xac, 0xb3, 0xba, 0x62, 0x98, 0xdd, 0x87, 0xb6, 0xd8, 0xfc, 0xac, 0x2d, 0xa2, 0x8b, 0x33, 0x59,
-	0x59, 0x2d, 0xf5, 0x0d, 0x50, 0x2d, 0xf9, 0x0d, 0x60, 0xfc, 0xa0, 0xc1, 0xf5, 0x38, 0x96, 0x47,
+	0x2c, 0xf7, 0x3e, 0xa8, 0x57, 0x7c, 0x1f, 0x58, 0x3f, 0x19, 0x70, 0x23, 0xf5, 0xe5, 0x71, 0xe4,
-	0x81, 0x83, 0xdd, 0xe3, 0x7f, 0x19, 0xd6, 0xbf, 0x68, 0x70, 0xa3, 0xd8, 0xbf, 0xff, 0x22, 0xe2,
+	0x61, 0xff, 0x78, 0xc2, 0x7d, 0xe8, 0x6a, 0x9e, 0x27, 0xaf, 0x8d, 0xb5, 0xe6, 0x40, 0xff, 0x66,
-	0xdf, 0x57, 0xe0, 0x9a, 0xd8, 0x42, 0xfe, 0x78, 0x18, 0x10, 0x1b, 0xbd, 0x05, 0x4b, 0xae, 0x3a,
+	0xc0, 0xcd, 0x72, 0xfb, 0xfe, 0x8f, 0x88, 0xff, 0x50, 0x87, 0xeb, 0x62, 0x09, 0xf9, 0x61, 0xd1,
-	0x74, 0xf0, 0xc2, 0x4f, 0x9a, 0x8e, 0x79, 0x53, 0xe8, 0x35, 0x4a, 0xee, 0x63, 0x89, 0x86, 0x32,
+	0x27, 0x2e, 0x7a, 0x17, 0x16, 0x7c, 0x95, 0x75, 0xf0, 0x32, 0xcc, 0x1a, 0x92, 0xba, 0xa1, 0x62,
-	0x65, 0x5d, 0x32, 0x9f, 0xa1, 0x97, 0xea, 0xc4, 0x17, 0xbf, 0x56, 0x58, 0xca, 0xd6, 0x8b, 0x4b,
+	0x65, 0x5f, 0xd3, 0x55, 0xf6, 0xaf, 0x73, 0x81, 0x28, 0xaf, 0x82, 0x46, 0xfe, 0x55, 0x90, 0xcf,
-	0xd9, 0x86, 0x5a, 0xca, 0xbe, 0x09, 0x8b, 0xc2, 0xfa, 0xb6, 0xf2, 0x81, 0x90, 0x9d, 0x30, 0x46,
+	0x67, 0xd3, 0x23, 0x4b, 0x8c, 0x66, 0x69, 0xed, 0x3c, 0x53, 0x5e, 0x3b, 0xb7, 0xd4, 0xda, 0xf9,
-	0xa0, 0xef, 0x67, 0xee, 0xd5, 0x2e, 0x3e, 0xc7, 0xa3, 0x29, 0xdf, 0x98, 0x23, 0xaa, 0xc3, 0xc2,
+	0x1d, 0x98, 0x17, 0xda, 0xb7, 0x53, 0x9b, 0x81, 0xc9, 0x14, 0x07, 0x72, 0xb5, 0x5f, 0xbb, 0x50,
-	0xaf, 0x9b, 0x91, 0x30, 0x43, 0x6a, 0x7d, 0x02, 0xd7, 0x0b, 0x77, 0x2b, 0x97, 0x58, 0xdd, 0x97,
+	0xfb, 0x0d, 0xc1, 0xdc, 0x2f, 0x1c, 0xe6, 0x5d, 0x7c, 0x81, 0x87, 0x63, 0x1e, 0xbd, 0x43, 0x2a,
-	0x00, 0x97, 0x9e, 0x30, 0x8d, 0x7d, 0x1c, 0x9c, 0x3b, 0x43, 0x8c, 0xee, 0x43, 0x5b, 0xea, 0x8b,
+	0xc3, 0xd0, 0x6e, 0xd8, 0x09, 0x31, 0x41, 0x3c, 0x7f, 0x0e, 0x37, 0x4a, 0x57, 0xab, 0x16, 0xcd,
-	0x22, 0x5e, 0x90, 0xaa, 0x8d, 0x57, 0x7d, 0x35, 0x77, 0x9c, 0xf8, 0xe8, 0x5d, 0x68, 0xf1, 0x56,
+	0x5b, 0xaf, 0x00, 0xae, 0x3c, 0x65, 0x12, 0xfb, 0x38, 0xba, 0xf0, 0x06, 0x18, 0x3d, 0x80, 0xb6,
-	0x23, 0x5a, 0xe6, 0xdb, 0x4b, 0x1d, 0x50, 0xfd, 0x6a, 0xce, 0x68, 0xb4, 0x92, 0xf7, 0xff, 0xc4,
+	0xd4, 0xa8, 0x45, 0xbc, 0x42, 0x56, 0x3b, 0xc1, 0xe6, 0x8a, 0x96, 0x4f, 0x42, 0xf4, 0x01, 0xb4,
-	0x4a, 0xb9, 0xe5, 0x28, 0x56, 0xaa, 0x8d, 0xc2, 0x2d, 0x68, 0x44, 0x0d, 0x32, 0xb4, 0x98, 0x28,
+	0x78, 0xef, 0x13, 0x2d, 0xf2, 0xe5, 0xa5, 0x96, 0xac, 0xb9, 0xa4, 0xe1, 0x26, 0x33, 0x79, 0x43,
-	0xf0, 0x1e, 0xa0, 0x8e, 0xd2, 0x43, 0xc4, 0xa7, 0x41, 0x4a, 0x8d, 0x22, 0x11, 0xa4, 0xda, 0x23,
+	0x52, 0xcc, 0x94, 0x7b, 0xa0, 0x62, 0xa6, 0xda, 0xb9, 0xdc, 0x84, 0xe9, 0xa4, 0x63, 0x87, 0xe6,
-	0x13, 0x41, 0xa6, 0xbb, 0x4a, 0x3b, 0xac, 0x11, 0x2d, 0x75, 0x46, 0xd0, 0x35, 0x09, 0x0f, 0xb5,
+	0x33, 0x01, 0xde, 0x94, 0x34, 0x51, 0x9e, 0x45, 0x42, 0xea, 0xa4, 0xd4, 0xb9, 0x12, 0x4e, 0xaa,
-	0x71, 0xa4, 0xeb, 0x45, 0x53, 0xdc, 0x90, 0xd4, 0x36, 0x50, 0x0c, 0xa9, 0x3d, 0x0b, 0xc5, 0x50,
+	0x4d, 0x3b, 0xe1, 0x64, 0xbe, 0xcd, 0xb5, 0xc3, 0x3a, 0xe3, 0x52, 0xab, 0x06, 0x5d, 0x97, 0xf0,
-	0xba, 0xd3, 0xf0, 0x29, 0x2c, 0xe5, 0x14, 0xe1, 0x68, 0x5d, 0x85, 0x3a, 0x5d, 0xc6, 0xe9, 0x37,
+	0x50, 0x3b, 0x59, 0xa6, 0x59, 0x36, 0xc4, 0x15, 0x49, 0x7d, 0x0c, 0x45, 0x91, 0xda, 0x44, 0x51,
-	0x27, 0xce, 0x47, 0x76, 0x73, 0xaa, 0x62, 0x61, 0x37, 0xbf, 0x54, 0x17, 0x76, 0x8b, 0x4a, 0xea,
+	0x14, 0xe5, 0x5b, 0x1f, 0x5f, 0xc0, 0x82, 0xe6, 0x55, 0x80, 0xd6, 0x54, 0xa8, 0xf3, 0x75, 0xa5,
-	0x3d, 0x58, 0xcc, 0x14, 0xaa, 0xe8, 0x46, 0xb2, 0x2a, 0xaf, 0x72, 0xd6, 0xd7, 0x26, 0xcc, 0x12,
+	0x79, 0x6b, 0xe4, 0x78, 0xa2, 0x57, 0x53, 0xa6, 0x0b, 0xbd, 0xfa, 0xb7, 0x83, 0xd0, 0x5b, 0x56,
-	0x1f, 0x7d, 0x06, 0xcb, 0x79, 0x75, 0x1f, 0xba, 0x99, 0x62, 0x97, 0x8c, 0xdd, 0x8d, 0xc9, 0x0a,
+	0xe3, 0xef, 0xc1, 0x7c, 0xa1, 0x72, 0x46, 0x37, 0xb3, 0x59, 0xba, 0x52, 0xde, 0x5c, 0x1d, 0x31,
-	0x91, 0xb3, 0x99, 0x42, 0x4c, 0x38, 0x9b, 0x57, 0x1d, 0x0a, 0x67, 0xf3, 0x2b, 0xb8, 0x53, 0xd0,
+	0x4a, 0x42, 0xf4, 0x25, 0x2c, 0xea, 0x0a, 0x51, 0x74, 0x2b, 0xf7, 0x8a, 0x2d, 0xe8, 0x5d, 0x1f,
-	0x8b, 0x2b, 0x10, 0x74, 0x87, 0x7b, 0x34, 0xa9, 0xf8, 0xd2, 0xff, 0x3f, 0x8b, 0x1a, 0xf1, 0xd1,
+	0x2d, 0x90, 0x18, 0x5b, 0xa8, 0x0c, 0x85, 0xb1, 0xba, 0x72, 0x55, 0x18, 0xab, 0x2f, 0x29, 0x4f,
-	0x3e, 0xef, 0x4d, 0x49, 0xbc, 0x81, 0xd6, 0x52, 0xd9, 0xa4, 0xbe, 0xa3, 0xfa, 0xfa, 0xa4, 0x69,
+	0xc1, 0x2c, 0x2f, 0x89, 0xd0, 0x5d, 0x6e, 0xd1, 0xa8, 0x6a, 0xd0, 0x7c, 0x73, 0x12, 0x31, 0x12,
-	0xe2, 0x23, 0x0c, 0x9d, 0xa2, 0x67, 0x0e, 0xdd, 0x4a, 0xad, 0xcd, 0x7b, 0xa8, 0xf5, 0xdb, 0xd3,
+	0xa2, 0x7d, 0xde, 0x2c, 0x93, 0xf2, 0x06, 0x5a, 0xcd, 0x45, 0x93, 0x7a, 0x79, 0x9b, 0x6b, 0xa3,
-	0x95, 0x88, 0x8f, 0x9e, 0xc1, 0x6a, 0x01, 0xe7, 0x21, 0x43, 0xba, 0xd8, 0x05, 0x14, 0xac, 0xdf,
+	0x86, 0x49, 0x88, 0x30, 0x74, 0xca, 0xee, 0x56, 0x74, 0x3b, 0x37, 0x57, 0x57, 0x1d, 0x98, 0x77,
-	0x9a, 0xaa, 0x43, 0xfc, 0x07, 0x8b, 0x9f, 0x2f, 0x6c, 0xc6, 0xff, 0x76, 0x7b, 0x3f, 0xfa, 0xf3,
+	0xc6, 0x0b, 0x91, 0x10, 0x3d, 0x87, 0x95, 0x92, 0x9c, 0x87, 0x2c, 0xe9, 0x60, 0x97, 0xa4, 0x60,
-	0xac, 0xc1, 0xfe, 0xa7, 0xf6, 0xf6, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x70, 0x91, 0x17, 0x98,
+	0xf3, 0xf6, 0x58, 0x19, 0x12, 0x3e, 0x9c, 0xff, 0x6a, 0x6e, 0x23, 0xfd, 0x1f, 0xf0, 0xa3, 0xe4,
-	0x95, 0x1b, 0x00, 0x00,
+	0xe7, 0xf9, 0x34, 0xfb, 0x93, 0xef, 0xbd, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x01, 0xfa, 0xac,
+	0xd6, 0x26, 0x1c, 0x00, 0x00,
 }

pkg/proto/office/office.proto

@@ -220,8 +220,9 @@ message ChangeWorkMomentPermissionResp {
 
 message GetUserWorkMomentsReq {
   string userID = 1;
-  server_api_params.RequestPagination Pagination = 2;
+  string opUserID = 2;
-  string operationID = 3;
+  server_api_params.RequestPagination Pagination = 3;
+  string operationID = 4;
 }
 
 message GetUserWorkMomentsResp {
@@ -244,12 +245,16 @@ message GetUserFriendWorkMomentsResp {
 
 message WorkMomentNotificationMsg {
   int32 notificationMsgType = 1;
-  Comment comment = 2;
+  string replyUserName = 2;
-  string workMomentID = 3;
+  string replyUserID = 3;
-  string userID = 4;
+  string content = 4;
-  string userName = 5;
+  string contentID = 5;
-  string faceURL = 6;
+  string workMomentID = 6;
-  string workMomentContent = 7;
+  string userID = 7;
+  string userName = 8;
+  string faceURL = 9;
+  string workMomentContent = 10;
+  int32 createTime = 11;
 }
 
 message SetUserWorkMomentsLevelReq {

pkg/proto/sdk_ws/ws.pb.go

@@ -40,7 +40,7 @@ func (m *GroupInfo) Reset()         { *m = GroupInfo{} }
 func (m *GroupInfo) String() string { return proto.CompactTextString(m) }
 func (*GroupInfo) ProtoMessage()    {}
 func (*GroupInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{0}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{0}
 }
 func (m *GroupInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupInfo.Unmarshal(m, b)
@@ -165,7 +165,7 @@ func (m *GroupMemberFullInfo) Reset()         { *m = GroupMemberFullInfo{} }
 func (m *GroupMemberFullInfo) String() string { return proto.CompactTextString(m) }
 func (*GroupMemberFullInfo) ProtoMessage()    {}
 func (*GroupMemberFullInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{1}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{1}
 }
 func (m *GroupMemberFullInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupMemberFullInfo.Unmarshal(m, b)
@@ -277,7 +277,7 @@ func (m *PublicUserInfo) Reset()         { *m = PublicUserInfo{} }
 func (m *PublicUserInfo) String() string { return proto.CompactTextString(m) }
 func (*PublicUserInfo) ProtoMessage()    {}
 func (*PublicUserInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{2}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{2}
 }
 func (m *PublicUserInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PublicUserInfo.Unmarshal(m, b)
@@ -352,7 +352,7 @@ func (m *UserInfo) Reset()         { *m = UserInfo{} }
 func (m *UserInfo) String() string { return proto.CompactTextString(m) }
 func (*UserInfo) ProtoMessage()    {}
 func (*UserInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{3}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{3}
 }
 func (m *UserInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserInfo.Unmarshal(m, b)
@@ -459,7 +459,7 @@ func (m *FriendInfo) Reset()         { *m = FriendInfo{} }
 func (m *FriendInfo) String() string { return proto.CompactTextString(m) }
 func (*FriendInfo) ProtoMessage()    {}
 func (*FriendInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{4}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{4}
 }
 func (m *FriendInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendInfo.Unmarshal(m, b)
@@ -544,7 +544,7 @@ func (m *BlackInfo) Reset()         { *m = BlackInfo{} }
 func (m *BlackInfo) String() string { return proto.CompactTextString(m) }
 func (*BlackInfo) ProtoMessage()    {}
 func (*BlackInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{5}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{5}
 }
 func (m *BlackInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlackInfo.Unmarshal(m, b)
@@ -625,7 +625,7 @@ func (m *GroupRequest) Reset()         { *m = GroupRequest{} }
 func (m *GroupRequest) String() string { return proto.CompactTextString(m) }
 func (*GroupRequest) ProtoMessage()    {}
 func (*GroupRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{6}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{6}
 }
 func (m *GroupRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupRequest.Unmarshal(m, b)
@@ -733,7 +733,7 @@ func (m *FriendRequest) Reset()         { *m = FriendRequest{} }
 func (m *FriendRequest) String() string { return proto.CompactTextString(m) }
 func (*FriendRequest) ProtoMessage()    {}
 func (*FriendRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{7}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{7}
 }
 func (m *FriendRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendRequest.Unmarshal(m, b)
@@ -878,7 +878,7 @@ func (m *Department) Reset()         { *m = Department{} }
 func (m *Department) String() string { return proto.CompactTextString(m) }
 func (*Department) ProtoMessage()    {}
 func (*Department) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{8}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{8}
 }
 func (m *Department) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Department.Unmarshal(m, b)
@@ -989,7 +989,7 @@ func (m *OrganizationUser) Reset()         { *m = OrganizationUser{} }
 func (m *OrganizationUser) String() string { return proto.CompactTextString(m) }
 func (*OrganizationUser) ProtoMessage()    {}
 func (*OrganizationUser) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{9}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{9}
 }
 func (m *OrganizationUser) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OrganizationUser.Unmarshal(m, b)
@@ -1103,7 +1103,7 @@ func (m *DepartmentMember) Reset()         { *m = DepartmentMember{} }
 func (m *DepartmentMember) String() string { return proto.CompactTextString(m) }
 func (*DepartmentMember) ProtoMessage()    {}
 func (*DepartmentMember) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{10}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{10}
 }
 func (m *DepartmentMember) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DepartmentMember.Unmarshal(m, b)
@@ -1184,7 +1184,7 @@ func (m *UserDepartmentMember) Reset()         { *m = UserDepartmentMember{} }
 func (m *UserDepartmentMember) String() string { return proto.CompactTextString(m) }
 func (*UserDepartmentMember) ProtoMessage()    {}
 func (*UserDepartmentMember) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{11}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{11}
 }
 func (m *UserDepartmentMember) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDepartmentMember.Unmarshal(m, b)
@@ -1230,7 +1230,7 @@ func (m *UserInDepartment) Reset()         { *m = UserInDepartment{} }
 func (m *UserInDepartment) String() string { return proto.CompactTextString(m) }
 func (*UserInDepartment) ProtoMessage()    {}
 func (*UserInDepartment) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{12}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{12}
 }
 func (m *UserInDepartment) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserInDepartment.Unmarshal(m, b)
@@ -1277,7 +1277,7 @@ func (m *PullMessageBySeqListResp) Reset()         { *m = PullMessageBySeqListRe
 func (m *PullMessageBySeqListResp) String() string { return proto.CompactTextString(m) }
 func (*PullMessageBySeqListResp) ProtoMessage()    {}
 func (*PullMessageBySeqListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{13}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{13}
 }
 func (m *PullMessageBySeqListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PullMessageBySeqListResp.Unmarshal(m, b)
@@ -1331,7 +1331,7 @@ func (m *PullMessageBySeqListReq) Reset()         { *m = PullMessageBySeqListReq
 func (m *PullMessageBySeqListReq) String() string { return proto.CompactTextString(m) }
 func (*PullMessageBySeqListReq) ProtoMessage()    {}
 func (*PullMessageBySeqListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{14}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{14}
 }
 func (m *PullMessageBySeqListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PullMessageBySeqListReq.Unmarshal(m, b)
@@ -1382,7 +1382,7 @@ func (m *GetMaxAndMinSeqReq) Reset()         { *m = GetMaxAndMinSeqReq{} }
 func (m *GetMaxAndMinSeqReq) String() string { return proto.CompactTextString(m) }
 func (*GetMaxAndMinSeqReq) ProtoMessage()    {}
 func (*GetMaxAndMinSeqReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{15}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{15}
 }
 func (m *GetMaxAndMinSeqReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetMaxAndMinSeqReq.Unmarshal(m, b)
@@ -1414,7 +1414,7 @@ func (m *GetMaxAndMinSeqResp) Reset()         { *m = GetMaxAndMinSeqResp{} }
 func (m *GetMaxAndMinSeqResp) String() string { return proto.CompactTextString(m) }
 func (*GetMaxAndMinSeqResp) ProtoMessage()    {}
 func (*GetMaxAndMinSeqResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{16}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{16}
 }
 func (m *GetMaxAndMinSeqResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetMaxAndMinSeqResp.Unmarshal(m, b)
@@ -1461,7 +1461,7 @@ func (m *UserSendMsgResp) Reset()         { *m = UserSendMsgResp{} }
 func (m *UserSendMsgResp) String() string { return proto.CompactTextString(m) }
 func (*UserSendMsgResp) ProtoMessage()    {}
 func (*UserSendMsgResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{17}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{17}
 }
 func (m *UserSendMsgResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserSendMsgResp.Unmarshal(m, b)
@@ -1521,6 +1521,7 @@ type MsgData struct {
 	Status               int32            `protobuf:"varint,17,opt,name=status" json:"status,omitempty"`
 	Options              map[string]bool  `protobuf:"bytes,18,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
 	OfflinePushInfo      *OfflinePushInfo `protobuf:"bytes,19,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"`
+	AtUserIDList         []string         `protobuf:"bytes,20,rep,name=atUserIDList" json:"atUserIDList,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
 	XXX_unrecognized     []byte           `json:"-"`
 	XXX_sizecache        int32            `json:"-"`
@@ -1530,7 +1531,7 @@ func (m *MsgData) Reset()         { *m = MsgData{} }
 func (m *MsgData) String() string { return proto.CompactTextString(m) }
 func (*MsgData) ProtoMessage()    {}
 func (*MsgData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{18}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{18}
 }
 func (m *MsgData) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MsgData.Unmarshal(m, b)
@@ -1676,7 +1677,13 @@ func (m *MsgData) GetOfflinePushInfo() *OfflinePushInfo {
 	return nil
 }
 
-//  repeated string atUserIDList = 17;
+func (m *MsgData) GetAtUserIDList() []string {
+	if m != nil {
+		return m.AtUserIDList
+	}
+	return nil
+}
+
 type OfflinePushInfo struct {
 	Title                string   `protobuf:"bytes,1,opt,name=title" json:"title,omitempty"`
 	Desc                 string   `protobuf:"bytes,2,opt,name=desc" json:"desc,omitempty"`
@@ -1692,7 +1699,7 @@ func (m *OfflinePushInfo) Reset()         { *m = OfflinePushInfo{} }
 func (m *OfflinePushInfo) String() string { return proto.CompactTextString(m) }
 func (*OfflinePushInfo) ProtoMessage()    {}
 func (*OfflinePushInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{19}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{19}
 }
 func (m *OfflinePushInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OfflinePushInfo.Unmarshal(m, b)
@@ -1760,7 +1767,7 @@ func (m *TipsComm) Reset()         { *m = TipsComm{} }
 func (m *TipsComm) String() string { return proto.CompactTextString(m) }
 func (*TipsComm) ProtoMessage()    {}
 func (*TipsComm) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{20}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{20}
 }
 func (m *TipsComm) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TipsComm.Unmarshal(m, b)
@@ -1817,7 +1824,7 @@ func (m *GroupCreatedTips) Reset()         { *m = GroupCreatedTips{} }
 func (m *GroupCreatedTips) String() string { return proto.CompactTextString(m) }
 func (*GroupCreatedTips) ProtoMessage()    {}
 func (*GroupCreatedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{21}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{21}
 }
 func (m *GroupCreatedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupCreatedTips.Unmarshal(m, b)
@@ -1886,7 +1893,7 @@ func (m *GroupInfoSetTips) Reset()         { *m = GroupInfoSetTips{} }
 func (m *GroupInfoSetTips) String() string { return proto.CompactTextString(m) }
 func (*GroupInfoSetTips) ProtoMessage()    {}
 func (*GroupInfoSetTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{22}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{22}
 }
 func (m *GroupInfoSetTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupInfoSetTips.Unmarshal(m, b)
@@ -1941,7 +1948,7 @@ func (m *JoinGroupApplicationTips) Reset()         { *m = JoinGroupApplicationTi
 func (m *JoinGroupApplicationTips) String() string { return proto.CompactTextString(m) }
 func (*JoinGroupApplicationTips) ProtoMessage()    {}
 func (*JoinGroupApplicationTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{23}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{23}
 }
 func (m *JoinGroupApplicationTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_JoinGroupApplicationTips.Unmarshal(m, b)
@@ -1997,7 +2004,7 @@ func (m *MemberQuitTips) Reset()         { *m = MemberQuitTips{} }
 func (m *MemberQuitTips) String() string { return proto.CompactTextString(m) }
 func (*MemberQuitTips) ProtoMessage()    {}
 func (*MemberQuitTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{24}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{24}
 }
 func (m *MemberQuitTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MemberQuitTips.Unmarshal(m, b)
@@ -2052,7 +2059,7 @@ func (m *GroupApplicationAcceptedTips) Reset()         { *m = GroupApplicationAc
 func (m *GroupApplicationAcceptedTips) String() string { return proto.CompactTextString(m) }
 func (*GroupApplicationAcceptedTips) ProtoMessage()    {}
 func (*GroupApplicationAcceptedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{25}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{25}
 }
 func (m *GroupApplicationAcceptedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupApplicationAcceptedTips.Unmarshal(m, b)
@@ -2107,7 +2114,7 @@ func (m *GroupApplicationRejectedTips) Reset()         { *m = GroupApplicationRe
 func (m *GroupApplicationRejectedTips) String() string { return proto.CompactTextString(m) }
 func (*GroupApplicationRejectedTips) ProtoMessage()    {}
 func (*GroupApplicationRejectedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{26}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{26}
 }
 func (m *GroupApplicationRejectedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupApplicationRejectedTips.Unmarshal(m, b)
@@ -2163,7 +2170,7 @@ func (m *GroupOwnerTransferredTips) Reset()         { *m = GroupOwnerTransferred
 func (m *GroupOwnerTransferredTips) String() string { return proto.CompactTextString(m) }
 func (*GroupOwnerTransferredTips) ProtoMessage()    {}
 func (*GroupOwnerTransferredTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{27}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{27}
 }
 func (m *GroupOwnerTransferredTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupOwnerTransferredTips.Unmarshal(m, b)
@@ -2226,7 +2233,7 @@ func (m *MemberKickedTips) Reset()         { *m = MemberKickedTips{} }
 func (m *MemberKickedTips) String() string { return proto.CompactTextString(m) }
 func (*MemberKickedTips) ProtoMessage()    {}
 func (*MemberKickedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{28}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{28}
 }
 func (m *MemberKickedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MemberKickedTips.Unmarshal(m, b)
@@ -2289,7 +2296,7 @@ func (m *MemberInvitedTips) Reset()         { *m = MemberInvitedTips{} }
 func (m *MemberInvitedTips) String() string { return proto.CompactTextString(m) }
 func (*MemberInvitedTips) ProtoMessage()    {}
 func (*MemberInvitedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{29}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{29}
 }
 func (m *MemberInvitedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MemberInvitedTips.Unmarshal(m, b)
@@ -2351,7 +2358,7 @@ func (m *MemberEnterTips) Reset()         { *m = MemberEnterTips{} }
 func (m *MemberEnterTips) String() string { return proto.CompactTextString(m) }
 func (*MemberEnterTips) ProtoMessage()    {}
 func (*MemberEnterTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{30}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{30}
 }
 func (m *MemberEnterTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MemberEnterTips.Unmarshal(m, b)
@@ -2405,7 +2412,7 @@ func (m *GroupDismissedTips) Reset()         { *m = GroupDismissedTips{} }
 func (m *GroupDismissedTips) String() string { return proto.CompactTextString(m) }
 func (*GroupDismissedTips) ProtoMessage()    {}
 func (*GroupDismissedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{31}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{31}
 }
 func (m *GroupDismissedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupDismissedTips.Unmarshal(m, b)
@@ -2461,7 +2468,7 @@ func (m *GroupMemberMutedTips) Reset()         { *m = GroupMemberMutedTips{} }
 func (m *GroupMemberMutedTips) String() string { return proto.CompactTextString(m) }
 func (*GroupMemberMutedTips) ProtoMessage()    {}
 func (*GroupMemberMutedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{32}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{32}
 }
 func (m *GroupMemberMutedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupMemberMutedTips.Unmarshal(m, b)
@@ -2530,7 +2537,7 @@ func (m *GroupMemberCancelMutedTips) Reset()         { *m = GroupMemberCancelMut
 func (m *GroupMemberCancelMutedTips) String() string { return proto.CompactTextString(m) }
 func (*GroupMemberCancelMutedTips) ProtoMessage()    {}
 func (*GroupMemberCancelMutedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{33}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{33}
 }
 func (m *GroupMemberCancelMutedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupMemberCancelMutedTips.Unmarshal(m, b)
@@ -2591,7 +2598,7 @@ func (m *GroupMutedTips) Reset()         { *m = GroupMutedTips{} }
 func (m *GroupMutedTips) String() string { return proto.CompactTextString(m) }
 func (*GroupMutedTips) ProtoMessage()    {}
 func (*GroupMutedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{34}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{34}
 }
 func (m *GroupMutedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupMutedTips.Unmarshal(m, b)
@@ -2645,7 +2652,7 @@ func (m *GroupCancelMutedTips) Reset()         { *m = GroupCancelMutedTips{} }
 func (m *GroupCancelMutedTips) String() string { return proto.CompactTextString(m) }
 func (*GroupCancelMutedTips) ProtoMessage()    {}
 func (*GroupCancelMutedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{35}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{35}
 }
 func (m *GroupCancelMutedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupCancelMutedTips.Unmarshal(m, b)
@@ -2700,7 +2707,7 @@ func (m *GroupMemberInfoSetTips) Reset()         { *m = GroupMemberInfoSetTips{}
 func (m *GroupMemberInfoSetTips) String() string { return proto.CompactTextString(m) }
 func (*GroupMemberInfoSetTips) ProtoMessage()    {}
 func (*GroupMemberInfoSetTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{36}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{36}
 }
 func (m *GroupMemberInfoSetTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupMemberInfoSetTips.Unmarshal(m, b)
@@ -2760,7 +2767,7 @@ func (m *OrganizationChangedTips) Reset()         { *m = OrganizationChangedTips
 func (m *OrganizationChangedTips) String() string { return proto.CompactTextString(m) }
 func (*OrganizationChangedTips) ProtoMessage()    {}
 func (*OrganizationChangedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{37}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{37}
 }
 func (m *OrganizationChangedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OrganizationChangedTips.Unmarshal(m, b)
@@ -2807,7 +2814,7 @@ func (m *FriendApplication) Reset()         { *m = FriendApplication{} }
 func (m *FriendApplication) String() string { return proto.CompactTextString(m) }
 func (*FriendApplication) ProtoMessage()    {}
 func (*FriendApplication) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{38}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{38}
 }
 func (m *FriendApplication) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendApplication.Unmarshal(m, b)
@@ -2860,7 +2867,7 @@ func (m *FromToUserID) Reset()         { *m = FromToUserID{} }
 func (m *FromToUserID) String() string { return proto.CompactTextString(m) }
 func (*FromToUserID) ProtoMessage()    {}
 func (*FromToUserID) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{39}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{39}
 }
 func (m *FromToUserID) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FromToUserID.Unmarshal(m, b)
@@ -2906,7 +2913,7 @@ func (m *FriendApplicationTips) Reset()         { *m = FriendApplicationTips{} }
 func (m *FriendApplicationTips) String() string { return proto.CompactTextString(m) }
 func (*FriendApplicationTips) ProtoMessage()    {}
 func (*FriendApplicationTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{40}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{40}
 }
 func (m *FriendApplicationTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendApplicationTips.Unmarshal(m, b)
@@ -2946,7 +2953,7 @@ func (m *FriendApplicationApprovedTips) Reset()         { *m = FriendApplication
 func (m *FriendApplicationApprovedTips) String() string { return proto.CompactTextString(m) }
 func (*FriendApplicationApprovedTips) ProtoMessage()    {}
 func (*FriendApplicationApprovedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{41}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{41}
 }
 func (m *FriendApplicationApprovedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendApplicationApprovedTips.Unmarshal(m, b)
@@ -2993,7 +3000,7 @@ func (m *FriendApplicationRejectedTips) Reset()         { *m = FriendApplication
 func (m *FriendApplicationRejectedTips) String() string { return proto.CompactTextString(m) }
 func (*FriendApplicationRejectedTips) ProtoMessage()    {}
 func (*FriendApplicationRejectedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{42}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{42}
 }
 func (m *FriendApplicationRejectedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendApplicationRejectedTips.Unmarshal(m, b)
@@ -3041,7 +3048,7 @@ func (m *FriendAddedTips) Reset()         { *m = FriendAddedTips{} }
 func (m *FriendAddedTips) String() string { return proto.CompactTextString(m) }
 func (*FriendAddedTips) ProtoMessage()    {}
 func (*FriendAddedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{43}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{43}
 }
 func (m *FriendAddedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendAddedTips.Unmarshal(m, b)
@@ -3094,7 +3101,7 @@ func (m *FriendDeletedTips) Reset()         { *m = FriendDeletedTips{} }
 func (m *FriendDeletedTips) String() string { return proto.CompactTextString(m) }
 func (*FriendDeletedTips) ProtoMessage()    {}
 func (*FriendDeletedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{44}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{44}
 }
 func (m *FriendDeletedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendDeletedTips.Unmarshal(m, b)
@@ -3132,7 +3139,7 @@ func (m *BlackAddedTips) Reset()         { *m = BlackAddedTips{} }
 func (m *BlackAddedTips) String() string { return proto.CompactTextString(m) }
 func (*BlackAddedTips) ProtoMessage()    {}
 func (*BlackAddedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{45}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{45}
 }
 func (m *BlackAddedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlackAddedTips.Unmarshal(m, b)
@@ -3170,7 +3177,7 @@ func (m *BlackDeletedTips) Reset()         { *m = BlackDeletedTips{} }
 func (m *BlackDeletedTips) String() string { return proto.CompactTextString(m) }
 func (*BlackDeletedTips) ProtoMessage()    {}
 func (*BlackDeletedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{46}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{46}
 }
 func (m *BlackDeletedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlackDeletedTips.Unmarshal(m, b)
@@ -3208,7 +3215,7 @@ func (m *FriendInfoChangedTips) Reset()         { *m = FriendInfoChangedTips{} }
 func (m *FriendInfoChangedTips) String() string { return proto.CompactTextString(m) }
 func (*FriendInfoChangedTips) ProtoMessage()    {}
 func (*FriendInfoChangedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{47}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{47}
 }
 func (m *FriendInfoChangedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FriendInfoChangedTips.Unmarshal(m, b)
@@ -3247,7 +3254,7 @@ func (m *UserInfoUpdatedTips) Reset()         { *m = UserInfoUpdatedTips{} }
 func (m *UserInfoUpdatedTips) String() string { return proto.CompactTextString(m) }
 func (*UserInfoUpdatedTips) ProtoMessage()    {}
 func (*UserInfoUpdatedTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{48}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{48}
 }
 func (m *UserInfoUpdatedTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserInfoUpdatedTips.Unmarshal(m, b)
@@ -3286,7 +3293,7 @@ func (m *ConversationUpdateTips) Reset()         { *m = ConversationUpdateTips{}
 func (m *ConversationUpdateTips) String() string { return proto.CompactTextString(m) }
 func (*ConversationUpdateTips) ProtoMessage()    {}
 func (*ConversationUpdateTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{49}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{49}
 }
 func (m *ConversationUpdateTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ConversationUpdateTips.Unmarshal(m, b)
@@ -3326,7 +3333,7 @@ func (m *ConversationSetPrivateTips) Reset()         { *m = ConversationSetPriva
 func (m *ConversationSetPrivateTips) String() string { return proto.CompactTextString(m) }
 func (*ConversationSetPrivateTips) ProtoMessage()    {}
 func (*ConversationSetPrivateTips) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{50}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{50}
 }
 func (m *ConversationSetPrivateTips) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ConversationSetPrivateTips.Unmarshal(m, b)
@@ -3380,7 +3387,7 @@ func (m *RequestPagination) Reset()         { *m = RequestPagination{} }
 func (m *RequestPagination) String() string { return proto.CompactTextString(m) }
 func (*RequestPagination) ProtoMessage()    {}
 func (*RequestPagination) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{51}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{51}
 }
 func (m *RequestPagination) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RequestPagination.Unmarshal(m, b)
@@ -3426,7 +3433,7 @@ func (m *ResponsePagination) Reset()         { *m = ResponsePagination{} }
 func (m *ResponsePagination) String() string { return proto.CompactTextString(m) }
 func (*ResponsePagination) ProtoMessage()    {}
 func (*ResponsePagination) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{52}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{52}
 }
 func (m *ResponsePagination) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResponsePagination.Unmarshal(m, b)
@@ -3479,7 +3486,7 @@ func (m *SignalReq) Reset()         { *m = SignalReq{} }
 func (m *SignalReq) String() string { return proto.CompactTextString(m) }
 func (*SignalReq) ProtoMessage()    {}
 func (*SignalReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{53}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{53}
 }
 func (m *SignalReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalReq.Unmarshal(m, b)
@@ -3746,7 +3753,7 @@ func (m *SignalResp) Reset()         { *m = SignalResp{} }
 func (m *SignalResp) String() string { return proto.CompactTextString(m) }
 func (*SignalResp) ProtoMessage()    {}
 func (*SignalResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{54}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{54}
 }
 func (m *SignalResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalResp.Unmarshal(m, b)
@@ -4014,7 +4021,7 @@ func (m *InvitationInfo) Reset()         { *m = InvitationInfo{} }
 func (m *InvitationInfo) String() string { return proto.CompactTextString(m) }
 func (*InvitationInfo) ProtoMessage()    {}
 func (*InvitationInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{55}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{55}
 }
 func (m *InvitationInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InvitationInfo.Unmarshal(m, b)
@@ -4110,7 +4117,7 @@ func (m *ParticipantMetaData) Reset()         { *m = ParticipantMetaData{} }
 func (m *ParticipantMetaData) String() string { return proto.CompactTextString(m) }
 func (*ParticipantMetaData) ProtoMessage()    {}
 func (*ParticipantMetaData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{56}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{56}
 }
 func (m *ParticipantMetaData) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ParticipantMetaData.Unmarshal(m, b)
@@ -4165,7 +4172,7 @@ func (m *SignalInviteReq) Reset()         { *m = SignalInviteReq{} }
 func (m *SignalInviteReq) String() string { return proto.CompactTextString(m) }
 func (*SignalInviteReq) ProtoMessage()    {}
 func (*SignalInviteReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{57}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{57}
 }
 func (m *SignalInviteReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalInviteReq.Unmarshal(m, b)
@@ -4226,7 +4233,7 @@ func (m *SignalInviteReply) Reset()         { *m = SignalInviteReply{} }
 func (m *SignalInviteReply) String() string { return proto.CompactTextString(m) }
 func (*SignalInviteReply) ProtoMessage()    {}
 func (*SignalInviteReply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{58}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{58}
 }
 func (m *SignalInviteReply) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalInviteReply.Unmarshal(m, b)
@@ -4281,7 +4288,7 @@ func (m *SignalInviteInGroupReq) Reset()         { *m = SignalInviteInGroupReq{}
 func (m *SignalInviteInGroupReq) String() string { return proto.CompactTextString(m) }
 func (*SignalInviteInGroupReq) ProtoMessage()    {}
 func (*SignalInviteInGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{59}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{59}
 }
 func (m *SignalInviteInGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalInviteInGroupReq.Unmarshal(m, b)
@@ -4342,7 +4349,7 @@ func (m *SignalInviteInGroupReply) Reset()         { *m = SignalInviteInGroupRep
 func (m *SignalInviteInGroupReply) String() string { return proto.CompactTextString(m) }
 func (*SignalInviteInGroupReply) ProtoMessage()    {}
 func (*SignalInviteInGroupReply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{60}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{60}
 }
 func (m *SignalInviteInGroupReply) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalInviteInGroupReply.Unmarshal(m, b)
@@ -4397,7 +4404,7 @@ func (m *SignalCancelReq) Reset()         { *m = SignalCancelReq{} }
 func (m *SignalCancelReq) String() string { return proto.CompactTextString(m) }
 func (*SignalCancelReq) ProtoMessage()    {}
 func (*SignalCancelReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{61}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{61}
 }
 func (m *SignalCancelReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalCancelReq.Unmarshal(m, b)
@@ -4455,7 +4462,7 @@ func (m *SignalCancelReply) Reset()         { *m = SignalCancelReply{} }
 func (m *SignalCancelReply) String() string { return proto.CompactTextString(m) }
 func (*SignalCancelReply) ProtoMessage()    {}
 func (*SignalCancelReply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{62}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{62}
 }
 func (m *SignalCancelReply) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalCancelReply.Unmarshal(m, b)
@@ -4490,7 +4497,7 @@ func (m *SignalAcceptReq) Reset()         { *m = SignalAcceptReq{} }
 func (m *SignalAcceptReq) String() string { return proto.CompactTextString(m) }
 func (*SignalAcceptReq) ProtoMessage()    {}
 func (*SignalAcceptReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{63}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{63}
 }
 func (m *SignalAcceptReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalAcceptReq.Unmarshal(m, b)
@@ -4558,7 +4565,7 @@ func (m *SignalAcceptReply) Reset()         { *m = SignalAcceptReply{} }
 func (m *SignalAcceptReply) String() string { return proto.CompactTextString(m) }
 func (*SignalAcceptReply) ProtoMessage()    {}
 func (*SignalAcceptReply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{64}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{64}
 }
 func (m *SignalAcceptReply) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalAcceptReply.Unmarshal(m, b)
@@ -4612,7 +4619,7 @@ func (m *SignalHungUpReq) Reset()         { *m = SignalHungUpReq{} }
 func (m *SignalHungUpReq) String() string { return proto.CompactTextString(m) }
 func (*SignalHungUpReq) ProtoMessage()    {}
 func (*SignalHungUpReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{65}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{65}
 }
 func (m *SignalHungUpReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalHungUpReq.Unmarshal(m, b)
@@ -4663,7 +4670,7 @@ func (m *SignalHungUpReply) Reset()         { *m = SignalHungUpReply{} }
 func (m *SignalHungUpReply) String() string { return proto.CompactTextString(m) }
 func (*SignalHungUpReply) ProtoMessage()    {}
 func (*SignalHungUpReply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{66}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{66}
 }
 func (m *SignalHungUpReply) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalHungUpReply.Unmarshal(m, b)
@@ -4698,7 +4705,7 @@ func (m *SignalRejectReq) Reset()         { *m = SignalRejectReq{} }
 func (m *SignalRejectReq) String() string { return proto.CompactTextString(m) }
 func (*SignalRejectReq) ProtoMessage()    {}
 func (*SignalRejectReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{67}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{67}
 }
 func (m *SignalRejectReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalRejectReq.Unmarshal(m, b)
@@ -4763,7 +4770,7 @@ func (m *SignalRejectReply) Reset()         { *m = SignalRejectReply{} }
 func (m *SignalRejectReply) String() string { return proto.CompactTextString(m) }
 func (*SignalRejectReply) ProtoMessage()    {}
 func (*SignalRejectReply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{68}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{68}
 }
 func (m *SignalRejectReply) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalRejectReply.Unmarshal(m, b)
@@ -4797,7 +4804,7 @@ func (m *DelMsgListReq) Reset()         { *m = DelMsgListReq{} }
 func (m *DelMsgListReq) String() string { return proto.CompactTextString(m) }
 func (*DelMsgListReq) ProtoMessage()    {}
 func (*DelMsgListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{69}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{69}
 }
 func (m *DelMsgListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DelMsgListReq.Unmarshal(m, b)
@@ -4857,7 +4864,7 @@ func (m *DelMsgListResp) Reset()         { *m = DelMsgListResp{} }
 func (m *DelMsgListResp) String() string { return proto.CompactTextString(m) }
 func (*DelMsgListResp) ProtoMessage()    {}
 func (*DelMsgListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ws_0aa1613bcc1a3980, []int{70}
+	return fileDescriptor_ws_8b0ea2633e539530, []int{70}
 }
 func (m *DelMsgListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DelMsgListResp.Unmarshal(m, b)
@@ -4966,198 +4973,199 @@ func init() {
 	proto.RegisterType((*DelMsgListResp)(nil), "server_api_params.DelMsgListResp")
 }
 
-func init() { proto.RegisterFile("sdk_ws/ws.proto", fileDescriptor_ws_0aa1613bcc1a3980) }
+func init() { proto.RegisterFile("sdk_ws/ws.proto", fileDescriptor_ws_8b0ea2633e539530) }
-
+
-var fileDescriptor_ws_0aa1613bcc1a3980 = []byte{
+var fileDescriptor_ws_8b0ea2633e539530 = []byte{
-	// 3033 bytes of a gzipped FileDescriptorProto
+	// 3049 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcf, 0x6f, 0x24, 0x47,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcb, 0x6f, 0x24, 0x49,
-	0xf5, 0xff, 0x76, 0x8f, 0x67, 0xec, 0x79, 0xe3, 0xf1, 0x8f, 0xde, 0xfd, 0x3a, 0x83, 0xd9, 0x2c,
+	0xd1, 0xff, 0xaa, 0xda, 0xdd, 0x76, 0x47, 0xbb, 0xfd, 0xa8, 0x99, 0xcf, 0xdb, 0x98, 0xd9, 0xc1,
-	0xa6, 0xb1, 0x42, 0x08, 0xb0, 0x41, 0x89, 0x90, 0x20, 0x81, 0x45, 0x6b, 0x7b, 0x7f, 0x85, 0xb5,
+	0x14, 0xd6, 0xb2, 0x2c, 0x30, 0x8b, 0x76, 0x85, 0x04, 0xbb, 0x30, 0x68, 0x6c, 0xcf, 0x6b, 0x19,
-	0xd7, 0xe9, 0xd9, 0x25, 0x08, 0x90, 0xa2, 0xf6, 0x74, 0x79, 0xdc, 0x71, 0x77, 0x55, 0x4f, 0xff,
+	0x7b, 0xbc, 0xd5, 0x33, 0x2c, 0x02, 0xa4, 0x55, 0xb9, 0x2b, 0xdd, 0xae, 0x75, 0x55, 0x66, 0x75,
-	0xf0, 0xee, 0x22, 0x24, 0x24, 0x90, 0x10, 0x37, 0x4e, 0x70, 0xe0, 0x82, 0xc4, 0x05, 0x81, 0xa2,
+	0x3d, 0x3c, 0x33, 0x08, 0x09, 0x09, 0x24, 0xc4, 0x8d, 0x13, 0x1c, 0xb8, 0x20, 0x71, 0x41, 0xa0,
-	0x28, 0x42, 0x20, 0x71, 0x88, 0x10, 0x07, 0xfe, 0x01, 0x8e, 0x88, 0x1b, 0x67, 0xae, 0x1c, 0x90,
+	0xd5, 0x6a, 0x85, 0x40, 0xe2, 0x80, 0x10, 0x07, 0xfe, 0x01, 0x8e, 0x88, 0x0b, 0xe2, 0xcc, 0x95,
-	0x90, 0x40, 0x55, 0xaf, 0xba, 0xbb, 0xaa, 0x7b, 0xc6, 0x9e, 0x1d, 0x59, 0xd9, 0x8d, 0x96, 0xdb,
+	0x03, 0x12, 0x12, 0x28, 0x33, 0xb2, 0xaa, 0x32, 0xab, 0xba, 0xed, 0x9e, 0x96, 0xb5, 0x33, 0xab,
-	0xbc, 0xd7, 0xf5, 0x5e, 0xbd, 0xfa, 0xbc, 0x57, 0xf5, 0x5e, 0xfd, 0x18, 0x58, 0x4e, 0xbc, 0xe3,
+	0xe1, 0xd6, 0x11, 0x95, 0x11, 0x19, 0xf9, 0x8b, 0xc8, 0x8c, 0xc8, 0x47, 0xc3, 0x72, 0xe2, 0x1d,
-	0xb7, 0x1f, 0x24, 0x2f, 0x3f, 0x48, 0xae, 0x44, 0x31, 0x4b, 0x99, 0xb5, 0x9a, 0x90, 0xf8, 0x84,
+	0xbf, 0xfd, 0x20, 0x79, 0xf9, 0x41, 0x72, 0x25, 0x8a, 0x59, 0xca, 0xac, 0xd5, 0x84, 0xc4, 0x27,
-	0xc4, 0x6f, 0xbb, 0x91, 0xff, 0x76, 0xe4, 0xc6, 0x6e, 0x98, 0xd8, 0xff, 0x34, 0xa1, 0x7d, 0x33,
+	0x24, 0x7e, 0xdb, 0x8d, 0xfc, 0xb7, 0x23, 0x37, 0x76, 0xc3, 0xc4, 0xfe, 0xa7, 0x09, 0xed, 0x9b,
-	0x66, 0x59, 0x74, 0x9b, 0x1e, 0x32, 0xab, 0x07, 0xf3, 0x43, 0x41, 0xec, 0xf4, 0x8c, 0x0d, 0xe3,
+	0x31, 0xcb, 0xa2, 0xdb, 0xf4, 0x90, 0x59, 0x3d, 0x98, 0x1f, 0x0a, 0x62, 0xa7, 0x67, 0x6c, 0x18,
-	0xc5, 0xb6, 0x93, 0x93, 0xd6, 0x25, 0x68, 0x8b, 0x9f, 0x7b, 0x6e, 0x48, 0x7a, 0xa6, 0xf8, 0x56,
+	0x2f, 0xb6, 0x9d, 0x9c, 0xb4, 0x2e, 0x41, 0x5b, 0xfc, 0xdc, 0x73, 0x43, 0xd2, 0x33, 0xc5, 0xb7,
-	0x32, 0x2c, 0x1b, 0x16, 0x29, 0x4b, 0xfd, 0x43, 0x7f, 0xe0, 0xa6, 0x3e, 0xa3, 0xbd, 0x86, 0x68,
+	0x92, 0x61, 0xd9, 0xb0, 0x48, 0x59, 0xea, 0x1f, 0xfa, 0x03, 0x37, 0xf5, 0x19, 0xed, 0x35, 0x44,
-	0xa0, 0xf1, 0x78, 0x1b, 0x9f, 0xa6, 0x31, 0xf3, 0xb2, 0x81, 0x68, 0x33, 0x87, 0x6d, 0x54, 0x1e,
+	0x03, 0x8d, 0xc7, 0xdb, 0xf8, 0x34, 0x8d, 0x99, 0x97, 0x0d, 0x44, 0x9b, 0x39, 0x6c, 0xa3, 0xf2,
-	0xef, 0xff, 0xd0, 0x1d, 0x90, 0xfb, 0xce, 0x9d, 0x5e, 0x13, 0xfb, 0x97, 0xa4, 0xb5, 0x01, 0x1d,
+	0x78, 0xff, 0x87, 0xee, 0x80, 0xdc, 0x77, 0xee, 0xf4, 0x9a, 0xd8, 0xbf, 0x24, 0xad, 0x0d, 0xe8,
-	0xf6, 0x80, 0x92, 0xf8, 0x7e, 0x42, 0xe2, 0xdb, 0x3b, 0xbd, 0x96, 0xf8, 0xaa, 0xb2, 0xac, 0xcb,
+	0xb0, 0x07, 0x94, 0xc4, 0xf7, 0x13, 0x12, 0xdf, 0xde, 0xe9, 0xb5, 0xc4, 0x57, 0x95, 0x65, 0x5d,
-	0x00, 0x83, 0x98, 0xb8, 0x29, 0xb9, 0xe7, 0x87, 0xa4, 0x37, 0xbf, 0x61, 0xbc, 0xd8, 0x75, 0x14,
+	0x06, 0x18, 0xc4, 0xc4, 0x4d, 0xc9, 0x3d, 0x3f, 0x24, 0xbd, 0xf9, 0x0d, 0xe3, 0xc5, 0xae, 0xa3,
-	0x0e, 0xd7, 0x10, 0x92, 0xf0, 0x80, 0xc4, 0xdb, 0x2c, 0xa3, 0x69, 0x6f, 0x41, 0x34, 0x50, 0x59,
+	0x70, 0xb8, 0x86, 0x90, 0x84, 0x07, 0x24, 0xde, 0x66, 0x19, 0x4d, 0x7b, 0x0b, 0xa2, 0x81, 0xca,
-	0xd6, 0x12, 0x98, 0xe4, 0x61, 0xaf, 0x2d, 0x54, 0x9b, 0xe4, 0xa1, 0xb5, 0x06, 0xad, 0x24, 0x75,
+	0xb2, 0x96, 0xc0, 0x24, 0x0f, 0x7b, 0x6d, 0xa1, 0xda, 0x24, 0x0f, 0xad, 0x35, 0x68, 0x25, 0xa9,
-	0xd3, 0x2c, 0xe9, 0xc1, 0x86, 0xf1, 0x62, 0xd3, 0x91, 0x94, 0xb5, 0x09, 0x5d, 0xa1, 0x97, 0xe5,
+	0x9b, 0x66, 0x49, 0x0f, 0x36, 0x8c, 0x17, 0x9b, 0x8e, 0xa4, 0xac, 0x4d, 0xe8, 0x0a, 0xbd, 0x2c,
-	0xd6, 0x74, 0x84, 0x88, 0xce, 0x2c, 0x10, 0xbb, 0xf7, 0x28, 0x22, 0xbd, 0x45, 0xa1, 0xa0, 0x64,
+	0xb7, 0xa6, 0x23, 0x44, 0x74, 0x66, 0x81, 0xd8, 0xbd, 0x47, 0x11, 0xe9, 0x2d, 0x0a, 0x05, 0x25,
-	0xd8, 0x7f, 0x35, 0xe1, 0x82, 0xc0, 0x7d, 0x57, 0x18, 0x70, 0x23, 0x0b, 0x82, 0x33, 0x3c, 0xb0,
+	0xc3, 0xfe, 0x8b, 0x09, 0x17, 0x04, 0xee, 0xbb, 0xc2, 0x80, 0x1b, 0x59, 0x10, 0x9c, 0xe1, 0x81,
-	0x06, 0xad, 0x0c, 0xbb, 0x43, 0xf8, 0x25, 0xc5, 0xfb, 0x89, 0x59, 0x40, 0xee, 0x90, 0x13, 0x12,
+	0x35, 0x68, 0x65, 0xd8, 0x1d, 0xc2, 0x2f, 0x29, 0xde, 0x4f, 0xcc, 0x02, 0x72, 0x87, 0x9c, 0x90,
-	0x08, 0xe0, 0x9b, 0x4e, 0xc9, 0xb0, 0xd6, 0x61, 0xe1, 0x1d, 0xe6, 0x53, 0x81, 0xc9, 0x9c, 0xf8,
+	0x40, 0x00, 0xdf, 0x74, 0x4a, 0x86, 0xb5, 0x0e, 0x0b, 0xef, 0x30, 0x9f, 0x0a, 0x4c, 0xe6, 0xc4,
-	0x58, 0xd0, 0xfc, 0x1b, 0xf5, 0x07, 0xc7, 0x94, 0xbb, 0x14, 0xe1, 0x2e, 0x68, 0xd5, 0x13, 0x2d,
+	0xc7, 0x82, 0xe6, 0xdf, 0xa8, 0x3f, 0x38, 0xa6, 0xdc, 0xa5, 0x08, 0x77, 0x41, 0xab, 0x9e, 0x68,
-	0xdd, 0x13, 0x2f, 0xc0, 0x92, 0x1b, 0x45, 0xbb, 0x2e, 0x1d, 0x92, 0x18, 0x3b, 0x9d, 0x17, 0x7a,
+	0xe9, 0x9e, 0x78, 0x01, 0x96, 0xdc, 0x28, 0xda, 0x75, 0xe9, 0x90, 0xc4, 0xd8, 0xe9, 0xbc, 0xd0,
-	0x2b, 0x5c, 0xee, 0x0f, 0xde, 0x53, 0x9f, 0x65, 0xf1, 0x80, 0x08, 0xb8, 0x9b, 0x8e, 0xc2, 0xe1,
+	0x5b, 0xe1, 0x72, 0x7f, 0xf0, 0x9e, 0xfa, 0x2c, 0x8b, 0x07, 0x44, 0xc0, 0xdd, 0x74, 0x14, 0x0e,
-	0x7a, 0x58, 0x44, 0x62, 0x05, 0x46, 0x44, 0xbe, 0xc2, 0x95, 0x5e, 0x81, 0xc2, 0x2b, 0xdc, 0x8f,
+	0xd7, 0xc3, 0x22, 0x12, 0x2b, 0x30, 0x22, 0xf2, 0x15, 0xae, 0xf4, 0x0a, 0x14, 0x5e, 0xe1, 0x7e,
-	0x59, 0x4a, 0xae, 0x53, 0x4f, 0x0c, 0xaa, 0x23, 0xfd, 0x58, 0xb2, 0xec, 0x1f, 0x19, 0xb0, 0xb4,
+	0xcc, 0x52, 0x72, 0x9d, 0x7a, 0x62, 0x50, 0x1d, 0xe9, 0xc7, 0x92, 0x65, 0xff, 0xc0, 0x80, 0xa5,
-	0x9f, 0x1d, 0x04, 0xfe, 0x40, 0xa8, 0xe0, 0xb0, 0x96, 0xe0, 0x19, 0x1a, 0x78, 0x2a, 0x04, 0xe6,
+	0xfd, 0xec, 0x20, 0xf0, 0x07, 0x42, 0x05, 0x87, 0xb5, 0x04, 0xcf, 0xd0, 0xc0, 0x53, 0x21, 0x30,
-	0x64, 0x08, 0x1a, 0x3a, 0x04, 0x6b, 0xd0, 0x1a, 0x12, 0xea, 0x91, 0x58, 0x42, 0x2a, 0x29, 0x69,
+	0x27, 0x43, 0xd0, 0xd0, 0x21, 0x58, 0x83, 0xd6, 0x90, 0x50, 0x8f, 0xc4, 0x12, 0x52, 0x49, 0x49,
-	0x6a, 0x33, 0x37, 0xd5, 0xfe, 0x99, 0x09, 0x0b, 0x1f, 0xb2, 0x09, 0x1b, 0xd0, 0x89, 0x8e, 0x18,
+	0x53, 0x9b, 0xb9, 0xa9, 0xf6, 0x4f, 0x4c, 0x58, 0xf8, 0x80, 0x4d, 0xd8, 0x80, 0x4e, 0x74, 0xc4,
-	0x25, 0x7b, 0x19, 0x0f, 0x2b, 0x69, 0x8b, 0xca, 0xb2, 0x2e, 0x42, 0xf3, 0xc0, 0x8f, 0xd3, 0x23,
+	0x28, 0xd9, 0xcb, 0x78, 0x58, 0x49, 0x5b, 0x54, 0x96, 0x75, 0x11, 0x9a, 0x07, 0x7e, 0x9c, 0x1e,
-	0xe1, 0xd7, 0xae, 0x83, 0x04, 0xe7, 0x92, 0xd0, 0xf5, 0xd1, 0x99, 0x6d, 0x07, 0x09, 0x39, 0xa0,
+	0x09, 0xbf, 0x76, 0x1d, 0x24, 0x38, 0x97, 0x84, 0xae, 0x8f, 0xce, 0x6c, 0x3b, 0x48, 0xc8, 0x01,
-	0x85, 0x02, 0x7b, 0x7d, 0x8e, 0xb5, 0x6b, 0x73, 0xac, 0x1e, 0x1b, 0x30, 0x2e, 0x36, 0xec, 0x7f,
+	0x2d, 0x14, 0xd8, 0xeb, 0x73, 0xac, 0x5d, 0x9b, 0x63, 0xf5, 0xd8, 0x80, 0x71, 0xb1, 0x61, 0xff,
-	0x19, 0x00, 0x37, 0x62, 0x9f, 0x50, 0x4f, 0x40, 0x53, 0x99, 0xdc, 0x46, 0x7d, 0x72, 0xaf, 0x41,
+	0xcb, 0x00, 0xb8, 0x11, 0xfb, 0x84, 0x7a, 0x02, 0x9a, 0xca, 0xe4, 0x36, 0xea, 0x93, 0x7b, 0x0d,
-	0x2b, 0x26, 0xa1, 0x1b, 0x1f, 0xe7, 0xc1, 0x8f, 0x54, 0xc5, 0xa0, 0x46, 0xcd, 0xa0, 0xd7, 0x01,
+	0x5a, 0x31, 0x09, 0xdd, 0xf8, 0x38, 0x0f, 0x7e, 0xa4, 0x2a, 0x06, 0x35, 0x6a, 0x06, 0xbd, 0x0e,
-	0x0e, 0x45, 0x3f, 0x5c, 0x8f, 0x80, 0xaa, 0xf3, 0xca, 0xc7, 0xaf, 0xd4, 0x96, 0xc1, 0x2b, 0xb9,
+	0x70, 0x28, 0xfa, 0xe1, 0x7a, 0x04, 0x54, 0x9d, 0x57, 0x3e, 0x7a, 0xa5, 0xb6, 0x0c, 0x5e, 0xc9,
-	0x97, 0x1c, 0xa5, 0x39, 0x9f, 0x59, 0xae, 0xe7, 0xc9, 0x00, 0x6e, 0xe2, 0xcc, 0x2a, 0x18, 0x63,
+	0xbd, 0xe4, 0x28, 0xcd, 0xf9, 0xcc, 0x72, 0x3d, 0x4f, 0x06, 0x70, 0x13, 0x67, 0x56, 0xc1, 0x18,
-	0xe2, 0xb7, 0x75, 0x4a, 0xfc, 0xce, 0x17, 0x41, 0xf1, 0x0f, 0x03, 0xda, 0x5b, 0x81, 0x3b, 0x38,
+	0x13, 0xbf, 0xad, 0x53, 0xe2, 0x77, 0xbe, 0x08, 0x8a, 0x7f, 0x18, 0xd0, 0xde, 0x0a, 0xdc, 0xc1,
-	0x9e, 0x72, 0xe8, 0xfa, 0x10, 0xcd, 0xda, 0x10, 0x6f, 0x42, 0xf7, 0x80, 0xab, 0xcb, 0x87, 0x20,
+	0xf1, 0x94, 0x43, 0xd7, 0x87, 0x68, 0xd6, 0x86, 0x78, 0x13, 0xba, 0x07, 0x5c, 0x5d, 0x3e, 0x04,
-	0x50, 0xe8, 0xbc, 0xf2, 0xc9, 0x31, 0xa3, 0xd4, 0x27, 0x85, 0xa3, 0xcb, 0xe9, 0xc3, 0x9d, 0x3b,
+	0x81, 0x42, 0xe7, 0x95, 0x8f, 0x8f, 0x19, 0xa5, 0x3e, 0x29, 0x1c, 0x5d, 0x4e, 0x1f, 0xee, 0xdc,
-	0x7b, 0xb8, 0xcd, 0x53, 0x86, 0xdb, 0x2a, 0x86, 0xfb, 0x17, 0x13, 0x16, 0xc5, 0x42, 0xe7, 0x90,
+	0xd9, 0xc3, 0x6d, 0x9e, 0x32, 0xdc, 0x56, 0x31, 0xdc, 0x3f, 0x9b, 0xb0, 0x28, 0x16, 0x3a, 0x87,
-	0x51, 0x46, 0x92, 0xd4, 0xfa, 0x2a, 0x2c, 0x64, 0xb9, 0xa9, 0xc6, 0xb4, 0xa6, 0x16, 0x22, 0xd6,
+	0x8c, 0x32, 0x92, 0xa4, 0xd6, 0x97, 0x61, 0x21, 0xcb, 0x4d, 0x35, 0xa6, 0x35, 0xb5, 0x10, 0xb1,
-	0x6b, 0x72, 0x59, 0x15, 0xf2, 0xa6, 0x90, 0xbf, 0x34, 0x46, 0xbe, 0xc8, 0x69, 0x4e, 0xd9, 0x9c,
+	0x5e, 0x93, 0xcb, 0xaa, 0x90, 0x37, 0x85, 0xfc, 0xa5, 0x31, 0xf2, 0x45, 0x4e, 0x73, 0xca, 0xe6,
-	0xa7, 0xa0, 0x23, 0x97, 0x7a, 0x01, 0x71, 0x48, 0x92, 0x05, 0xa9, 0x5c, 0x2d, 0x35, 0x1e, 0x46,
+	0x3c, 0x05, 0x1d, 0xb9, 0xd4, 0x0b, 0x88, 0x43, 0x92, 0x2c, 0x48, 0xe5, 0x6a, 0xa9, 0xf1, 0x30,
-	0xda, 0x68, 0x37, 0x19, 0xca, 0x04, 0x25, 0x29, 0x8e, 0x0e, 0xb6, 0xe3, 0x9f, 0x70, 0xe8, 0x25,
+	0xd2, 0x46, 0xbb, 0xc9, 0x50, 0x26, 0x28, 0x49, 0x71, 0x74, 0xb0, 0x1d, 0xff, 0x84, 0x43, 0x2f,
-	0x83, 0x4f, 0xd4, 0x98, 0x8c, 0x84, 0x87, 0x70, 0x5a, 0xe5, 0x64, 0xd9, 0xa7, 0x44, 0x0d, 0x03,
+	0x19, 0x7c, 0xa2, 0xc6, 0x64, 0x24, 0x3c, 0x84, 0xd3, 0x2a, 0x27, 0xcb, 0x3e, 0x25, 0x6a, 0x18,
-	0x41, 0xe3, 0x71, 0x17, 0x23, 0x2d, 0x14, 0x60, 0x66, 0x52, 0x38, 0xd5, 0xc4, 0x64, 0xff, 0xad,
+	0x08, 0x1a, 0x8f, 0xbb, 0x18, 0x69, 0xa1, 0x00, 0x33, 0x93, 0xc2, 0xa9, 0x26, 0x26, 0xfb, 0xaf,
-	0x01, 0x5d, 0x9c, 0x3e, 0x39, 0xa8, 0x97, 0x79, 0x9c, 0xb3, 0x50, 0x8b, 0x22, 0x85, 0xc3, 0xad,
+	0x0d, 0xe8, 0xe2, 0xf4, 0xc9, 0x41, 0xbd, 0xcc, 0xe3, 0x9c, 0x85, 0x5a, 0x14, 0x29, 0x1c, 0x6e,
-	0xe0, 0xd4, 0x9e, 0xbe, 0xd0, 0x68, 0x3c, 0x1e, 0x8a, 0x9c, 0xbe, 0xa1, 0x2d, 0x38, 0x2a, 0x2b,
+	0x05, 0xa7, 0xf6, 0xf4, 0x85, 0x46, 0xe3, 0xf1, 0x50, 0xe4, 0xf4, 0x0d, 0x6d, 0xc1, 0x51, 0x59,
-	0xef, 0xe5, 0xa6, 0xba, 0xf0, 0x28, 0x1c, 0xbe, 0x94, 0xa5, 0x4c, 0x8b, 0x8e, 0x82, 0xe6, 0xb2,
+	0x79, 0x2f, 0x37, 0xd5, 0x85, 0x47, 0xe1, 0xf0, 0xa5, 0x2c, 0x65, 0x5a, 0x74, 0x14, 0x34, 0x97,
-	0x29, 0x2b, 0xfa, 0xc7, 0xf8, 0x50, 0x38, 0x1c, 0xdf, 0x94, 0xe5, 0x7d, 0x23, 0x48, 0x25, 0x03,
+	0x4d, 0x59, 0xd1, 0x3f, 0xc6, 0x87, 0xc2, 0xe1, 0xf8, 0xa6, 0x2c, 0xef, 0x1b, 0x41, 0x2a, 0x19,
-	0x35, 0xcb, 0x7e, 0x31, 0x95, 0x14, 0x74, 0xcd, 0xab, 0xed, 0x53, 0xbd, 0x0a, 0x9a, 0x57, 0xf5,
+	0xa8, 0x59, 0xf6, 0x8b, 0xa9, 0xa4, 0xa0, 0x6b, 0x5e, 0x6d, 0x9f, 0xea, 0x55, 0xd0, 0xbc, 0xaa,
-	0xc9, 0xd5, 0xa9, 0x4d, 0xae, 0x4d, 0xe8, 0xa2, 0x9e, 0x3c, 0xe8, 0x17, 0x31, 0xd5, 0x6b, 0x4c,
+	0x4f, 0xae, 0x4e, 0x6d, 0x72, 0x6d, 0x42, 0x17, 0xf5, 0xe4, 0x41, 0xbf, 0x88, 0xa9, 0x5e, 0x63,
-	0x3d, 0x36, 0xba, 0xd5, 0xd8, 0xd0, 0xbd, 0xbb, 0x34, 0xc1, 0xbb, 0xcb, 0x85, 0x77, 0x7f, 0x6b,
+	0xea, 0xb1, 0xd1, 0xad, 0xc6, 0x86, 0xee, 0xdd, 0xa5, 0x09, 0xde, 0x5d, 0x2e, 0xbc, 0xfb, 0x6b,
-	0x02, 0xec, 0x90, 0xc8, 0x8d, 0xd3, 0x90, 0xd0, 0x94, 0x0f, 0xcf, 0x2b, 0xa8, 0xc2, 0xb9, 0x1a,
+	0x13, 0x60, 0x87, 0x44, 0x6e, 0x9c, 0x86, 0x84, 0xa6, 0x7c, 0x78, 0x5e, 0x41, 0x15, 0xce, 0xd5,
-	0x4f, 0xcd, 0x13, 0xa6, 0x9e, 0x27, 0x2c, 0x98, 0x13, 0x80, 0xa3, 0x37, 0xc5, 0x6f, 0x0e, 0x66,
+	0x78, 0x6a, 0x9e, 0x30, 0xf5, 0x3c, 0x61, 0xc1, 0x9c, 0x00, 0x1c, 0xbd, 0x29, 0x7e, 0x73, 0x30,
-	0xe4, 0xc6, 0xa8, 0x0d, 0x83, 0xbc, 0xa0, 0x79, 0x1e, 0x60, 0xb1, 0x27, 0x33, 0x47, 0xd3, 0x41,
+	0x23, 0x37, 0x46, 0x6d, 0x18, 0xe4, 0x05, 0xcd, 0xf3, 0x00, 0x8b, 0x3d, 0x99, 0x39, 0x9a, 0x0e,
-	0x82, 0x4f, 0xfe, 0xb2, 0x3f, 0x51, 0xd0, 0xb4, 0x70, 0x5d, 0xd7, 0xb9, 0x67, 0xd6, 0x60, 0x2f,
+	0x12, 0x7c, 0xf2, 0x97, 0xfd, 0x89, 0x82, 0xa6, 0x85, 0xeb, 0xba, 0xce, 0x3d, 0xb3, 0x06, 0x7b,
-	0xc1, 0x4a, 0x92, 0x1d, 0x94, 0x83, 0xdb, 0xcb, 0x42, 0x19, 0xee, 0x35, 0x3e, 0x07, 0x15, 0x8b,
+	0x09, 0x56, 0x92, 0xec, 0xa0, 0x1c, 0xdc, 0x5e, 0x16, 0xca, 0x70, 0xaf, 0xf1, 0x39, 0xa8, 0x58,
-	0x33, 0xde, 0x08, 0x53, 0x4d, 0xc9, 0xa8, 0x56, 0x05, 0xf6, 0xbb, 0x26, 0xac, 0xdc, 0x8d, 0x87,
+	0x9c, 0xf1, 0x46, 0x98, 0x6a, 0x4a, 0x46, 0xb5, 0x2a, 0xb0, 0xdf, 0x35, 0x61, 0xe5, 0x6e, 0x3c,
-	0x2e, 0xf5, 0xbf, 0x2b, 0xca, 0x4d, 0xb1, 0x80, 0xcf, 0x92, 0x72, 0x37, 0xa0, 0x43, 0xe8, 0x30,
+	0x74, 0xa9, 0xff, 0x6d, 0x51, 0x6e, 0x8a, 0x05, 0x7c, 0x96, 0x94, 0xbb, 0x01, 0x1d, 0x42, 0x87,
-	0xf0, 0x93, 0xa3, 0xbd, 0x12, 0x37, 0x95, 0xa5, 0x82, 0x3d, 0x37, 0x29, 0x29, 0x37, 0xb5, 0xa4,
+	0x81, 0x9f, 0x1c, 0xed, 0x95, 0xb8, 0xa9, 0x2c, 0x15, 0xec, 0xb9, 0x49, 0x49, 0xb9, 0xa9, 0x25,
-	0xbc, 0x06, 0xad, 0x90, 0x1d, 0xf8, 0x41, 0x1e, 0xf7, 0x92, 0x12, 0x31, 0x4f, 0x02, 0x22, 0xb2,
+	0xe5, 0x35, 0x68, 0x85, 0xec, 0xc0, 0x0f, 0xf2, 0xb8, 0x97, 0x94, 0x88, 0x79, 0x12, 0x10, 0x91,
-	0x73, 0x11, 0xf3, 0x39, 0xa3, 0x4c, 0xd4, 0x0b, 0x63, 0x13, 0x75, 0x5b, 0x4d, 0xd4, 0x3a, 0xf0,
+	0x9d, 0x8b, 0x98, 0xcf, 0x19, 0x65, 0xa2, 0x5e, 0x18, 0x9b, 0xa8, 0xdb, 0x6a, 0xa2, 0xd6, 0x81,
-	0x50, 0x03, 0x1e, 0xe1, 0xea, 0x14, 0x70, 0xfd, 0xc9, 0x80, 0x95, 0x12, 0x6e, 0xac, 0x41, 0x27,
+	0x87, 0x1a, 0xf0, 0x08, 0x57, 0xa7, 0x80, 0xeb, 0x8f, 0x06, 0xac, 0x94, 0x70, 0x63, 0x0d, 0x3a,
-	0xc2, 0x55, 0x8d, 0x40, 0x73, 0x4c, 0x04, 0x16, 0x71, 0xd3, 0x50, 0xe3, 0x86, 0x47, 0x1a, 0x4b,
+	0x11, 0xae, 0x6a, 0x04, 0x9a, 0x63, 0x22, 0xb0, 0x88, 0x9b, 0x86, 0x1a, 0x37, 0x3c, 0xd2, 0x58,
-	0x7c, 0xa5, 0xde, 0x2f, 0x68, 0xde, 0x5b, 0x40, 0x5c, 0x05, 0x2c, 0xa4, 0x94, 0xaa, 0xbb, 0xa5,
+	0xe2, 0x2b, 0xf5, 0x7e, 0x41, 0xf3, 0xde, 0x02, 0xe2, 0x2a, 0x60, 0x21, 0xa5, 0x54, 0xdd, 0x2d,
-	0x55, 0xdd, 0xd5, 0x3c, 0xfa, 0x07, 0x03, 0x2e, 0x72, 0x2f, 0xd7, 0x86, 0x71, 0x17, 0x56, 0x58,
+	0xad, 0xea, 0xae, 0xe6, 0xd1, 0xdf, 0x19, 0x70, 0x91, 0x7b, 0xb9, 0x36, 0x8c, 0xbb, 0xb0, 0xc2,
-	0x25, 0x12, 0x64, 0xa2, 0xf9, 0xd4, 0x98, 0x44, 0x51, 0x0d, 0x1a, 0xa7, 0x26, 0xcc, 0x15, 0x7a,
+	0x2a, 0x91, 0x20, 0x13, 0xcd, 0x27, 0xc6, 0x24, 0x8a, 0x6a, 0xd0, 0x38, 0x35, 0x61, 0xae, 0xd0,
-	0x95, 0x4e, 0x64, 0xe6, 0x19, 0xa7, 0xb0, 0x6a, 0x8f, 0x53, 0x13, 0xb6, 0x3f, 0x30, 0x60, 0x05,
+	0xab, 0x74, 0x22, 0x33, 0xcf, 0x38, 0x85, 0x55, 0x7b, 0x9c, 0x9a, 0xb0, 0xfd, 0x7b, 0x03, 0x56,
-	0x53, 0x9b, 0x32, 0xcf, 0xcf, 0xdd, 0xec, 0xb7, 0xe0, 0x62, 0xb5, 0xe7, 0x3b, 0x7e, 0x92, 0xf6,
+	0x30, 0xb5, 0x29, 0xf3, 0xfc, 0xdc, 0xcd, 0x7e, 0x0b, 0x2e, 0x56, 0x7b, 0xbe, 0xe3, 0x27, 0x69,
-	0xcc, 0x8d, 0xc6, 0xb4, 0xa6, 0x8f, 0x55, 0x60, 0x7f, 0x0f, 0x7a, 0xfb, 0x59, 0x10, 0xec, 0x92,
+	0xcf, 0xdc, 0x68, 0x4c, 0x6b, 0xfa, 0x58, 0x05, 0xf6, 0x77, 0xa0, 0xb7, 0x9f, 0x05, 0xc1, 0x2e,
-	0x24, 0x71, 0x87, 0x64, 0xeb, 0x51, 0x9f, 0x8c, 0x38, 0xdf, 0x21, 0x49, 0xc4, 0x27, 0x07, 0x89,
+	0x49, 0x12, 0x77, 0x48, 0xb6, 0x1e, 0xf5, 0xc9, 0x88, 0xf3, 0x1d, 0x92, 0x44, 0x7c, 0x72, 0x90,
-	0xe3, 0x6d, 0xe6, 0x11, 0x61, 0x7c, 0xd3, 0xc9, 0x49, 0xee, 0x57, 0x12, 0xc7, 0x7c, 0x85, 0x94,
+	0x38, 0xde, 0x66, 0x1e, 0x11, 0xc6, 0x37, 0x9d, 0x9c, 0xe4, 0x7e, 0x25, 0x71, 0xcc, 0x57, 0x48,
-	0x25, 0x1c, 0x52, 0xd6, 0x15, 0x98, 0x0b, 0xb8, 0x59, 0x0d, 0x61, 0xd6, 0xfa, 0x18, 0xb3, 0x76,
+	0x59, 0xc2, 0x21, 0x65, 0x5d, 0x81, 0xb9, 0x80, 0x9b, 0xd5, 0x10, 0x66, 0xad, 0x8f, 0x31, 0x6b,
-	0x93, 0xe1, 0x8e, 0x9b, 0xba, 0x8e, 0x68, 0x67, 0x87, 0xf0, 0xdc, 0xf8, 0xde, 0x47, 0x13, 0x03,
+	0x37, 0x19, 0xee, 0xb8, 0xa9, 0xeb, 0x88, 0x76, 0x76, 0x08, 0xcf, 0x8d, 0xef, 0x7d, 0x34, 0x31,
-	0x98, 0x17, 0x59, 0xa2, 0x4a, 0xf1, 0x19, 0x2d, 0xe2, 0x57, 0x65, 0x71, 0xb3, 0x13, 0xd4, 0x23,
+	0x80, 0x79, 0x91, 0x25, 0xaa, 0x14, 0x9f, 0xd1, 0x22, 0x7e, 0x55, 0x16, 0x37, 0x3b, 0x41, 0x3d,
-	0xec, 0xe8, 0x3a, 0x39, 0x69, 0x5f, 0x04, 0xeb, 0x26, 0x49, 0x77, 0xdd, 0x87, 0xd7, 0xa8, 0xb7,
+	0xc2, 0x8e, 0xae, 0x93, 0x93, 0xf6, 0x45, 0xb0, 0x6e, 0x92, 0x74, 0xd7, 0x7d, 0x78, 0x8d, 0x7a,
-	0xeb, 0xd3, 0x3e, 0x19, 0x39, 0x64, 0x64, 0x5f, 0x87, 0x0b, 0x35, 0x6e, 0x12, 0x89, 0x89, 0xee,
+	0xbb, 0x3e, 0xed, 0x93, 0x91, 0x43, 0x46, 0xf6, 0x75, 0xb8, 0x50, 0xe3, 0x26, 0x91, 0x98, 0xe8,
-	0x3e, 0xec, 0x93, 0x91, 0x30, 0xa0, 0xeb, 0x48, 0x4a, 0xf0, 0x45, 0x2b, 0x59, 0xbf, 0x49, 0xca,
+	0xee, 0xc3, 0x3e, 0x19, 0x09, 0x03, 0xba, 0x8e, 0xa4, 0x04, 0x5f, 0xb4, 0x92, 0xf5, 0x9b, 0xa4,
-	0x1e, 0xc1, 0x32, 0x77, 0x55, 0x9f, 0x50, 0x6f, 0x37, 0x19, 0x0a, 0x15, 0x1b, 0xd0, 0x41, 0x04,
+	0xec, 0x11, 0x2c, 0x73, 0x57, 0xf5, 0x09, 0xf5, 0x76, 0x93, 0xa1, 0x50, 0xb1, 0x01, 0x1d, 0x44,
-	0x76, 0x93, 0x61, 0x59, 0x10, 0x2a, 0x2c, 0xde, 0x62, 0x10, 0xf8, 0xdc, 0x25, 0xa2, 0x85, 0x1c,
+	0x60, 0x37, 0x19, 0x96, 0x05, 0xa1, 0xc2, 0xe2, 0x2d, 0x06, 0x81, 0xcf, 0x5d, 0x22, 0x5a, 0xc8,
-	0x8d, 0xc2, 0xe2, 0xd3, 0x2e, 0x21, 0x72, 0x7f, 0xc4, 0xe7, 0x63, 0xc3, 0x29, 0x68, 0xfb, 0x83,
+	0xd1, 0x28, 0x2c, 0x3e, 0xed, 0x12, 0x22, 0xf7, 0x47, 0x7c, 0x3e, 0x36, 0x9c, 0x82, 0xb6, 0xff,
-	0x26, 0xcc, 0x4b, 0x40, 0xc5, 0x54, 0xe3, 0x35, 0x78, 0x81, 0x17, 0x52, 0x98, 0x2d, 0x07, 0x27,
+	0xd6, 0x84, 0x79, 0x09, 0xa8, 0x98, 0x6a, 0xbc, 0x06, 0x2f, 0xf0, 0x42, 0x0a, 0xb3, 0xe5, 0xe0,
-	0xe5, 0x56, 0x13, 0x29, 0x75, 0x73, 0xda, 0xd0, 0x37, 0xa7, 0x15, 0x9b, 0xe6, 0xea, 0x36, 0x55,
+	0xa4, 0xdc, 0x6a, 0x22, 0xa5, 0x6e, 0x4e, 0x1b, 0xfa, 0xe6, 0xb4, 0x62, 0xd3, 0x5c, 0xdd, 0xa6,
-	0xc6, 0xd5, 0xac, 0x8f, 0x8b, 0x27, 0x07, 0xb1, 0x5e, 0xee, 0x07, 0x6e, 0x7a, 0xc8, 0xe2, 0x50,
+	0xca, 0xb8, 0x9a, 0xf5, 0x71, 0xf1, 0xe4, 0x20, 0xd6, 0xcb, 0xfd, 0xc0, 0x4d, 0x0f, 0x59, 0x1c,
-	0x96, 0xd4, 0x4d, 0xa7, 0xc6, 0xe7, 0x09, 0x09, 0x79, 0x45, 0x45, 0x81, 0x0b, 0x43, 0x85, 0xcb,
+	0xca, 0x92, 0xba, 0xe9, 0xd4, 0xf8, 0x3c, 0x21, 0x21, 0xaf, 0xa8, 0x28, 0x70, 0x61, 0xa8, 0x70,
-	0xf3, 0x37, 0x72, 0xf2, 0xca, 0x02, 0xf7, 0x32, 0x3a, 0x13, 0x6d, 0x4b, 0x12, 0x9f, 0x51, 0x91,
+	0x79, 0xfe, 0x46, 0x4e, 0x5e, 0x59, 0xe0, 0x5e, 0x46, 0x67, 0xa2, 0x6d, 0x49, 0xe2, 0x33, 0x2a,
-	0xdb, 0xb0, 0x80, 0x50, 0x59, 0x7c, 0xe4, 0x61, 0x32, 0xbc, 0x11, 0xb3, 0x50, 0xee, 0x68, 0x72,
+	0x72, 0x1b, 0x16, 0x10, 0x2a, 0x8b, 0x8f, 0x3c, 0x4c, 0x86, 0x37, 0x62, 0x16, 0xca, 0x1d, 0x4d,
-	0x52, 0x8c, 0x9c, 0xd1, 0x34, 0xcf, 0x8b, 0x1d, 0x94, 0x55, 0x58, 0x5c, 0x56, 0x92, 0xa2, 0x7a,
+	0x4e, 0x8a, 0x91, 0x33, 0x9a, 0xe6, 0x79, 0xb1, 0x83, 0xb2, 0x0a, 0x8b, 0xcb, 0x4a, 0x52, 0x54,
-	0x58, 0x74, 0x72, 0xd2, 0x5a, 0x81, 0x46, 0x42, 0x46, 0xb2, 0x24, 0xe0, 0x3f, 0x35, 0xcf, 0x2d,
+	0x0f, 0x8b, 0x4e, 0x4e, 0x5a, 0x2b, 0xd0, 0x48, 0xc8, 0x48, 0x96, 0x04, 0xfc, 0xa7, 0xe6, 0xb9,
-	0xeb, 0x9e, 0xab, 0xac, 0xf1, 0x2b, 0xe2, 0xab, 0xba, 0xc6, 0x97, 0x0b, 0xe7, 0xaa, 0xb6, 0x70,
+	0x65, 0xdd, 0x73, 0x95, 0x35, 0x7e, 0x45, 0x7c, 0x55, 0xd7, 0xf8, 0x72, 0xe1, 0x5c, 0xd5, 0x16,
-	0x5e, 0x83, 0x79, 0x16, 0xf1, 0x38, 0x4f, 0x7a, 0x96, 0x98, 0x63, 0x9f, 0x9e, 0x3c, 0xc7, 0xae,
+	0xce, 0x6b, 0x30, 0xcf, 0x22, 0x1e, 0xe7, 0x49, 0xcf, 0x12, 0x73, 0xec, 0x93, 0x93, 0xe7, 0xd8,
-	0xdc, 0xc5, 0x96, 0xd7, 0x69, 0x1a, 0x3f, 0x72, 0x72, 0x39, 0xeb, 0x0e, 0x2c, 0xb3, 0xc3, 0xc3,
+	0x95, 0xbb, 0xd8, 0xf2, 0x3a, 0x4d, 0xe3, 0x47, 0x4e, 0x2e, 0x67, 0xdd, 0x81, 0x65, 0x76, 0x78,
-	0xc0, 0xa7, 0x64, 0x3f, 0x4b, 0x8e, 0x44, 0xe9, 0x7d, 0x41, 0x2c, 0x4d, 0xf6, 0xb8, 0xa5, 0x49,
+	0x18, 0xf8, 0x94, 0xec, 0x67, 0xc9, 0x91, 0x28, 0xbd, 0x2f, 0x88, 0xa5, 0xc9, 0x1e, 0xb7, 0x34,
-	0x6f, 0xe9, 0x54, 0x45, 0xd7, 0x5f, 0x83, 0x45, 0xb5, 0x1b, 0x0e, 0xc3, 0x31, 0x79, 0x24, 0x63,
+	0xe9, 0x2d, 0x9d, 0xaa, 0x28, 0xcf, 0x27, 0x6e, 0x8a, 0xa5, 0x93, 0x98, 0x71, 0x17, 0x37, 0x1a,
-	0x90, 0xff, 0xe4, 0xd9, 0xe4, 0xc4, 0x0d, 0x32, 0xcc, 0xce, 0x0b, 0x0e, 0x12, 0xaf, 0x99, 0x5f,
+	0x3c, 0x9f, 0xa8, 0xbc, 0xf5, 0xd7, 0x60, 0x51, 0x35, 0x85, 0x43, 0x75, 0x4c, 0x1e, 0xc9, 0x38,
-	0x32, 0xec, 0x9f, 0x1a, 0xb0, 0x5c, 0xe9, 0x80, 0xb7, 0x4e, 0xfd, 0x34, 0x20, 0x52, 0x03, 0x12,
+	0xe5, 0x3f, 0x79, 0xc6, 0x39, 0x71, 0x83, 0x0c, 0x33, 0xf8, 0x82, 0x83, 0xc4, 0x6b, 0xe6, 0x17,
-	0xbc, 0xf2, 0xf1, 0x48, 0x32, 0x90, 0x21, 0x2c, 0x7e, 0xcb, 0x1c, 0xd2, 0x28, 0xf6, 0xb3, 0x36,
+	0x0c, 0xfb, 0xc7, 0x06, 0x2c, 0x57, 0x8c, 0xe0, 0xad, 0x53, 0x3f, 0x0d, 0x88, 0xd4, 0x80, 0x04,
-	0x2c, 0xfa, 0x77, 0xfb, 0x5c, 0x51, 0x9f, 0x65, 0xd4, 0x2b, 0xce, 0xa4, 0x14, 0x1e, 0x0f, 0x21,
+	0xaf, 0x8e, 0x3c, 0x92, 0x0c, 0x64, 0x98, 0x8b, 0xdf, 0x32, 0xcf, 0x34, 0x8a, 0x3d, 0xaf, 0x0d,
-	0xff, 0x6e, 0x7f, 0xcb, 0xf5, 0x86, 0x04, 0x4f, 0x8e, 0x9a, 0xc2, 0x26, 0x9d, 0x69, 0x7b, 0xb0,
+	0x8b, 0xfe, 0xdd, 0x3e, 0x57, 0xd4, 0x67, 0x19, 0xf5, 0x8a, 0x73, 0x2b, 0x85, 0xc7, 0xc3, 0xcc,
-	0x70, 0xcf, 0x8f, 0x92, 0x6d, 0x16, 0x86, 0xdc, 0x11, 0x1e, 0x49, 0x79, 0x8e, 0x36, 0x84, 0xbf,
+	0xbf, 0xdb, 0xdf, 0x72, 0xbd, 0x21, 0xc1, 0xd3, 0xa5, 0xa6, 0xb0, 0x49, 0x67, 0xda, 0x1e, 0x2c,
-	0x25, 0xc5, 0x43, 0xc5, 0x23, 0x87, 0x6e, 0x16, 0xa4, 0xbc, 0x69, 0x3e, 0x71, 0x15, 0x96, 0x38,
+	0xdc, 0xf3, 0xa3, 0x64, 0x9b, 0x85, 0x21, 0x77, 0x96, 0x47, 0x52, 0x9e, 0xc7, 0x0d, 0x11, 0x13,
-	0x33, 0x49, 0x18, 0xdd, 0x41, 0x69, 0xb4, 0x53, 0xe1, 0xd8, 0x7f, 0x36, 0x61, 0x45, 0xec, 0x6c,
+	0x92, 0xe2, 0xe1, 0xe4, 0x91, 0x43, 0x37, 0x0b, 0x52, 0xde, 0x34, 0x9f, 0xdc, 0x0a, 0x4b, 0x9c,
-	0xb6, 0x85, 0xdb, 0x3d, 0x21, 0xf4, 0x0a, 0x34, 0xc5, 0x34, 0x94, 0xd9, 0xe2, 0xf4, 0xdd, 0x10,
+	0xab, 0x24, 0x8c, 0xee, 0xa0, 0x34, 0xda, 0xa9, 0x70, 0xec, 0x3f, 0x99, 0xb0, 0x22, 0x76, 0x3f,
-	0x36, 0xb5, 0xae, 0x42, 0x8b, 0x45, 0x22, 0xc5, 0x60, 0x22, 0x7b, 0x61, 0x92, 0x90, 0x7e, 0x3c,
+	0xdb, 0x22, 0x34, 0x3c, 0x21, 0xf4, 0x0a, 0x34, 0xc5, 0x54, 0x95, 0x19, 0xe5, 0xf4, 0x1d, 0x13,
-	0xe5, 0x48, 0x29, 0xeb, 0x06, 0x40, 0x58, 0x66, 0x14, 0x5c, 0xba, 0xa7, 0xd5, 0xa1, 0x48, 0x72,
+	0x36, 0xb5, 0xae, 0x42, 0x8b, 0x45, 0x22, 0x0d, 0x61, 0xb2, 0x7b, 0x61, 0x92, 0x90, 0x7e, 0x84,
-	0x70, 0x8b, 0x65, 0xb8, 0x38, 0xa3, 0x6a, 0x38, 0x3a, 0xd3, 0xda, 0x83, 0x25, 0x61, 0xf6, 0xdd,
+	0xe5, 0x48, 0x29, 0xeb, 0x06, 0x40, 0x58, 0x66, 0x1d, 0x5c, 0xde, 0xa7, 0xd5, 0xa1, 0x48, 0x72,
-	0x7c, 0x5b, 0x2c, 0x7c, 0x30, 0x7d, 0x8f, 0x15, 0x69, 0xfb, 0x97, 0x86, 0x84, 0x91, 0x7f, 0xed,
+	0x70, 0x8b, 0xa5, 0xba, 0x38, 0xc7, 0x6a, 0x38, 0x3a, 0xd3, 0xda, 0x83, 0x25, 0x61, 0xf6, 0xdd,
-	0x13, 0xc4, 0xbe, 0x84, 0xc4, 0x98, 0x09, 0x92, 0x75, 0x58, 0x08, 0x33, 0x65, 0x97, 0xde, 0x70,
+	0x7c, 0xeb, 0x2c, 0x7c, 0x30, 0x7d, 0x8f, 0x15, 0x69, 0xfb, 0xe7, 0x86, 0x84, 0x91, 0x7f, 0xed,
-	0x0a, 0xba, 0x74, 0x51, 0x63, 0x6a, 0x17, 0xd9, 0xbf, 0x32, 0xa0, 0xf7, 0x06, 0xf3, 0xa9, 0xf8,
+	0x13, 0xc4, 0xbe, 0x84, 0xc4, 0x98, 0x09, 0x92, 0x75, 0x58, 0x08, 0x33, 0x65, 0x27, 0xdf, 0x70,
-	0x70, 0x2d, 0x8a, 0x02, 0x79, 0x90, 0x3a, 0xb3, 0xcf, 0xbf, 0x06, 0x6d, 0x17, 0xd5, 0xd0, 0x54,
+	0x0a, 0xba, 0x74, 0x51, 0x63, 0x6a, 0x17, 0xd9, 0xbf, 0x30, 0xa0, 0xf7, 0x06, 0xf3, 0xa9, 0xf8,
-	0xba, 0x7d, 0x8a, 0x9d, 0x77, 0x29, 0xa3, 0x6c, 0xa2, 0x1a, 0xea, 0x26, 0xca, 0x7e, 0xcf, 0x80,
+	0x70, 0x2d, 0x8a, 0x02, 0x79, 0xd8, 0x3a, 0xb3, 0xcf, 0xbf, 0x02, 0x6d, 0x17, 0xd5, 0xd0, 0x54,
+	0xba, 0x7d, 0x8a, 0xdd, 0x79, 0x29, 0xa3, 0x6c, 0xb4, 0x1a, 0xea, 0x46, 0xcb, 0x7e, 0xcf, 0x80,
 	0x25, 0x04, 0xe5, 0xcd, 0xcc, 0x4f, 0x67, 0xb6, 0x6f, 0x0b, 0x16, 0x46, 0x99, 0x9f, 0xce, 0x10,
 	0x95, 0x85, 0x5c, 0x3d, 0x9e, 0x1a, 0x63, 0xe2, 0xc9, 0x7e, 0xdf, 0x80, 0x4b, 0x55, 0x58, 0xaf,
-	0x0d, 0x06, 0x24, 0x7a, 0x92, 0x53, 0x4a, 0xdb, 0x44, 0xce, 0x55, 0x36, 0x91, 0x63, 0x4d, 0x76,
+	0x0d, 0x06, 0x24, 0x7a, 0x92, 0x53, 0x4a, 0xdb, 0x68, 0xce, 0x55, 0x36, 0x9a, 0x63, 0x4d, 0x76,
-	0xc8, 0x3b, 0x64, 0xf0, 0xf4, 0x9a, 0xfc, 0x43, 0x13, 0x3e, 0x76, 0xb3, 0x98, 0x78, 0xf7, 0x62,
+	0xc8, 0x3b, 0x64, 0xf0, 0xf4, 0x9a, 0xfc, 0x7d, 0x13, 0x3e, 0x72, 0xb3, 0x98, 0x78, 0xf7, 0x62,
 	0x97, 0x26, 0x87, 0x24, 0x8e, 0x9f, 0xa0, 0xbd, 0x77, 0xa0, 0x4b, 0xc9, 0x83, 0xd2, 0x26, 0x39,
-	0x1d, 0xa7, 0x55, 0xa3, 0x0b, 0x4f, 0xb7, 0x76, 0xd9, 0xff, 0x36, 0x60, 0x05, 0xf5, 0x7c, 0xdd,
+	0x1d, 0xa7, 0x55, 0xa3, 0x0b, 0x4f, 0xb7, 0x76, 0xd9, 0xff, 0x36, 0x60, 0x05, 0xf5, 0x7c, 0xd5,
 	0x1f, 0x1c, 0x3f, 0xc1, 0xc1, 0xef, 0xc1, 0xd2, 0xb1, 0xb0, 0x80, 0x53, 0x33, 0x2c, 0xdb, 0x15,
 	0xe9, 0x29, 0x87, 0xff, 0x1f, 0x03, 0x56, 0x51, 0xd1, 0x6d, 0x7a, 0xe2, 0x3f, 0xc9, 0x60, 0xdd,
-	0x87, 0x65, 0x1f, 0x4d, 0x98, 0x11, 0x80, 0xaa, 0xf8, 0x94, 0x08, 0xfc, 0xde, 0x80, 0x65, 0xd4,
+	0x87, 0x65, 0x1f, 0x4d, 0x98, 0x11, 0x80, 0xaa, 0xf8, 0x94, 0x08, 0xfc, 0xd6, 0x80, 0x65, 0xd4,
 	0x74, 0x9d, 0xa6, 0x24, 0x9e, 0x79, 0xfc, 0xb7, 0xa0, 0x43, 0x68, 0x1a, 0xbb, 0x74, 0x96, 0x15,
 	0x52, 0x15, 0x9d, 0x72, 0x91, 0x7c, 0xcf, 0x00, 0x4b, 0xa8, 0xda, 0xf1, 0x93, 0xd0, 0x4f, 0x92,
-	0x27, 0xe8, 0xba, 0xe9, 0x0c, 0xfe, 0xb9, 0x09, 0x17, 0x15, 0x2d, 0xbb, 0x59, 0xfa, 0xb4, 0x9b,
+	0x27, 0xe8, 0xba, 0xe9, 0x0c, 0xfe, 0xa9, 0x09, 0x17, 0x15, 0x2d, 0xbb, 0x59, 0xfa, 0xb4, 0x9b,
-	0x6c, 0xed, 0x40, 0x9b, 0xd7, 0x08, 0xea, 0xed, 0xc4, 0xb4, 0x1d, 0x95, 0x82, 0xbc, 0x8a, 0x15,
+	0x6c, 0xed, 0x40, 0x9b, 0xd7, 0x08, 0xea, 0x0d, 0xc6, 0xb4, 0x1d, 0x95, 0x82, 0xbc, 0x8a, 0x15,
 	0x44, 0x9f, 0x0c, 0x18, 0xf5, 0x12, 0x51, 0x1c, 0x75, 0x1d, 0x8d, 0xc7, 0x97, 0xa1, 0x75, 0x45,
-	0xcd, 0xb6, 0x4b, 0x07, 0x24, 0x78, 0x66, 0x20, 0xb2, 0x7f, 0x63, 0xc0, 0x12, 0x36, 0x79, 0xfa,
+	0xcd, 0xb6, 0x4b, 0x07, 0x24, 0x78, 0x66, 0x20, 0xb2, 0x7f, 0x65, 0xc0, 0x12, 0x36, 0x79, 0xfa,
-	0x87, 0xcc, 0x73, 0x3d, 0x06, 0xf2, 0x47, 0xc6, 0x4b, 0x3c, 0xbc, 0xd6, 0x14, 0x2d, 0x6a, 0x5d,
+	0x87, 0xcc, 0x73, 0x3d, 0x06, 0xf2, 0x87, 0xc6, 0x4b, 0x3c, 0xbc, 0xd6, 0x14, 0x2d, 0x6a, 0x5d,
 	0xfd, 0xf4, 0x86, 0xd6, 0x2d, 0xe8, 0x0c, 0x8e, 0x5c, 0x3a, 0x9c, 0x29, 0xb8, 0x54, 0x51, 0x3b,
-	0x85, 0xe7, 0xd4, 0x03, 0xb9, 0x6d, 0xfc, 0x24, 0x86, 0xff, 0x6a, 0x65, 0x28, 0xa7, 0xde, 0x3e,
+	0x85, 0xe7, 0xd4, 0x43, 0xbb, 0x6d, 0xfc, 0x24, 0x86, 0xff, 0x6a, 0x65, 0x28, 0xa7, 0xde, 0x50,
-	0x3e, 0x1e, 0xe8, 0xc7, 0xb0, 0x8a, 0xb7, 0x40, 0x4a, 0x4d, 0x68, 0xf5, 0x60, 0xde, 0xf5, 0xf0,
+	0x3e, 0x1e, 0xe8, 0xc7, 0xb0, 0x8a, 0x37, 0x45, 0x4a, 0x4d, 0x68, 0xf5, 0x60, 0xde, 0xf5, 0xf0,
-	0x00, 0xc1, 0x10, 0x42, 0x39, 0xa9, 0xdf, 0xef, 0xc9, 0x27, 0x1c, 0xe5, 0xfd, 0xde, 0x65, 0x00,
+	0x90, 0xc1, 0x10, 0x42, 0x39, 0xa9, 0xdf, 0x01, 0xca, 0x67, 0x1e, 0xe5, 0x1d, 0xe0, 0x65, 0x00,
 	0xd7, 0xf3, 0xde, 0x62, 0xb1, 0xe7, 0xd3, 0xbc, 0xc0, 0x57, 0x38, 0xf6, 0x1b, 0xb0, 0x78, 0x23,
-	0x66, 0xe1, 0x3d, 0xe5, 0x3e, 0xe7, 0xd4, 0x1b, 0x27, 0xf5, 0x2e, 0xc8, 0xd4, 0xef, 0x82, 0xec,
+	0x66, 0xe1, 0x3d, 0xe5, 0xce, 0xe7, 0xd4, 0x5b, 0x29, 0xf5, 0xbe, 0xc8, 0xd4, 0xef, 0x8b, 0xec,
-	0xef, 0xc0, 0xff, 0xd7, 0x0c, 0x17, 0x60, 0x6d, 0xe3, 0x35, 0x55, 0xde, 0x89, 0x0c, 0x99, 0x4f,
+	0x6f, 0xc1, 0xff, 0xd7, 0x0c, 0x17, 0x60, 0x6d, 0xe3, 0x55, 0x56, 0xde, 0x89, 0x0c, 0x99, 0x8f,
-	0x8c, 0x81, 0x4c, 0xb5, 0xc5, 0xd1, 0x84, 0xec, 0x1f, 0x18, 0xf0, 0x7c, 0x4d, 0xfd, 0xb5, 0x28,
+	0x8d, 0x81, 0x4c, 0xb5, 0xc5, 0xd1, 0x84, 0xec, 0xef, 0x19, 0xf0, 0x7c, 0x4d, 0xfd, 0xb5, 0x28,
 	0x8a, 0xd9, 0x89, 0xf4, 0xc9, 0x79, 0x74, 0xa3, 0x17, 0xbf, 0x66, 0xb5, 0xf8, 0x1d, 0x6b, 0x84,
-	0x56, 0xb0, 0x7f, 0x08, 0x46, 0xfc, 0xda, 0x80, 0x65, 0x69, 0x84, 0xe7, 0xc9, 0x6e, 0xbf, 0x08,
+	0x56, 0xb0, 0x7f, 0x00, 0x46, 0xfc, 0xd2, 0x80, 0x65, 0x69, 0x84, 0xe7, 0xc9, 0x6e, 0x3f, 0x0f,
-	0x2d, 0xbc, 0xe2, 0x96, 0x1d, 0x3e, 0x3f, 0xb6, 0xc3, 0xfc, 0x6a, 0xde, 0x91, 0x8d, 0xeb, 0x11,
+	0x2d, 0xbc, 0x06, 0x97, 0x1d, 0x3e, 0x3f, 0xb6, 0xc3, 0xfc, 0xfa, 0xde, 0x91, 0x8d, 0xeb, 0x11,
-	0x69, 0x8e, 0x9b, 0x51, 0x5f, 0x2e, 0x82, 0x7d, 0xea, 0x4b, 0x68, 0x29, 0x60, 0x7f, 0x33, 0x0f,
+	0x69, 0x8e, 0x9b, 0x51, 0x5f, 0x2c, 0x82, 0x7d, 0xea, 0x8b, 0x6a, 0x29, 0x60, 0x7f, 0x3d, 0x0f,
-	0xe6, 0x1d, 0x12, 0x90, 0xf3, 0xc4, 0xc8, 0xbe, 0x0f, 0x4b, 0xe2, 0xbe, 0xbd, 0xc4, 0xe0, 0x5c,
+	0xe6, 0x1d, 0x12, 0x90, 0xf3, 0xc4, 0xc8, 0xbe, 0x0f, 0x4b, 0xe2, 0x4e, 0xbe, 0xc4, 0xe0, 0x5c,
 	0xd4, 0xbe, 0x05, 0x2b, 0x42, 0xed, 0xb9, 0xdb, 0x5b, 0xcc, 0x0e, 0x8e, 0x8f, 0xba, 0x94, 0x9c,
-	0x8b, 0xf6, 0xcf, 0xc3, 0x85, 0x1c, 0xfb, 0xfb, 0x91, 0x57, 0x1c, 0x22, 0x4d, 0x38, 0x3a, 0xb7,
+	0x8b, 0xf6, 0xcf, 0xc2, 0x85, 0x1c, 0xfb, 0xfb, 0x91, 0x57, 0x1c, 0x22, 0x4d, 0x38, 0x5e, 0xb7,
-	0xbf, 0x00, 0x6b, 0xdb, 0x8c, 0x9e, 0x90, 0x38, 0xc1, 0x8b, 0x05, 0x21, 0x92, 0x4b, 0x68, 0x93,
+	0x3f, 0x07, 0x6b, 0xdb, 0x8c, 0x9e, 0x90, 0x38, 0xc1, 0xcb, 0x07, 0x21, 0x92, 0x4b, 0x68, 0x93,
 	0x5f, 0x52, 0xf6, 0x3b, 0xb0, 0xae, 0x4a, 0xf4, 0x49, 0xba, 0x1f, 0xfb, 0x27, 0x8a, 0x94, 0x3c,
-	0x5a, 0x36, 0xb4, 0xa3, 0xe5, 0xf2, 0x28, 0xda, 0xd4, 0x8e, 0xa2, 0x2f, 0x41, 0xdb, 0x4f, 0xa4,
+	0x7e, 0x36, 0xb4, 0xe3, 0xe7, 0xf2, 0xb8, 0xda, 0xd4, 0x8e, 0xab, 0x2f, 0x41, 0xdb, 0x4f, 0xa4,
-	0x02, 0x11, 0x54, 0x0b, 0x4e, 0xc9, 0xb0, 0xfb, 0xb0, 0x2a, 0x6f, 0xc0, 0xf7, 0xdd, 0xa1, 0x4f,
+	0x02, 0x11, 0x54, 0x0b, 0x4e, 0xc9, 0xb0, 0xfb, 0xb0, 0x2a, 0x6f, 0xc9, 0xf7, 0xdd, 0xa1, 0x4f,
-	0x71, 0x05, 0xbc, 0x0c, 0x10, 0xb9, 0xc3, 0xfc, 0x05, 0x0c, 0xde, 0x42, 0x28, 0x1c, 0xfe, 0x3d,
+	0x71, 0x05, 0xbc, 0x0c, 0x10, 0xb9, 0xc3, 0xfc, 0x95, 0x0c, 0xde, 0x54, 0x28, 0x1c, 0xfe, 0x3d,
-	0x39, 0x62, 0x0f, 0xe4, 0x77, 0x13, 0xbf, 0x97, 0x1c, 0xfb, 0x1b, 0x60, 0x39, 0x24, 0x89, 0x18,
+	0x39, 0x62, 0x0f, 0xe4, 0x77, 0x13, 0xbf, 0x97, 0x1c, 0xfb, 0x6b, 0x60, 0x39, 0x24, 0x89, 0x18,
-	0x4d, 0x88, 0xa2, 0x75, 0x03, 0x3a, 0xdb, 0x59, 0x1c, 0x13, 0xca, 0xbb, 0xca, 0x9f, 0x83, 0xa8,
+	0x4d, 0x88, 0xa2, 0x75, 0x03, 0x3a, 0xdb, 0x59, 0x1c, 0x13, 0xca, 0xbb, 0xca, 0x9f, 0x8c, 0xa8,
-	0x2c, 0xae, 0xb7, 0x5f, 0xea, 0xc5, 0x93, 0x6b, 0x85, 0x63, 0xff, 0xa2, 0x01, 0xed, 0xbe, 0x3f,
+	0x2c, 0xae, 0xb7, 0x5f, 0xea, 0xc5, 0xd3, 0x6d, 0x85, 0x63, 0xff, 0xac, 0x01, 0xed, 0xbe, 0x3f,
-	0xa4, 0x6e, 0xe0, 0x90, 0x91, 0xf5, 0x15, 0x68, 0xe1, 0x7e, 0x42, 0xba, 0x71, 0xdc, 0x49, 0x2a,
+	0xa4, 0x6e, 0xe0, 0x90, 0x91, 0xf5, 0x25, 0x68, 0xe1, 0x7e, 0x42, 0xba, 0x71, 0xdc, 0x69, 0x2b,
 	0xb6, 0xc6, 0x8d, 0x93, 0x43, 0x46, 0xb7, 0xfe, 0xcf, 0x91, 0x32, 0xd6, 0x9b, 0xd0, 0xc5, 0x5f,
-	0xb7, 0xf1, 0x7c, 0x48, 0x26, 0x97, 0xcf, 0x9c, 0xa1, 0x44, 0xb6, 0x46, 0x5d, 0xba, 0x06, 0x6e,
+	0xb7, 0xf1, 0x7c, 0x48, 0x26, 0x97, 0x4f, 0x9d, 0xa1, 0x44, 0xb6, 0x46, 0x5d, 0xba, 0x06, 0x6e,
 	0xd0, 0x40, 0xd4, 0x1b, 0x72, 0xee, 0x4e, 0x36, 0x08, 0xcb, 0x12, 0x69, 0x10, 0xca, 0x70, 0x69,
 	0x57, 0x9c, 0xa0, 0xc8, 0x34, 0x3a, 0x59, 0x1a, 0x0f, 0x5a, 0xa4, 0x34, 0xca, 0x70, 0xe9, 0xa3,
 	0x8c, 0x0e, 0xef, 0x47, 0xf2, 0x60, 0x6f, 0xb2, 0xf4, 0x2d, 0xd1, 0x4c, 0x4a, 0xa3, 0x0c, 0x97,
 	0x8e, 0xc5, 0xca, 0x2a, 0x40, 0x3f, 0x4d, 0x1a, 0x17, 0x60, 0x29, 0x8d, 0x32, 0x5b, 0x6d, 0x98,
 	0x8f, 0xdc, 0x47, 0x01, 0x73, 0x3d, 0xfb, 0xdd, 0x06, 0x40, 0xde, 0x30, 0x11, 0x55, 0x88, 0xe6,
-	0xa2, 0xcd, 0x33, 0x5d, 0x14, 0x05, 0x8f, 0x14, 0x27, 0xf5, 0xc7, 0x3b, 0xe9, 0xb3, 0xd3, 0x3a,
+	0xa2, 0xcd, 0x33, 0x5d, 0x14, 0x05, 0x8f, 0x14, 0x27, 0xf5, 0xc7, 0x3b, 0xe9, 0xd3, 0xd3, 0x3a,
 	0x09, 0xb5, 0x55, 0xdc, 0x74, 0xb5, 0xe2, 0xa6, 0xcd, 0x33, 0xdd, 0x24, 0x8d, 0x92, 0x8e, 0xba,
 	0x5a, 0x71, 0xd4, 0xe6, 0x99, 0x8e, 0x92, 0xf2, 0xd2, 0x55, 0x57, 0x2b, 0xae, 0xda, 0x3c, 0xd3,
 	0x55, 0x52, 0x5e, 0x3a, 0xeb, 0x6a, 0xc5, 0x59, 0x9b, 0x67, 0x3a, 0x4b, 0xca, 0xd7, 0xdd, 0xf5,
-	0xbe, 0x09, 0x4b, 0x02, 0x32, 0xbc, 0xc5, 0xa3, 0x87, 0x4c, 0x1c, 0xd6, 0x0b, 0xb8, 0xf4, 0x07,
+	0xbe, 0x09, 0x4b, 0x02, 0x32, 0xbc, 0xe9, 0xa3, 0x87, 0x4c, 0x1c, 0xd6, 0x0b, 0xb8, 0xf4, 0x47,
-	0x55, 0x3a, 0xd3, 0xfa, 0x1c, 0xac, 0x22, 0x43, 0x3e, 0xc0, 0x29, 0xae, 0x45, 0xdb, 0x4e, 0xfd,
+	0x57, 0x3a, 0xd3, 0xfa, 0x0c, 0xac, 0x22, 0x83, 0x28, 0x37, 0x15, 0xa6, 0xb8, 0xa9, 0xa8, 0x7f,
-	0x83, 0xb8, 0x77, 0xc9, 0x92, 0x94, 0x85, 0x3b, 0x6e, 0xea, 0xe6, 0x95, 0x51, 0xc9, 0x51, 0x6f,
+	0x10, 0x77, 0x33, 0x59, 0x92, 0xb2, 0x70, 0xc7, 0x4d, 0xdd, 0xbc, 0x32, 0x2a, 0x39, 0xea, 0xcd,
-	0xc5, 0xe6, 0x6a, 0x4f, 0x36, 0x63, 0xc6, 0xc2, 0xe2, 0xba, 0x4b, 0x52, 0x5c, 0x22, 0xf5, 0x43,
+	0xd9, 0x5c, 0xed, 0x59, 0x67, 0xcc, 0x58, 0x58, 0x5c, 0x89, 0x49, 0x8a, 0x4b, 0xa4, 0x7e, 0x48,
-	0xc2, 0xb2, 0x54, 0x2e, 0x13, 0x39, 0x89, 0x8f, 0x1e, 0x3c, 0xdf, 0x15, 0x77, 0x49, 0xf2, 0x45,
+	0x58, 0x96, 0xca, 0x65, 0x22, 0x27, 0xf1, 0x61, 0x84, 0xe7, 0xbb, 0xe2, 0xbe, 0x49, 0xbe, 0x1a,
-	0x40, 0xc1, 0x10, 0x2b, 0x5b, 0x79, 0x37, 0x26, 0x9f, 0x54, 0x96, 0x9c, 0xb3, 0xef, 0xb1, 0xec,
+	0x28, 0x18, 0x62, 0x65, 0x2b, 0xef, 0xcf, 0xe4, 0xb3, 0xcb, 0x92, 0x73, 0xf6, 0x5d, 0x97, 0xfd,
-	0xbf, 0x1b, 0x70, 0x61, 0xdf, 0x8d, 0x53, 0x7f, 0xe0, 0x47, 0x2e, 0x4d, 0x77, 0x49, 0xea, 0x8a,
+	0x77, 0x03, 0x2e, 0xec, 0xbb, 0x71, 0xea, 0x0f, 0xfc, 0xc8, 0xa5, 0xe9, 0x2e, 0x49, 0x5d, 0x31,
-	0x31, 0x68, 0xaf, 0xaa, 0x8c, 0xc7, 0x7b, 0x55, 0xb5, 0x0f, 0xcb, 0x43, 0xbd, 0xf4, 0x7f, 0xcc,
+	0x06, 0xed, 0xe5, 0x95, 0xf1, 0x78, 0x2f, 0xaf, 0xf6, 0x61, 0x79, 0xa8, 0x97, 0xfe, 0x8f, 0x59,
-	0xaa, 0xbd, 0x2a, 0xae, 0x3d, 0x11, 0x6b, 0x3c, 0xf6, 0x13, 0x31, 0xfb, 0xc7, 0x26, 0x2c, 0x57,
+	0xb5, 0x57, 0xc5, 0xb5, 0x67, 0x64, 0x8d, 0xc7, 0x7e, 0x46, 0x66, 0xff, 0xd0, 0x84, 0xe5, 0xca,
-	0x96, 0x4e, 0x5e, 0x8e, 0x62, 0xa1, 0x51, 0xc4, 0x44, 0x41, 0x5b, 0xd7, 0x00, 0xfc, 0x22, 0x8c,
+	0xd2, 0xc9, 0xcb, 0x51, 0x2c, 0x34, 0x8a, 0x98, 0x28, 0x68, 0xeb, 0x1a, 0x80, 0x5f, 0x84, 0xd1,
-	0x4e, 0x39, 0x19, 0xd7, 0x63, 0xcd, 0x51, 0x84, 0xc6, 0x5d, 0x90, 0x35, 0x66, 0xbe, 0x20, 0xe3,
+	0x29, 0x27, 0xe3, 0x7a, 0xac, 0x39, 0x8a, 0xd0, 0xb8, 0x4b, 0xb4, 0xc6, 0xec, 0x97, 0x68, 0xb7,
-	0x1b, 0x93, 0xa8, 0x74, 0xd2, 0x29, 0x1b, 0x93, 0x31, 0xae, 0x74, 0x54, 0x51, 0xfb, 0xdb, 0xb0,
+	0xa0, 0x13, 0x95, 0x4e, 0x3a, 0x65, 0x63, 0x32, 0xc6, 0x95, 0x8e, 0x2a, 0x6a, 0x7f, 0x13, 0x56,
-	0x5a, 0x5b, 0xa1, 0xc4, 0x7d, 0x19, 0x3b, 0x26, 0xb4, 0xb8, 0x2f, 0xe3, 0x84, 0x12, 0xac, 0x66,
+	0x6b, 0x2b, 0x94, 0xb8, 0x2f, 0x63, 0xc7, 0x84, 0x16, 0xf7, 0x65, 0x9c, 0x50, 0x82, 0xd5, 0xac,
-	0x35, 0x58, 0x03, 0xff, 0x44, 0x7d, 0x83, 0x2a, 0x49, 0xfb, 0x27, 0x26, 0xac, 0x8d, 0xcf, 0x2e,
+	0x06, 0x6b, 0xe0, 0x9f, 0xa8, 0xef, 0x54, 0x25, 0x69, 0xff, 0xc8, 0x84, 0xb5, 0xf1, 0xd9, 0xe5,
-	0xcf, 0x2a, 0xdc, 0x07, 0xd0, 0x9b, 0xb4, 0x92, 0x9f, 0x1b, 0xea, 0x65, 0x74, 0x17, 0x79, 0xf8,
+	0x59, 0x85, 0xfb, 0x00, 0x7a, 0x93, 0x56, 0xf2, 0x73, 0x43, 0xbd, 0x8c, 0xee, 0x22, 0x0f, 0x3f,
-	0x59, 0x85, 0xfb, 0x42, 0x1e, 0xdd, 0x4a, 0xaa, 0xb3, 0x7f, 0x57, 0xe0, 0x53, 0x54, 0x1a, 0xcf,
+	0xab, 0x70, 0x5f, 0xc8, 0xa3, 0x5b, 0x49, 0x75, 0xf6, 0x6f, 0x0a, 0x7c, 0x8a, 0x4a, 0xe3, 0x19,
-	0x28, 0x3e, 0xd6, 0x4b, 0xb0, 0x82, 0xc3, 0x54, 0x5e, 0x54, 0x60, 0xe1, 0x5a, 0xe3, 0x97, 0x2b,
+	0xc5, 0xc7, 0x7a, 0x09, 0x56, 0x70, 0x98, 0xca, 0xab, 0x0b, 0x2c, 0x5c, 0x6b, 0xfc, 0x72, 0xa5,
-	0x85, 0x92, 0xf6, 0xcf, 0x2d, 0x66, 0xff, 0x68, 0xe4, 0x3e, 0x29, 0xea, 0xb7, 0x8f, 0x94, 0x4f,
+	0x50, 0xd2, 0xfe, 0xb9, 0xc5, 0xec, 0x1f, 0x8c, 0xdc, 0x27, 0x45, 0xfd, 0xf6, 0xa1, 0xf2, 0x49,
-	0xca, 0x48, 0x53, 0x8a, 0x1a, 0x25, 0xd2, 0x8a, 0xba, 0xf2, 0x7f, 0x91, 0x76, 0x76, 0xa4, 0x15,
+	0x19, 0x69, 0x4a, 0x51, 0xa3, 0x44, 0x5a, 0x51, 0x57, 0xfe, 0x2f, 0xd2, 0xce, 0x8e, 0xb4, 0x02,
-	0x58, 0x2a, 0x05, 0x9e, 0xfd, 0x7d, 0xe8, 0xee, 0x90, 0x60, 0x37, 0x19, 0xe6, 0x6f, 0xb9, 0x4e,
+	0x4b, 0xa5, 0xc0, 0xb3, 0xbf, 0x0b, 0xdd, 0x1d, 0x12, 0xec, 0x26, 0xc3, 0xfc, 0xbd, 0xd7, 0x69,
-	0x03, 0x72, 0xd2, 0x5f, 0x61, 0x26, 0xbe, 0xe2, 0xaa, 0xbe, 0x00, 0x9b, 0xab, 0xbd, 0x00, 0xb3,
+	0x40, 0x4e, 0xfa, 0xbb, 0xcc, 0xc4, 0x97, 0x5e, 0xd5, 0x57, 0x62, 0x73, 0xb5, 0x57, 0x62, 0xf6,
-	0xb7, 0x60, 0x49, 0x35, 0x60, 0x96, 0xa7, 0x6c, 0x5b, 0x97, 0xbe, 0xb5, 0x7e, 0xe5, 0x65, 0xfc,
+	0x16, 0x2c, 0xa9, 0x06, 0xcc, 0xf2, 0xdc, 0x6d, 0xeb, 0xd2, 0x37, 0xd6, 0xaf, 0xbc, 0x8c, 0x7f,
-	0xd3, 0xd5, 0xeb, 0x35, 0x10, 0x0f, 0x5a, 0xe2, 0x4f, 0x58, 0xaf, 0xfe, 0x37, 0x00, 0x00, 0xff,
+	0xcc, 0x7a, 0xbd, 0x06, 0xe2, 0x41, 0x4b, 0xfc, 0x51, 0xeb, 0xd5, 0xff, 0x06, 0x00, 0x00, 0xff,
-	0xff, 0xda, 0x69, 0x8c, 0xa6, 0x97, 0x35, 0x00, 0x00,
+	0xff, 0xf8, 0x91, 0x1b, 0x32, 0xbb, 0x35, 0x00, 0x00,
 }

pkg/proto/sdk_ws/ws.proto

@@ -213,8 +213,9 @@ message MsgData {
   int32 status = 17;
   map<string, bool> options = 18;
   OfflinePushInfo offlinePushInfo = 19;
+  repeated string atUserIDList = 20;
+
 }
-//    repeated string atUserIDList = 20;
 message OfflinePushInfo{
   string title = 1;
   string desc = 2;

pkg/proto/user/user.proto

@@ -315,4 +315,8 @@ service user {
   rpc GetBlockUsers(GetBlockUsersReq) returns (GetBlockUsersResp);
   rpc GetBlockUserById(GetBlockUserByIdReq) returns (GetBlockUserByIdResp);
   rpc DeleteUser(DeleteUserReq) returns (DeleteUserResp);
+
+
+  rpc GetUserInfoFromCache(GetUserInfoReq) returns(GetUserInfoResp);
+
 }

script/check_all.sh

@@ -4,23 +4,25 @@ source ./style_info.cfg
 source ./path_info.cfg
 source ./function.sh
 service_port_name=(
-  openImCmsApiPort
+  openImWsPort
   openImApiPort
+  openImSdkWsPort
+  openImDemoPort
+  openImCmsApiPort
   openImUserPort
   openImFriendPort
-  openImOfflineMessagePort
+  openImMessagePort
-  openImOnlineRelayPort
+  openImMessageGatewayPort
   openImGroupPort
   openImAuthPort
   openImPushPort
-  openImWsPort
-  openImSdkWsPort
-  openImDemoPort
-  openImAdminCmsPort
-  openImMessageCmsPort
   openImStatisticsPort
+  openImMessageCmsPort
+  openImAdminCmsPort
   openImOfficePort
   openImOrganizationPort
+  openImConversationPort
+  openImCachePort
 )
 switch=$(cat $config_path | grep demoswitch |awk -F '[:]' '{print $NF}')
 for i in ${service_port_name[*]}; do

script/msg_gateway_start.sh

@@ -5,7 +5,7 @@ source ./path_info.cfg
 source ./function.sh
 ulimit -n 200000
 
-list1=$(cat $config_path | grep openImOnlineRelayPort | awk -F '[:]' '{print $NF}')
+list1=$(cat $config_path | grep openImMessageGatewayPort | awk -F '[:]' '{print $NF}')
 list2=$(cat $config_path | grep openImWsPort | awk -F '[:]' '{print $NF}')
 list_to_string $list1
 rpc_ports=($ports_array)

script/path_info.cfg

@@ -50,6 +50,8 @@ service_source_root=(
   ../cmd/rpc/open_im_statistics/
   ../cmd/rpc/open_im_office/ 
   ../cmd/rpc/open_im_organization/
+  ../cmd/rpc/open_im_conversation/
+  ../cmd/rpc/open_im_cache/
   ${msg_gateway_source_root}
   ${msg_transfer_source_root}
   ${msg_source_root}
@@ -71,7 +73,9 @@ service_names=(
   open_im_message_cms
   open_im_statistics
   open_im_office
-  open_im_organization	
+  open_im_organization
+  open_im_conversation
+  open_im_cache
   ${msg_gateway_name}
   ${msg_transfer_name}
   ${msg_name}

script/start_rpc_service.sh

@@ -20,6 +20,8 @@ service_filename=(
   ${msg_name}
   open_im_office
   open_im_organization
+  open_im_conversation
+  open_im_cache
 )
 
 #service config port name
@@ -35,9 +37,11 @@ service_port_name=(
   openImAdminCmsPort
   openImMessageCmsPort
   openImStatisticsPort
-  openImOfflineMessagePort
+  openImMessagePort
   openImOfficePort
   openImOrganizationPort
+  openImConversationPort
+  openImCachePort
 )
 
 for ((i = 0; i < ${#service_filename[*]}; i++)); do