cache

This reverts commit 766b6e9f

cmd/open_im_api/main.go

@@ -8,6 +8,7 @@ import (
 	"Open_IM/internal/api/group"
 	"Open_IM/internal/api/manage"
 	"Open_IM/internal/api/office"
+	"Open_IM/internal/api/organization"
 	apiThird "Open_IM/internal/api/third"
 	"Open_IM/internal/api/user"
 	"Open_IM/pkg/common/config"
@@ -29,17 +30,21 @@ func main() {
 	gin.SetMode(gin.ReleaseMode)
 	f, _ := os.Create("../logs/api.log")
 	gin.DefaultWriter = io.MultiWriter(f)
-
+	gin.SetMode(gin.DebugMode)
 	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")
 	{
-		userRouterGroup.POST("/update_user_info", user.UpdateUserInfo)    //1
-		userRouterGroup.POST("/get_users_info", user.GetUsersInfo)        //1
-		userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo) //1
+		userRouterGroup.POST("/update_user_info", user.UpdateUserInfo)              //1
+		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)
+		userRouterGroup.POST("/get_user_friend_from_cache", user.GetFriendIDListFromCache)
+		userRouterGroup.POST("/get_black_list_from_cache", user.GetBlackIDListFromCache)
 	}
 	//friend routing group
 	friendRouterGroup := r.Group("/friend")
@@ -83,6 +88,9 @@ func main() {
 		groupRouterGroup.POST("/cancel_mute_group_member", group.CancelMuteGroupMember) //MuteGroup
 		groupRouterGroup.POST("/mute_group", group.MuteGroup)
 		groupRouterGroup.POST("/cancel_mute_group", group.CancelMuteGroup)
+
+		groupRouterGroup.POST("/set_group_member_nickname", group.SetGroupMemberNickname)
+
 	}
 	//certificate
 	authRouterGroup := r.Group("/auth")
@@ -124,6 +132,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")
@@ -135,9 +144,40 @@ func main() {
 		officeGroup.POST("/set_tag", office.SetTag)
 		officeGroup.POST("/send_msg_to_tag", office.SendMsg2Tag)
 		officeGroup.POST("/get_send_tag_log", office.GetTagSendLogs)
+
+		officeGroup.POST("/create_one_work_moment", office.CreateOneWorkMoment)
+		officeGroup.POST("/delete_one_work_moment", office.DeleteOneWorkMoment)
+		officeGroup.POST("/like_one_work_moment", office.LikeOneWorkMoment)
+		officeGroup.POST("/comment_one_work_moment", office.CommentOneWorkMoment)
+		officeGroup.POST("/get_work_moment_by_id", office.GetWorkMomentByID)
+		officeGroup.POST("/get_user_work_moments", office.GetUserWorkMoments)
+		officeGroup.POST("/get_user_friend_work_moments", office.GetUserFriendWorkMoments)
+		officeGroup.POST("/set_user_work_moments_level", office.SetUserWorkMomentsLevel)
 	}
+
+	organizationGroup := r.Group("/organization")
+	{
+		organizationGroup.POST("/create_department", organization.CreateDepartment)
+		organizationGroup.POST("/update_department", organization.UpdateDepartment)
+		organizationGroup.POST("/get_sub_department", organization.GetSubDepartment)
+		organizationGroup.POST("/delete_department", organization.DeleteDepartment)
+		organizationGroup.POST("/get_all_department", organization.GetAllDepartment)
+
+		organizationGroup.POST("/create_organization_user", organization.CreateOrganizationUser)
+		organizationGroup.POST("/update_organization_user", organization.UpdateOrganizationUser)
+		organizationGroup.POST("/delete_organization_user", organization.DeleteOrganizationUser)
+
+		organizationGroup.POST("/create_department_member", organization.CreateDepartmentMember)
+		organizationGroup.POST("/get_user_in_department", organization.GetUserInDepartment)
+		organizationGroup.POST("/update_user_in_department", organization.UpdateUserInDepartment)
+
+		organizationGroup.POST("/get_department_member", organization.GetDepartmentMember)
+		organizationGroup.POST("/delete_user_in_department", organization.DeleteUserInDepartment)
+
+	}
+
 	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

@@ -3,7 +3,9 @@ package main
 import (
 	"Open_IM/internal/cms_api"
 	"Open_IM/pkg/utils"
+	"flag"
 	"fmt"
+	"strconv"
 
 	"github.com/gin-gonic/gin"
 )
@@ -12,6 +14,10 @@ func main() {
 	gin.SetMode(gin.ReleaseMode)
 	router := cms_api.NewGinRouter()
 	router.Use(utils.CorsHandler())
-	fmt.Println("start cms api server, port: ", 8000)
-	router.Run(":" + "8000")
+	ginPort := flag.Int("port", 10006, "get ginServerPort from cmd,default 8000 as port")
+	flag.Parse()
+	fmt.Println("start cms api server, port: ", ginPort)
+	router.Run(":" + strconv.Itoa(*ginPort))
 }
+
+//

cmd/open_im_demo/main.go

@@ -23,7 +23,7 @@ func main() {
 	r := gin.Default()
 	r.Use(utils.CorsHandler())
 
-	authRouterGroup := r.Group("/auth")
+	authRouterGroup := r.Group("/demo")
 	{
 		authRouterGroup.POST("/code", register.SendVerificationCode)
 		authRouterGroup.POST("/verify", register.Verify)

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_organization/Makefile

@@ -0,0 +1,25 @@
+.PHONY: all build run gotool install clean help
+
+BINARY_NAME=open_im_organization
+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_organization/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"Open_IM/internal/rpc/organization"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	rpcPort := flag.Int("port", 11200, "get RpcOrganizationPort from cmd,default 11200 as port")
+	flag.Parse()
+	fmt.Println("start organization rpc server, port: ", *rpcPort)
+	rpcServer := organization.NewServer(*rpcPort)
+	rpcServer.Run()
+}

config/config.yaml

@@ -76,23 +76,25 @@ endpoints:
   rpc_office: openim_rpc_office
 
 api:
-  openImApiPort: [ 10000 ] #api服务端口，默认即可，需要开放此端口或做nginx转发
+  openImApiPort: [ 10002 ] #api服务端口，默认即可，需要开放此端口或做nginx转发
 cmsapi:
-  openImCmsApiPort: [ 8000 ] #管理后台api服务端口，默认即可，需要开放此端口或做nginx转发
+  openImCmsApiPort: [ 10006 ] #管理后台api服务端口，默认即可，需要开放此端口或做nginx转发
 sdk:
-  openImSdkWsPort: [ 30000 ] #jssdk服务端口，默认即可，项目中使用jssdk才需开放此端口或做nginx转发
+  openImSdkWsPort: [ 10003 ] #jssdk服务端口，默认即可，项目中使用jssdk才需开放此端口或做nginx转发
 #对象存储服务，以下配置二选一，目前支持两种，腾讯云和minio，二者配置好其中一种即可（如果使用minio参考https://doc.rentsoft.cn/#/qa/minio搭建minio服务器）
 credential: #腾讯cos，发送图片、视频、文件时需要，请自行申请后替换，必须修改
   tencent:
     appID: 1302656840
     region: ap-chengdu
     bucket: echat-1302656840
-    secretID: AKIDGNYVChzIQinu7QEgtNp0hnNgqcV8vZTC
-    secretKey: kz15vW83qM6dBUWIq681eBZA0c0vlIbe
+    secretID: AKIDGNYVChzIQinu7QEgtNp0hnNgqcV8vZTC1
+    secretKey: kz15vW83qM6dBUWIq681eBZA0c0vlIbe1
   minio: #MinIO 发送图片、视频、文件时需要，请自行申请后替换，必须修改。 客户端初始化InitSDK，中 object_storage参数为minio
     bucket: openim
     location: us-east-1
-    endpoint: http://121.37.25.71:9000
+    endpoint: http://127.0.0.1:10005 #minio外网ip 这个ip是给客户端访问的
+    endpointInner: http://127.0.0.1:10005 #minio内网地址 如果im server 可以通过内网访问到 minio就可以填写
+    endpointInnerEnable: true #是否启用minio内网地址 启用可以让桶初始化，IM server连接minio走内网地址访问
     accessKeyID: user12345
     secretAccessKey: key12345
   ali: # ali oss
@@ -109,17 +111,20 @@ credential: #腾讯cos，发送图片、视频、文件时需要，请自行申
 
 
 rpcport: #rpc服务端口 默认即可
-  openImUserPort: [ 10100 ]
-  openImFriendPort: [ 10200 ]
-  openImOfflineMessagePort: [ 10300 ]
-  openImOnlineRelayPort: [ 10400 ]
-  openImGroupPort: [ 10500 ]
-  openImAuthPort: [ 10600 ]
-  openImPushPort: [ 10700 ]
-  openImStatisticsPort: [ 10800 ]
-  openImMessageCmsPort: [ 10900 ]
-  openImAdminCmsPort: [ 11000 ]
-  openImOfficePort: [ 11100 ]
+  openImUserPort: [ 10110 ]
+  openImFriendPort: [ 10120 ]
+  openImMessagePort: [ 10130 ]
+  openImMessageGatewayPort: [ 10140 ]
+  openImGroupPort: [ 10150 ]
+  openImAuthPort: [ 10160 ]
+  openImPushPort: [ 10170 ]
+  openImStatisticsPort: [ 10180 ]
+  openImMessageCmsPort: [ 10190 ]
+  openImAdminCmsPort: [ 10200 ]
+  openImOfficePort: [ 10210 ]
+  openImOrganizationPort: [ 10220 ]
+  openImConversationPort: [ 10230 ]
+  openImCachePort: [10240]
   c2c:
     callbackBeforeSendMsg:
       switch: false
@@ -142,6 +147,9 @@ rpcregistername: #rpc注册服务名，默认即可
   OpenImMessageCMSName: MessageCMS
   openImAdminCMSName: AdminCMS
   openImOfficeName: Office
+  openImOrganizationName: Organization
+  openImConversationName: Conversation
+  openImCacheName: Cache
 
 log:
   storageLocation: ../logs/
@@ -160,12 +168,12 @@ modulename: #日志文件按模块命名，默认即可
   pushName: push
 
 longconnsvr:
-  openImWsPort: [ 17778 ] # ws服务端口，默认即可，要开放此端口或做nginx转发
+  openImWsPort: [ 10001 ] # ws服务端口，默认即可，要开放此端口或做nginx转发
   websocketMaxConnNum: 10000
   websocketMaxMsgLen: 4096
   websocketTimeOut: 10
 
-## 推送只能开启一个
+## 推送只能开启一个 enable代表开启
 push:
   tpns: #腾讯推送，暂未测试 暂不要使用
     ios:
@@ -200,6 +208,9 @@ secret: tuoyun
 # 1：多平台登录：Android、iOS、Windows、Mac 每种平台只能一个在线，web端可以多个同时在线
 multiloginpolicy: 1
 
+#chat log insert to db
+chatPersistenceMysql: true
+
 #token config
 tokenpolicy:
   accessSecret: "open_im_server" #token生成相关，默认即可
@@ -428,6 +439,34 @@ notification:
       ext: "groupMemberCancelMuted ext"
     defaultTips:
       tips: "group Member Cancel Muted"
+
+  groupMemberInfoSet:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: false
+      title: "groupMemberInfoSet title"
+      desc: "groupMemberInfoSet desc"
+      ext: "groupMemberInfoSet ext"
+    defaultTips:
+      tips: "group member info set"
+
+
+  organizationChanged:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: false
+      title: "organizationChanged title"
+      desc: "organizationChanged desc"
+      ext: "organizationChanged ext"
+    defaultTips:
+      tips: "organization changed"
+
+
+
   #############################friend#################################
 
   friendApplicationAdded:
@@ -565,7 +604,7 @@ notification:
 
   conversationSetPrivate:
     conversation:
-      reliabilityLevel: 2
+      reliabilityLevel: 3
       unreadCount: true
     offlinePush:
       switch: true
@@ -576,6 +615,19 @@ notification:
       openTips: "burn after reading was opened"
       closeTips: "burn after reading was closed"
 
+  ###################workMoments################
+  workMomentsNotification:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: true
+      offlinePush:
+        switch: true
+        title: "burn after reading"
+        desc: "burn after reading"
+        ext: "burn after reading"
+      defaultTips:
+        openTips: "burn after reading was opened"
+        closeTips: "burn after reading was closed"
 
 
 #---------------demo configuration---------------------#
@@ -584,7 +636,7 @@ notification:
 demoswitch: true
 demo:
   #demo对外服务端口，默认即可，需要开放此端口或做nginx转发
-  openImDemoPort: [ 42233 ]
+  openImDemoPort: [ 10004 ]
   alismsverify: #阿里云短信配置，在阿里云申请成功后修改以下四项，必须修改
     accessKeyId: LTAI5tJPkn4HuuePdiLdGqe7
     accessKeySecret: 4n9OJ7ZCVN1U6KeHDAtOyNeVZcjOuV

docker-compose.yaml

@@ -94,7 +94,7 @@ services:
     command: /usr/local/bin/etcd --name etcd0 --data-dir /etcd-data --listen-client-urls http://0.0.0.0:2379 --advertise-client-urls http://0.0.0.0:2379 --listen-peer-urls http://0.0.0.0:2380 --initial-advertise-peer-urls http://0.0.0.0:2380 --initial-cluster etcd0=http://0.0.0.0:2380 --initial-cluster-token tkn --initial-cluster-state new
 
   open_im_server:
-    image: openim/open_im_server:v2.0.7
+    image: openim/open_im_server:v2.0.8
     container_name: open_im_server
     volumes:
       - ./logs:/Open-IM-Server/logs

internal/api/auth/auth.go

@@ -17,14 +17,16 @@ import (
 func UserRegister(c *gin.Context) {
 	params := api.UserRegisterReq{}
 	if err := c.BindJSON(&params); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		errMsg := " BindJSON failed " + err.Error()
+		log.NewError("0", errMsg)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
 		return
 	}
 
 	if params.Secret != config.Config.Secret {
-		log.NewError(params.OperationID, "params.Secret != config.Config.Secret", params.Secret, config.Config.Secret)
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "not authorized"})
+		errMsg := " params.Secret != config.Config.Secret "
+		log.NewError(params.OperationID, errMsg, params.Secret, config.Config.Secret)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": errMsg})
 		return
 	}
 	req := &rpc.UserRegisterReq{UserInfo: &open_im_sdk.UserInfo{}}
@@ -36,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)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "internal service err"})
+		errMsg := req.OperationID + " " + "client.UserRegister failed " + err.Error() + req.String()
+		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)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": reply.CommonResp.ErrMsg})
+		errMsg := req.OperationID + " " + " client.UserRegister failed " + reply.CommonResp.ErrMsg + req.String()
+		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)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		errMsg := req.OperationID + " " + " client.UserToken failed " + err.Error() + pbDataToken.String()
+		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},
@@ -64,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())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		errMsg := " BindJSON failed " + 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}
@@ -80,12 +86,13 @@ 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())
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		errMsg := req.OperationID + " UserToken failed " + err.Error() + req.String()
+		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},
 		UserToken: api.UserTokenInfo{UserID: req.FromUserID, Token: reply.Token, ExpiredTime: reply.ExpiredTime}}
-	log.NewInfo(req.OperationID, "UserRegister return ", resp)
+	log.NewInfo(req.OperationID, "UserToken return ", resp)
 	c.JSON(http.StatusOK, resp)
 }

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

@@ -696,3 +696,41 @@ func CancelMuteGroup(c *gin.Context) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
 	c.JSON(http.StatusOK, resp)
 }
+
+//SetGroupMemberNickname
+
+func SetGroupMemberNickname(c *gin.Context) {
+	params := api.SetGroupMemberNicknameReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.SetGroupMemberNicknameReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.SetGroupMemberNickname(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), " failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.SetGroupMemberNicknameResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetGroupMemberIDListFromCache(c *gin.Context) {
+
+}

internal/api/manage/management_user.go

@@ -118,6 +118,7 @@ func AccountCheck(c *gin.Context) {
 	log.NewInfo(req.OperationID, "AccountCheck api return", resp)
 	c.JSON(http.StatusOK, resp)
 }
+
 func GetUsersOnlineStatus(c *gin.Context) {
 	params := api.GetUsersOnlineStatusReq{}
 	if err := c.BindJSON(&params); err != nil {
@@ -133,6 +134,7 @@ func GetUsersOnlineStatus(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
 		return
 	}
+
 	log.NewInfo(params.OperationID, "GetUsersOnlineStatus args ", req.String())
 	var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
 	var respResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
@@ -176,5 +178,4 @@ func GetUsersOnlineStatus(c *gin.Context) {
 	}
 	log.NewInfo(req.OperationID, "GetUsersOnlineStatus api return", resp)
 	c.JSON(http.StatusOK, resp)
-
 }

internal/api/office/work_moments.go

@@ -0,0 +1,415 @@
+package office
+
+import (
+	apiStruct "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbOffice "Open_IM/pkg/proto/office"
+	pbCommon "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func CreateOneWorkMoment(c *gin.Context) {
+	var (
+		req    apiStruct.CreateOneWorkMomentReq
+		resp   apiStruct.CreateOneWorkMomentResp
+		reqPb  pbOffice.CreateOneWorkMomentReq
+		respPb *pbOffice.CreateOneWorkMomentResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.WorkMoment.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.CreateOneWorkMoment(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CreateOneWorkMoment rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CreateOneWorkMoment rpc server failed" + err.Error()})
+		return
+	}
+	resp.CommResp = apiStruct.CommResp{
+		ErrCode: respPb.CommonResp.ErrCode,
+		ErrMsg:  respPb.CommonResp.ErrMsg,
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func DeleteOneWorkMoment(c *gin.Context) {
+	var (
+		req    apiStruct.DeleteOneWorkMomentReq
+		resp   apiStruct.DeleteOneWorkMomentResp
+		reqPb  pbOffice.DeleteOneWorkMomentReq
+		respPb *pbOffice.DeleteOneWorkMomentResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.DeleteOneWorkMoment(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DeleteOneWorkMoment rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "DeleteOneWorkMoment rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func LikeOneWorkMoment(c *gin.Context) {
+	var (
+		req    apiStruct.LikeOneWorkMomentReq
+		resp   apiStruct.LikeOneWorkMomentResp
+		reqPb  pbOffice.LikeOneWorkMomentReq
+		respPb *pbOffice.LikeOneWorkMomentResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.LikeOneWorkMoment(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "LikeOneWorkMoment rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "LikeOneWorkMoment rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func CommentOneWorkMoment(c *gin.Context) {
+	var (
+		req    apiStruct.CommentOneWorkMomentReq
+		resp   apiStruct.CommentOneWorkMomentResp
+		reqPb  pbOffice.CommentOneWorkMomentReq
+		respPb *pbOffice.CommentOneWorkMomentResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.CommentOneWorkMoment(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CommentOneWorkMoment rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "CommentOneWorkMoment rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetWorkMomentByID(c *gin.Context) {
+	var (
+		req    apiStruct.GetWorkMomentByIDReq
+		resp   apiStruct.GetWorkMomentByIDResp
+		reqPb  pbOffice.GetWorkMomentByIDReq
+		respPb *pbOffice.GetWorkMomentByIDResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.OperationID = req.OperationID
+	reqPb.OpUserID = userID
+	reqPb.WorkMomentID = req.WorkMomentID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.GetWorkMomentByID(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserWorkMoments rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserWorkMoments rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	resp.Data.WorkMoment = &apiStruct.WorkMoment{LikeUserList: []*apiStruct.WorkMomentUser{}, Comments: []*apiStruct.Comment{}, AtUserList: []*apiStruct.WorkMomentUser{}}
+	if err := utils.CopyStructFields(&resp.Data.WorkMoment, respPb.WorkMoment); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetUserWorkMoments(c *gin.Context) {
+	var (
+		req    apiStruct.GetUserWorkMomentsReq
+		resp   apiStruct.GetUserWorkMomentsResp
+		reqPb  pbOffice.GetUserWorkMomentsReq
+		respPb *pbOffice.GetUserWorkMomentsResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, 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
+	}
+	reqPb.OperationID = req.OperationID
+	reqPb.Pagination = &pbCommon.RequestPagination{
+		PageNumber: req.PageNumber,
+		ShowNumber: req.ShowNumber,
+	}
+	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)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserWorkMoments rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserWorkMoments rpc server failed" + err.Error()})
+		return
+	}
+	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 {
+	//	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.ReplyUserName,
+				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
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetUserFriendWorkMoments(c *gin.Context) {
+	var (
+		req    apiStruct.GetUserFriendWorkMomentsReq
+		resp   apiStruct.GetUserFriendWorkMomentsResp
+		reqPb  pbOffice.GetUserFriendWorkMomentsReq
+		respPb *pbOffice.GetUserFriendWorkMomentsResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	reqPb.OperationID = req.OperationID
+	reqPb.Pagination = &pbCommon.RequestPagination{
+		PageNumber: req.PageNumber,
+		ShowNumber: req.ShowNumber,
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.GetUserFriendWorkMoments(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserFriendWorkMoments rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserFriendWorkMoments rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	//if err := utils.CopyStructFields(&resp.Data.WorkMoments, respPb.WorkMoments); err != nil {
+	//	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.ReplyUserName,
+				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
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func SetUserWorkMomentsLevel(c *gin.Context) {
+	var (
+		req    apiStruct.SetUserWorkMomentsLevelReq
+		resp   apiStruct.SetUserWorkMomentsLevelResp
+		reqPb  pbOffice.SetUserWorkMomentsLevelReq
+		respPb *pbOffice.SetUserWorkMomentsLevelResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	reqPb.UserID = userID
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfficeName)
+	client := pbOffice.NewOfficeServiceClient(etcdConn)
+	respPb, err := client.SetUserWorkMomentsLevel(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetUserWorkMomentsLevel rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "SetUserWorkMomentsLevel rpc server failed" + err.Error()})
+		return
+	}
+	if err := utils.CopyStructFields(&resp, respPb.CommonResp); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/organization/organization.go

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

internal/api/third/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"
 )
 
@@ -17,7 +18,14 @@ var (
 func MinioInit() {
 	operationID := utils.OperationIDGenerator()
 	log.NewInfo(operationID, utils.GetSelfFuncName(), "minio config: ", config.Config.Credential.Minio)
-	minioUrl, err := url2.Parse(config.Config.Credential.Minio.Endpoint)
+	var initUrl string
+	if config.Config.Credential.Minio.EndpointInnerEnable {
+		initUrl = config.Config.Credential.Minio.EndpointInner
+	} else {
+		initUrl = config.Config.Credential.Minio.Endpoint
+	}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "use initUrl: ", initUrl)
+	minioUrl, err := url2.Parse(initUrl)
 	if err != nil {
 		log.NewError(operationID, utils.GetSelfFuncName(), "parse failed, please check config/config.yaml", err.Error())
 		return
@@ -51,10 +59,10 @@ func MinioInit() {
 		}
 	}
 	// 自动化桶public的代码
-	//err = minioClient.SetBucketPolicy(context.Background(), config.Config.Credential.Minio.Bucket, policy.BucketPolicyReadWrite)
-	//if err != nil {
-	//	log.NewError("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
-	//	return
-	//}
+	err = minioClient.SetBucketPolicy(context.Background(), config.Config.Credential.Minio.Bucket, policy.BucketPolicyReadWrite)
+	if err != nil {
+		log.NewDebug("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
+		return
+	}
 	log.NewInfo(operationID, utils.GetSelfFuncName(), "minio create and set policy success")
 }

internal/api/third/minio_storage_credential.go

@@ -111,7 +111,13 @@ func MinioStorageCredential(c *gin.Context) {
 	stsOpts.AccessKey = config.Config.Credential.Minio.AccessKeyID
 	stsOpts.SecretKey = config.Config.Credential.Minio.SecretAccessKey
 	stsOpts.DurationSeconds = constant.MinioDurationTimes
-	li, err := cr.NewSTSAssumeRole(config.Config.Credential.Minio.Endpoint, stsOpts)
+	var endpoint string
+	if config.Config.Credential.Minio.EndpointInnerEnable {
+		endpoint = config.Config.Credential.Minio.EndpointInner
+	} else {
+		endpoint = config.Config.Credential.Minio.Endpoint
+	}
+	li, err := cr.NewSTSAssumeRole(endpoint, stsOpts)
 	if err != nil {
 		log.NewError("", utils.GetSelfFuncName(), "NewSTSAssumeRole failed", err.Error(), stsOpts, config.Config.Credential.Minio.Endpoint)
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})

internal/api/user/user.go

@@ -4,9 +4,12 @@ import (
 	jsonData "Open_IM/internal/utils"
 	api "Open_IM/pkg/base_info"
 	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	cacheRpc "Open_IM/pkg/proto/cache"
+	pbRelay "Open_IM/pkg/proto/relay"
 	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
 	rpc "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
@@ -16,6 +19,214 @@ 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
+	}
+	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 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.GetUserInfoFromCacheReq{}
+//	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.GetUserInfoFromCache(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.UpdateUserInfoToCacheReq{
+//		UserInfoList: rpcResp.UserInfoList,
+//		OperationID:  getUserInfoReq.OperationID,
+//	}
+//	_, err = cacheClient.UpdateUserInfoToCache(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 GetFriendIDListFromCache(c *gin.Context) {
+	var (
+		req    api.GetFriendIDListFromCacheReq
+		resp   api.GetFriendIDListFromCacheResp
+		reqPb  cacheRpc.GetFriendIDListFromCacheReq
+		respPb *cacheRpc.GetFriendIDListFromCacheResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
+		return
+	}
+	reqPb.OperationID = req.OperationID
+	var ok bool
+	ok, reqPb.UserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	client := cacheRpc.NewCacheClient(etcdConn)
+	respPb, err := client.GetFriendIDListFromCache(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed:" + err.Error()})
+		return
+	}
+	resp.UserIDList = respPb.UserIDList
+	resp.CommResp = api.CommResp{ErrMsg: respPb.CommonResp.ErrMsg, ErrCode: respPb.CommonResp.ErrCode}
+	c.JSON(http.StatusOK, resp)
+}
+
+func GetBlackIDListFromCache(c *gin.Context) {
+	var (
+		req    api.GetBlackIDListFromCacheReq
+		resp   api.GetBlackIDListFromCacheResp
+		reqPb  cacheRpc.GetBlackIDListFromCacheReq
+		respPb *cacheRpc.GetBlackIDListFromCacheResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
+		return
+	}
+	reqPb.OperationID = req.OperationID
+	var ok bool
+	ok, reqPb.UserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	client := cacheRpc.NewCacheClient(etcdConn)
+	respPb, err := client.GetBlackIDListFromCache(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed:" + err.Error()})
+		return
+	}
+	resp.UserIDList = respPb.UserIDList
+	resp.CommResp = api.CommResp{ErrMsg: respPb.CommonResp.ErrMsg, ErrCode: respPb.CommonResp.ErrCode}
+	c.JSON(http.StatusOK, resp)
+}
+
 func GetUsersInfo(c *gin.Context) {
 	params := api.GetUsersInfoReq{}
 	if err := c.BindJSON(&params); err != nil {
@@ -127,3 +338,70 @@ func GetSelfUserInfo(c *gin.Context) {
 	}
 
 }
+
+func GetUsersOnlineStatus(c *gin.Context) {
+	params := api.GetUsersOnlineStatusReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbRelay.GetUsersOnlineStatusReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	if len(config.Config.Manager.AppManagerUid) == 0 {
+		log.NewError(req.OperationID, "Manager == 0")
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "Manager == 0"})
+		return
+	}
+	req.OpUserID = config.Config.Manager.AppManagerUid[0]
+
+	log.NewInfo(params.OperationID, "GetUsersOnlineStatus args ", req.String())
+	var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
+	var respResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
+	flag := false
+	grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
+	for _, v := range grpcCons {
+		client := pbRelay.NewOnlineMessageRelayServiceClient(v)
+		reply, err := client.GetUsersOnlineStatus(context.Background(), req)
+		if err != nil {
+			log.NewError(params.OperationID, "GetUsersOnlineStatus rpc  err", req.String(), err.Error())
+			continue
+		} else {
+			if reply.ErrCode == 0 {
+				wsResult = append(wsResult, reply.SuccessResult...)
+			}
+		}
+	}
+	log.NewInfo(params.OperationID, "call GetUsersOnlineStatus rpc server is success", wsResult)
+	//Online data merge of each node
+	for _, v1 := range params.UserIDList {
+		flag = false
+		temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult)
+		for _, v2 := range wsResult {
+			if v2.UserID == v1 {
+				flag = true
+				temp.UserID = v1
+				temp.Status = constant.OnlineStatus
+				temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, v2.DetailPlatformStatus...)
+			}
+
+		}
+		if !flag {
+			temp.UserID = v1
+			temp.Status = constant.OfflineStatus
+		}
+		respResult = append(respResult, temp)
+	}
+	resp := api.GetUsersOnlineStatusResp{CommResp: api.CommResp{ErrCode: 0, ErrMsg: ""}, SuccessResult: respResult}
+	if len(respResult) == 0 {
+		resp.SuccessResult = []*pbRelay.GetUsersOnlineStatusResp_SuccessResult{}
+	}
+	log.NewInfo(req.OperationID, "GetUsersOnlineStatus api return", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/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/demo/register/set_password.go

@@ -53,7 +53,7 @@ func SetPassword(c *gin.Context) {
 			return
 		}
 	}
-	url := fmt.Sprintf("http://%s:10000/auth/user_register", utils.ServerIP)
+	url := fmt.Sprintf("http://%s:%d/auth/user_register", utils.ServerIP, config.Config.Api.GinPort[0])
 	openIMRegisterReq := api.UserRegisterReq{}
 	openIMRegisterReq.OperationID = params.OperationID
 	openIMRegisterReq.Platform = params.Platform

internal/msg_gateway/gate/rpc_server.go

@@ -101,7 +101,7 @@ func (r *RPCServer) OnlinePushMsg(_ context.Context, in *pbRelay.OnlinePushMsgRe
 }
 func (r *RPCServer) GetUsersOnlineStatus(_ context.Context, req *pbRelay.GetUsersOnlineStatusReq) (*pbRelay.GetUsersOnlineStatusResp, error) {
 	log.NewInfo(req.OperationID, "rpc GetUsersOnlineStatus arrived server", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) {
+	if !token_verify.IsManagerUserID(req.OpUserID) {
 		log.NewError(req.OperationID, "no permission GetUsersOnlineStatus ", req.OpUserID)
 		return &pbRelay.GetUsersOnlineStatusResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}

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)
 	}
 
 }
@@ -262,20 +262,26 @@ func (ws *WServer) getUserUid(conn *UserConn) (uid, platform string) {
 func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request) bool {
 	status := http.StatusUnauthorized
 	query := r.URL.Query()
+	operationID := ""
+	if len(query["operationID"]) != 0 {
+		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 {
-			e := err.(*constant.ErrInfo)
-			log.ErrorByKv("Token verify failed", "", "query", query, msg)
+		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")
-			http.Error(w, e.ErrMsg, int(e.ErrCode))
+			w.Header().Set("ws_err_msg", err.Error())
+			http.Error(w, err.Error(), status)
 			return false
 		} else {
-			log.InfoByKv("Connection Authentication Success", "", "token", query["token"][0], "userID", query["sendID"][0])
+			log.Info(operationID, "Connection Authentication Success", "", "token", query["token"][0], "userID", query["sendID"][0])
 			return true
 		}
 	} else {
-		log.ErrorByKv("Args err", "", "query", query)
+		log.Error(operationID, "Args err", "query", query)
 		w.Header().Set("Sec-Websocket-Version", "13")
+		w.Header().Set("ws_err_msg", "args err, need token, sendID, platformID")
 		http.Error(w, http.StatusText(status), status)
 		return false
 	}

internal/msg_transfer/logic/history_msg_handler.go

@@ -14,6 +14,7 @@ import (
 	"github.com/Shopify/sarama"
 	"github.com/golang/protobuf/proto"
 	"strings"
+	"time"
 )
 
 type fcb func(msg []byte, msgKey string)
@@ -38,7 +39,7 @@ func (mc *HistoryConsumerHandler) Init() {
 }
 
 func (mc *HistoryConsumerHandler) handleChatWs2Mongo(msg []byte, msgKey string) {
-	time := utils.GetCurrentTimestampByNano()
+	now := time.Now()
 	msgFromMQ := pbMsg.MsgDataToMQ{}
 	err := proto.Unmarshal(msg, &msgFromMQ)
 	if err != nil {
@@ -62,13 +63,13 @@ func (mc *HistoryConsumerHandler) handleChatWs2Mongo(msg []byte, msgKey string)
 				return
 			}
 			mc.singleMsgCount++
-			log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", utils.GetCurrentTimestampByNano()-time)
+			log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", time.Since(now))
 		}
 		if !isSenderSync && msgKey == msgFromMQ.MsgData.SendID {
 		} else {
 			go sendMessageToPush(&msgFromMQ, msgKey)
 		}
-		log.NewDebug(operationID, "saveUserChat cost time ", utils.GetCurrentTimestampByNano()-time)
+		log.NewDebug(operationID, "saveUserChat cost time ", time.Since(now))
 	case constant.GroupChatType:
 		log.NewDebug(msgFromMQ.OperationID, "msg_transfer msg type = GroupChatType", isHistory, isPersist)
 		if isHistory {
@@ -89,13 +90,13 @@ func (mc *HistoryConsumerHandler) handleChatWs2Mongo(msg []byte, msgKey string)
 				return
 			}
 			mc.singleMsgCount++
-			log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", utils.GetCurrentTimestampByNano()-time)
+			log.NewDebug(msgFromMQ.OperationID, "sendMessageToPush cost time ", time.Since(now))
 		}
 		if !isSenderSync && msgKey == msgFromMQ.MsgData.SendID {
 		} else {
 			go sendMessageToPush(&msgFromMQ, msgKey)
 		}
-		log.NewDebug(operationID, "saveUserChat cost time ", utils.GetCurrentTimestampByNano()-time)
+		log.NewDebug(operationID, "saveUserChat cost time ", time.Since(now))
 	default:
 		log.NewError(msgFromMQ.OperationID, "SessionType error", msgFromMQ.String())
 		return

internal/msg_transfer/logic/init.go

@@ -2,8 +2,8 @@ package logic
 
 import (
 	"Open_IM/pkg/common/config"
-
 	"Open_IM/pkg/common/kafka"
+	"fmt"
 )
 
 var (
@@ -20,6 +20,10 @@ func Init() {
 }
 func Run() {
 	//register mysqlConsumerHandler to
-	go persistentCH.persistentConsumerGroup.RegisterHandleAndConsumer(&persistentCH)
+	if config.Config.ChatPersistenceMysql {
+		go persistentCH.persistentConsumerGroup.RegisterHandleAndConsumer(&persistentCH)
+	} else {
+		fmt.Println("not start mysql consumer")
+	}
 	go historyCH.historyConsumerGroup.RegisterHandleAndConsumer(&historyCH)
 }

internal/push/getui/push.go

@@ -7,6 +7,8 @@ import (
 	"Open_IM/pkg/utils"
 	"bytes"
 	"crypto/sha256"
+	"errors"
+
 	//"crypto/sha512"
 	"encoding/hex"
 	"encoding/json"
@@ -18,10 +20,12 @@ import (
 
 var (
 	GetuiClient *Getui
+
+	TokenExpireError = errors.New("token expire")
 )
 
 const (
-	PushURL = "/push/single/cid"
+	PushURL = "/push/single/alias"
 	AuthURL = "/auth"
 )
 
@@ -51,19 +55,40 @@ type AuthResp struct {
 type PushReq struct {
 	RequestID string `json:"request_id"`
 	Audience  struct {
-		Cid []string `json:"cid"`
+		Alias []string `json:"alias"`
 	} `json:"audience"`
-	PushMssage struct {
-		Notification Notification `json:"notification"`
+	PushMessage struct {
+		Notification Notification `json:"notification,omitempty"`
+		Transmission string       `json:"transmission,omitempty"`
 	} `json:"push_message"`
+	PushChannel struct {
+		Ios     Ios     `json:"ios"`
+		Android Android `json:"android"`
+	} `json:"push_channel"`
+}
+
+type Ios struct {
+	Aps struct {
+		Sound string `json:"sound"`
+		Alert Alert  `json:"alert"`
+	} `json:"aps"`
+}
+
+type Alert struct {
+	Title string `json:"title"`
+	Body  string `json:"body"`
+}
+
+type Android struct {
+	Ups struct {
+		Notification Notification `json:"notification"`
+	} `json:"ups"`
 }
 
 type Notification struct {
 	Title     string `json:"title"`
 	Body      string `json:"body"`
 	ClickType string `json:"click_type"`
-	Intent    string `json:"intent"`
-	Url       string `json:"url"`
 }
 
 type PushResp struct {
@@ -73,44 +98,56 @@ func newGetuiClient() *Getui {
 	return &Getui{}
 }
 
-func (g *Getui) Push(userIDList []string, alert, detailContent, platform, operationID string) (resp string, err error) {
+func (g *Getui) Push(userIDList []string, alert, detailContent, operationID string) (resp string, err error) {
 	token, err := db.DB.GetGetuiToken()
+	log.NewDebug(operationID, utils.GetSelfFuncName(), "token：", token)
 	if err != nil {
 		log.NewError(operationID, utils.OperationIDGenerator(), "GetGetuiToken failed", err.Error())
 	}
 	if token == "" || err != nil {
-		token, expireTime, err := g.Auth(operationID, time.Now().UnixNano()/1e6)
+		token, err = g.getTokenAndSave2Redis(operationID)
 		if err != nil {
-			return "", utils.Wrap(err, "Auth failed")
-		}
-		log.NewInfo(operationID, "getui", utils.GetSelfFuncName(), token, expireTime, err)
-		err = db.DB.SetGetuiToken(token, 60*60*23)
-		if err != nil {
-			return "", utils.Wrap(err, "Auth failed")
+			log.NewError(operationID, utils.GetSelfFuncName(), "getTokenAndSave2Redis failed", err.Error())
+			return "", utils.Wrap(err, "")
 		}
 	}
 	pushReq := PushReq{
 		RequestID: utils.OperationIDGenerator(),
 		Audience: struct {
-			Cid []string `json:"cid"`
-		}{Cid: []string{userIDList[0]}},
+			Alias []string `json:"alias"`
+		}{Alias: []string{userIDList[0]}},
 	}
-	pushReq.PushMssage.Notification = Notification{
+	pushReq.PushMessage.Notification = Notification{
 		Title:     alert,
 		Body:      alert,
-		ClickType: "none",
+		ClickType: "startapp",
 	}
-	if config.Config.Push.Getui.Intent != "" {
-		pushReq.PushMssage.Notification.Intent = config.Config.Push.Getui.Intent
-		pushReq.PushMssage.Notification.ClickType = "intent"
+	pushReq.PushChannel.Ios.Aps.Sound = "default"
+	pushReq.PushChannel.Ios.Aps.Alert = Alert{
+		Title: alert,
+		Body:  alert,
+	}
+	pushReq.PushChannel.Android.Ups.Notification = Notification{
+		Title:     alert,
+		Body:      alert,
+		ClickType: "startapp",
 	}
 	pushResp := PushResp{}
 	err = g.request(PushURL, pushReq, token, &pushResp, operationID)
+	switch err {
+	case TokenExpireError:
+		token, err = g.getTokenAndSave2Redis(operationID)
+		if err != nil {
+			log.NewError(operationID, utils.GetSelfFuncName(), "getTokenAndSave2Redis failed, ", err.Error())
+		} else {
+			log.NewInfo(operationID, utils.GetSelfFuncName(), "getTokenAndSave2Redis: ", token)
+		}
+	}
 	if err != nil {
 		return "", utils.Wrap(err, "push failed")
 	}
 	respBytes, err := json.Marshal(pushResp)
-	return string(respBytes), err
+	return string(respBytes), utils.Wrap(err, "")
 }
 
 func (g *Getui) Auth(operationID string, timeStamp int64) (token string, expireTime int64, err error) {
@@ -147,7 +184,7 @@ func (g *Getui) request(url string, content interface{}, token string, returnStr
 		return err
 	}
 	if token != "" {
-		req.Header.Set(token, token)
+		req.Header.Set("token", token)
 	}
 	req.Header.Set("content-type", "application/json")
 	resp, err := client.Do(req)
@@ -160,8 +197,26 @@ func (g *Getui) request(url string, content interface{}, token string, returnStr
 		return err
 	}
 	log.NewInfo(operationID, "getui", utils.GetSelfFuncName(), "resp, ", string(result))
-	if err := json.Unmarshal(result, returnStruct); err != nil {
+	commonResp := GetuiCommonResp{}
+	commonResp.Data = returnStruct
+	if err := json.Unmarshal(result, &commonResp); err != nil {
 		return err
 	}
+	if commonResp.Code == 10001 {
+		return TokenExpireError
+	}
 	return nil
 }
+
+func (g *Getui) getTokenAndSave2Redis(operationID string) (token string, err error) {
+	token, expireTime, err := g.Auth(operationID, time.Now().UnixNano()/1e6)
+	if err != nil {
+		return "", utils.Wrap(err, "Auth failed")
+	}
+	log.NewDebug(operationID, "getui", utils.GetSelfFuncName(), token, expireTime, err)
+	err = db.DB.SetGetuiToken(token, 60*60*23)
+	if err != nil {
+		return "", utils.Wrap(err, "Auth failed")
+	}
+	return token, nil
+}

internal/push/jpush/push.go

@@ -32,13 +32,13 @@ func (j *JPush) SetAlias(cid, alias string) (resp string, err error) {
 	return resp, nil
 }
 
-func (j *JPush) Push(accounts []string, alert, detailContent, platform, operationID string) (string, error) {
+func (j *JPush) Push(accounts []string, alert, detailContent, operationID string) (string, error) {
 	var pf requestBody.Platform
-	_ = pf.SetPlatform(platform)
+	pf.SetAll()
 	var au requestBody.Audience
 	au.SetAlias(accounts)
 	var no requestBody.Notification
-	no.SetAlert(alert, platform)
+	no.SetAlert(alert)
 	var me requestBody.Message
 	me.SetMsgContent(detailContent)
 	var o requestBody.Options

internal/push/jpush/requestBody/notification.go

@@ -2,7 +2,6 @@ package requestBody
 
 import (
 	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
 )
 
 type Notification struct {
@@ -23,18 +22,14 @@ type Ios struct {
 	Badge string `json:"badge,omitempty"`
 }
 
-func (n *Notification) SetAlert(alert, platform string) {
+func (n *Notification) SetAlert(alert string) {
 	n.Alert = alert
-	switch platform {
-	case constant.AndroidPlatformStr:
-		n.Android.Alert = alert
-		n.SetAndroidIntent()
-	case constant.IOSPlatformStr:
-		n.IOS.Alert = alert
-		n.IOS.Sound = "default"
-		n.IOS.Badge = "+1"
-	default:
-	}
+	n.Android.Alert = alert
+	n.SetAndroidIntent()
+	n.IOS.Alert = alert
+	n.IOS.Sound = "default"
+	n.IOS.Badge = "+1"
+
 }
 func (n *Notification) SetAndroidIntent() {
 	n.Android.Intent.URL = config.Config.Push.Jpns.PushIntent

internal/push/logic/push_to_client.go

@@ -37,7 +37,7 @@ type AtContent struct {
 func MsgToUser(pushMsg *pbPush.PushMsgReq) {
 	var wsResult []*pbRelay.SingleMsgToUser
 	isOfflinePush := utils.GetSwitchFromOptions(pushMsg.MsgData.Options, constant.IsOfflinePush)
-	log.Debug("Get msg from msg_transfer And push msg", pushMsg.OperationID, "PushData", pushMsg.String())
+	log.Debug(pushMsg.OperationID, "Get msg from msg_transfer And push msg", pushMsg.String())
 	grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
 	//Online push message
 	log.Debug("test", pushMsg.OperationID, "len  grpc", len(grpcCons), "data", pushMsg.String())
@@ -45,82 +45,80 @@ func MsgToUser(pushMsg *pbPush.PushMsgReq) {
 		msgClient := pbRelay.NewOnlineMessageRelayServiceClient(v)
 		reply, err := msgClient.OnlinePushMsg(context.Background(), &pbRelay.OnlinePushMsgReq{OperationID: pushMsg.OperationID, MsgData: pushMsg.MsgData, PushToUserID: pushMsg.PushToUserID})
 		if err != nil {
-			log.InfoByKv("push data to client rpc err", pushMsg.OperationID, "err", err)
+			log.NewError("push data to client rpc err", pushMsg.OperationID, "err", err)
 			continue
 		}
 		if reply != nil && reply.Resp != nil {
 			wsResult = append(wsResult, reply.Resp...)
 		}
 	}
-	log.InfoByKv("push_result", pushMsg.OperationID, "result", wsResult, "sendData", pushMsg.MsgData)
+	log.NewInfo(pushMsg.OperationID, "push_result", wsResult, "sendData", pushMsg.MsgData)
 	count++
 	if isOfflinePush && pushMsg.PushToUserID != pushMsg.MsgData.SendID {
 		for _, v := range wsResult {
 			if v.ResultCode == 0 {
 				continue
 			}
-			//supported terminal
-			for _, t := range pushTerminal {
-				if v.RecvPlatFormID == t {
-					//Use offline push messaging
-					var UIDList []string
-					UIDList = append(UIDList, v.RecvID)
-					customContent := OpenIMContent{
-						SessionType: int(pushMsg.MsgData.SessionType),
-						From:        pushMsg.MsgData.SendID,
-						To:          pushMsg.MsgData.RecvID,
-						Seq:         pushMsg.MsgData.Seq,
-					}
-					bCustomContent, _ := json.Marshal(customContent)
-					jsonCustomContent := string(bCustomContent)
-					var content string
-					if pushMsg.MsgData.OfflinePushInfo != nil {
-						content = pushMsg.MsgData.OfflinePushInfo.Title
-
-					} else {
-						switch pushMsg.MsgData.ContentType {
-						case constant.Text:
-							content = constant.ContentType2PushContent[constant.Text]
-						case constant.Picture:
-							content = constant.ContentType2PushContent[constant.Picture]
-						case constant.Voice:
-							content = constant.ContentType2PushContent[constant.Voice]
-						case constant.Video:
-							content = constant.ContentType2PushContent[constant.Video]
-						case constant.File:
-							content = constant.ContentType2PushContent[constant.File]
-						case constant.AtText:
-							a := AtContent{}
-							_ = utils.JsonStringToStruct(string(pushMsg.MsgData.Content), &a)
-							if utils.IsContain(v.RecvID, a.AtUserList) {
-								content = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
-							} else {
-								content = constant.ContentType2PushContent[constant.GroupMsg]
-							}
-						default:
-							content = constant.ContentType2PushContent[constant.Common]
-						}
-					}
-					var offlinePusher pusher.OfflinePusher
-					if config.Config.Push.Getui.Enable {
-						log.NewInfo(pushMsg.OperationID, utils.GetSelfFuncName(), config.Config.Push.Getui)
-						offlinePusher = getui.GetuiClient
-					}
-					if config.Config.Push.Jpns.Enable {
-						offlinePusher = jpush.JPushClient
-					}
-					if offlinePusher == nil {
-						offlinePusher = jpush.JPushClient
-					}
-					pushResult, err := offlinePusher.Push(UIDList, content, jsonCustomContent, constant.PlatformIDToName(t), pushMsg.OperationID)
-					if err != nil {
-						log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error(), constant.PlatformIDToName(t))
-					} else {
-						log.NewDebug(pushMsg.OperationID, "offline push return result is ", pushResult, pushMsg.MsgData, constant.PlatformIDToName(t))
-					}
-
+			if utils.IsContainInt32(v.RecvPlatFormID, pushTerminal) {
+				//Use offline push messaging
+				var UIDList []string
+				UIDList = append(UIDList, v.RecvID)
+				customContent := OpenIMContent{
+					SessionType: int(pushMsg.MsgData.SessionType),
+					From:        pushMsg.MsgData.SendID,
+					To:          pushMsg.MsgData.RecvID,
+					Seq:         pushMsg.MsgData.Seq,
 				}
+				bCustomContent, _ := json.Marshal(customContent)
+				jsonCustomContent := string(bCustomContent)
+				var content string
+				if pushMsg.MsgData.OfflinePushInfo != nil {
+					content = pushMsg.MsgData.OfflinePushInfo.Title
+
+				} else {
+					switch pushMsg.MsgData.ContentType {
+					case constant.Text:
+						content = constant.ContentType2PushContent[constant.Text]
+					case constant.Picture:
+						content = constant.ContentType2PushContent[constant.Picture]
+					case constant.Voice:
+						content = constant.ContentType2PushContent[constant.Voice]
+					case constant.Video:
+						content = constant.ContentType2PushContent[constant.Video]
+					case constant.File:
+						content = constant.ContentType2PushContent[constant.File]
+					case constant.AtText:
+						a := AtContent{}
+						_ = utils.JsonStringToStruct(string(pushMsg.MsgData.Content), &a)
+						if utils.IsContain(v.RecvID, a.AtUserList) {
+							content = constant.ContentType2PushContent[constant.AtText] + constant.ContentType2PushContent[constant.Common]
+						} else {
+							content = constant.ContentType2PushContent[constant.GroupMsg]
+						}
+					default:
+						content = constant.ContentType2PushContent[constant.Common]
+					}
+				}
+				var offlinePusher pusher.OfflinePusher
+				if config.Config.Push.Getui.Enable {
+					log.NewInfo(pushMsg.OperationID, utils.GetSelfFuncName(), config.Config.Push.Getui)
+					offlinePusher = getui.GetuiClient
+				}
+				if config.Config.Push.Jpns.Enable {
+					offlinePusher = jpush.JPushClient
+				}
+				if offlinePusher == nil {
+					offlinePusher = jpush.JPushClient
+				}
+				pushResult, err := offlinePusher.Push(UIDList, content, jsonCustomContent, pushMsg.OperationID)
+				if err != nil {
+					log.NewError(pushMsg.OperationID, "offline push error", pushMsg.String(), err.Error())
+				} else {
+					log.NewDebug(pushMsg.OperationID, "offline push return result is ", pushResult, pushMsg.MsgData)
+				}
+				break
 			}
+
 		}
 
 	}

internal/push/push_interface.go

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

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)
-		return &pbAuth.UserRegisterResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		errMsg := req.OperationID + " imdb.UserRegister failed " + err.Error() + user.UserID
+		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)
-		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		errMsg := req.OperationID + " imdb.GetUserByUserID failed " + err.Error() + req.FromUserID
+		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)
-		return &pbAuth.UserTokenResp{CommonResp: &pbAuth.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		errMsg := req.OperationID + " token_verify.CreateToken failed " + err.Error() + req.FromUserID + utils.Int32ToString(req.Platform)
+		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,330 @@
+package cache
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/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
+
+	//to cache
+	err = SyncDB2Cache()
+	if err != nil {
+		log.NewError("", err.Error(), "db to cache failed")
+		panic(err.Error())
+	}
+
+	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 SyncDB2Cache() error {
+	var err error
+	log.NewInfo("0", utils.GetSelfFuncName())
+	userList, err := imdb.GetAllUser()
+	if err != nil {
+		return utils.Wrap(err, "")
+	}
+	//err = updateAllUserToCache(userList)
+	err = updateAllFriendToCache(userList)
+	err = updateAllBlackListToCache(userList)
+	err = updateAllGroupMemberListToCache()
+	return err
+}
+
+func DelRelationCache() {}
+
+func updateAllUserToCache(userList []db.User) error {
+	for _, userInfo := range userList {
+		userInfoPb := &commonPb.UserInfo{
+			UserID:         userInfo.UserID,
+			Nickname:       userInfo.Nickname,
+			FaceURL:        userInfo.FaceURL,
+			Gender:         userInfo.Gender,
+			PhoneNumber:    userInfo.PhoneNumber,
+			Birth:          uint32(userInfo.Birth.Unix()),
+			Email:          userInfo.Email,
+			Ex:             userInfo.Ex,
+			CreateTime:     uint32(userInfo.CreateTime.Unix()),
+			AppMangerLevel: userInfo.AppMangerLevel,
+		}
+		m, err := utils.Pb2Map(userInfoPb)
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), err.Error())
+		}
+		if err := db.DB.SetUserInfoToCache(userInfo.UserID, m); err != nil {
+			log.NewError("0", utils.GetSelfFuncName(), "set userInfo to cache failed", err.Error())
+		}
+	}
+	log.NewInfo("0", utils.GetSelfFuncName(), "ok")
+	return nil
+}
+
+func updateAllGroupMemberListToCache() error {
+	log.NewInfo("0", utils.GetSelfFuncName())
+	groupIDList, err := imdb.GetAllGroupIDList()
+	if err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "getAllGroupIDList failed", err.Error())
+		panic(err.Error())
+	}
+	for _, groupID := range groupIDList {
+		groupMemberIDList, err := imdb.GetGroupMemberIDListByGroupID(groupID)
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "GetGroupMemberIDListByGroupID", err.Error())
+			continue
+		}
+		log.NewDebug("", utils.GetSelfFuncName(), "groupMemberIDList", groupMemberIDList)
+		if err := db.DB.AddGroupMemberToCache(groupID, groupMemberIDList...); err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "AddGroupMemberToCache", err.Error())
+		}
+	}
+	log.NewInfo("0", utils.GetSelfFuncName(), "ok")
+	return nil
+}
+
+func updateAllFriendToCache(userList []db.User) error {
+	log.NewInfo("0", utils.GetSelfFuncName())
+	for _, user := range userList {
+		friendIDList, err := imdb.GetFriendIDListByUserID(user.UserID)
+		if err != nil {
+			log.NewError("0", utils.GetSelfFuncName(), err.Error())
+			continue
+		}
+		if err := db.DB.AddFriendToCache(user.UserID, friendIDList...); err != nil {
+			log.NewError("0", utils.GetSelfFuncName(), err.Error())
+		}
+	}
+	log.NewInfo("0", utils.GetSelfFuncName(), "ok")
+	return nil
+}
+
+func updateAllBlackListToCache(userList []db.User) error {
+	log.NewInfo("0", utils.GetSelfFuncName())
+	for _, user := range userList {
+		blackIDList, err := imdb.GetBlackIDListByUserID(user.UserID)
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), err.Error())
+			continue
+		}
+		if err := db.DB.AddBlackUserToCache(user.UserID, blackIDList...); err != nil {
+			log.NewError("0", utils.GetSelfFuncName(), err.Error())
+		}
+	}
+	log.NewInfo("0", utils.GetSelfFuncName(), "ok")
+	return nil
+}
+
+func (s *cacheServer) GetUserInfoFromCache(_ context.Context, req *pbCache.GetUserInfoFromCacheReq) (resp *pbCache.GetUserInfoFromCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.GetUserInfoFromCacheResp{
+		CommonResp: &pbCache.CommonResp{},
+	}
+	for _, userID := range req.UserIDList {
+		userInfo, err := db.DB.GetUserInfoFromCache(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) UpdateUserInfoToCache(_ context.Context, req *pbCache.UpdateUserInfoToCacheReq) (resp *pbCache.UpdateUserInfoToCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.UpdateUserInfoToCacheResp{
+		CommonResp: &pbCache.CommonResp{},
+	}
+	for _, userInfo := range req.UserInfoList {
+		m, err := utils.Pb2Map(userInfo)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), *userInfo)
+		}
+		if err := db.DB.SetUserInfoToCache(userInfo.UserID, m); err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "set userInfo to cache failed", err.Error())
+		}
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) GetFriendIDListFromCache(_ context.Context, req *pbCache.GetFriendIDListFromCacheReq) (resp *pbCache.GetFriendIDListFromCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.GetFriendIDListFromCacheResp{CommonResp: &pbCache.CommonResp{}}
+	friendIDList, err := db.DB.GetFriendIDListFromCache(req.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache", err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), friendIDList)
+	resp.UserIDList = friendIDList
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) AddFriendToCache(_ context.Context, req *pbCache.AddFriendToCacheReq) (resp *pbCache.AddFriendToCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.AddFriendToCacheResp{CommonResp: &pbCache.CommonResp{}}
+	if err := db.DB.AddFriendToCache(req.UserID, req.FriendID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) ReduceFriendFromCache(_ context.Context, req *pbCache.ReduceFriendFromCacheReq) (resp *pbCache.ReduceFriendFromCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.ReduceFriendFromCacheResp{CommonResp: &pbCache.CommonResp{}}
+	if err := db.DB.ReduceFriendToCache(req.UserID, req.FriendID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) GetBlackIDListFromCache(_ context.Context, req *pbCache.GetBlackIDListFromCacheReq) (resp *pbCache.GetBlackIDListFromCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.GetBlackIDListFromCacheResp{CommonResp: &pbCache.CommonResp{}}
+	blackUserIDList, err := db.DB.GetBlackListFromCache(req.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), blackUserIDList)
+	resp.UserIDList = blackUserIDList
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) AddBlackUserToCache(_ context.Context, req *pbCache.AddBlackUserToCacheReq) (resp *pbCache.AddBlackUserToCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.AddBlackUserToCacheResp{CommonResp: &pbCache.CommonResp{}}
+	if err := db.DB.AddBlackUserToCache(req.UserID, req.BlackUserID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) ReduceBlackUserFromCache(_ context.Context, req *pbCache.ReduceBlackUserFromCacheReq) (resp *pbCache.ReduceBlackUserFromCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.ReduceBlackUserFromCacheResp{CommonResp: &pbCache.CommonResp{}}
+	if err := db.DB.ReduceBlackUserFromCache(req.UserID, req.BlackUserID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) GetGroupMemberIDListFromCache(_ context.Context, req *pbCache.GetGroupMemberIDListFromCacheReq) (resp *pbCache.GetGroupMemberIDListFromCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.GetGroupMemberIDListFromCacheResp{
+		CommonResp: &pbCache.CommonResp{},
+	}
+	userIDList, err := db.DB.GetGroupMemberIDListFromCache(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMemberIDListFromCache failed", err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	resp.UserIDList = userIDList
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) AddGroupMemberToCache(_ context.Context, req *pbCache.AddGroupMemberToCacheReq) (resp *pbCache.AddGroupMemberToCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.AddGroupMemberToCacheResp{CommonResp: &pbCache.CommonResp{}}
+	if err := db.DB.AddGroupMemberToCache(req.GroupID, req.UserIDList...); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddGroupMemberToCache failed", err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *cacheServer) ReduceGroupMemberFromCache(_ context.Context, req *pbCache.ReduceGroupMemberFromCacheReq) (resp *pbCache.ReduceGroupMemberFromCacheResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbCache.ReduceGroupMemberFromCacheResp{}
+	if err := db.DB.ReduceGroupMemberFromCache(req.GroupID, req.UserIDList...); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "ReduceGroupMemberFromCache failed", err.Error())
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}

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/friend/firend.go

@@ -10,6 +10,7 @@ import (
 	"Open_IM/pkg/common/token_verify"
 	cp "Open_IM/pkg/common/utils"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbCache "Open_IM/pkg/proto/cache"
 	pbFriend "Open_IM/pkg/proto/friend"
 	sdkws "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
@@ -83,6 +84,18 @@ func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlackl
 		return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 	log.NewInfo(req.CommID.OperationID, "AddBlacklist rpc ok ", req.CommID.FromUserID, req.CommID.ToUserID)
+	reqAddBlackUserToCache := &pbCache.AddBlackUserToCacheReq{UserID: req.CommID.FromUserID, BlackUserID: req.CommID.ToUserID, OperationID: req.CommID.OperationID}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	cacheClient := pbCache.NewCacheClient(etcdConn)
+	cacheResp, err := cacheClient.AddBlackUserToCache(context.Background(), reqAddBlackUserToCache)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "AddBlackUserToCache rpc call failed ", err.Error())
+		return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: 500, ErrMsg: "AddBlackUserToCache rpc call failed"}}, nil
+	}
+	if cacheResp.CommonResp.ErrCode != 0 {
+		log.NewError(req.CommID.OperationID, "AddBlackUserToCache rpc logic call failed ", cacheResp.String())
+		return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}}, nil
+	}
 	chat.BlackAddedNotification(req)
 	return &pbFriend.AddBlacklistResp{CommonResp: &pbFriend.CommonResp{}}, nil
 }
@@ -234,9 +247,37 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
 				log.NewError(req.CommID.OperationID, "InsertToFriend failed ", err.Error(), toInsertFollow)
 				return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 			}
+			// cache rpc
+			addFriendToCacheReq := &pbCache.AddFriendToCacheReq{OperationID: req.CommID.OperationID}
+			etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+			client := pbCache.NewCacheClient(etcdConn)
+			addFriendToCacheReq.UserID = req.CommID.ToUserID
+			addFriendToCacheReq.FriendID = req.CommID.FromUserID
+			respPb, err := client.AddFriendToCache(context.Background(), addFriendToCacheReq)
+			if err != nil {
+				log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", err.Error(), addFriendToCacheReq.String())
+				return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil
+			}
+			if respPb.CommonResp.ErrCode != 0 {
+				log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", addFriendToCacheReq.String())
+				return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil
+			}
+			addFriendToCacheReq.UserID = req.CommID.FromUserID
+			addFriendToCacheReq.FriendID = req.CommID.ToUserID
+			respPb, err = client.AddFriendToCache(context.Background(), addFriendToCacheReq)
+			if err != nil {
+				log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", err.Error(), addFriendToCacheReq.String())
+				return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil
+			}
+			if respPb.CommonResp.ErrCode != 0 {
+				log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", addFriendToCacheReq.String())
+				return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil
+			}
+
 			chat.FriendAddedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
 		}
 	}
+
 	if req.HandleResult == constant.FriendResponseAgree {
 		chat.FriendApplicationApprovedNotification(req)
 	} else if req.HandleResult == constant.FriendResponseRefuse {
@@ -244,6 +285,7 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
 	} else {
 		log.Error(req.CommID.OperationID, "HandleResult failed ", req.HandleResult)
 	}
+
 	log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok")
 	return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{}}, nil
 }
@@ -261,6 +303,18 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFri
 		return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 	log.NewInfo(req.CommID.OperationID, "DeleteFriend rpc ok")
+	reduceFriendFromCache := &pbCache.ReduceFriendFromCacheReq{OperationID: req.CommID.OperationID, UserID: req.CommID.FromUserID, FriendID: req.CommID.ToUserID}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	client := pbCache.NewCacheClient(etcdConn)
+	respPb, err := client.ReduceFriendFromCache(context.Background(), reduceFriendFromCache)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache rpc failed", err.Error())
+		return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil
+	}
+	if respPb.CommonResp.ErrCode != 0 {
+		log.NewError(req.CommID.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed")
+		return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: respPb.CommonResp.ErrCode, ErrMsg: respPb.CommonResp.ErrMsg}}, nil
+	}
 	chat.FriendDeletedNotification(req)
 	return &pbFriend.DeleteFriendResp{CommonResp: &pbFriend.CommonResp{}}, nil
 }
@@ -330,6 +384,18 @@ func (s *friendServer) RemoveBlacklist(ctx context.Context, req *pbFriend.Remove
 
 	}
 	log.NewInfo(req.CommID.OperationID, "rpc RemoveBlacklist ok ")
+	reqReduceBlackUserFromCache := &pbCache.ReduceBlackUserFromCacheReq{UserID: req.CommID.FromUserID, BlackUserID: req.CommID.ToUserID, OperationID: req.CommID.OperationID}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	cacheClient := pbCache.NewCacheClient(etcdConn)
+	cacheResp, err := cacheClient.ReduceBlackUserFromCache(context.Background(), reqReduceBlackUserFromCache)
+	if err != nil {
+		log.NewError(req.CommID.OperationID, "ReduceBlackUserFromCache rpc call failed ", err.Error())
+		return &pbFriend.RemoveBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: 500, ErrMsg: "ReduceBlackUserFromCache rpc call failed"}}, nil
+	}
+	if cacheResp.CommonResp.ErrCode != 0 {
+		log.NewError(req.CommID.OperationID, "ReduceBlackUserFromCache rpc logic call failed ", cacheResp.String())
+		return &pbFriend.RemoveBlacklistResp{CommonResp: &pbFriend.CommonResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}}, nil
+	}
 	chat.BlackDeletedNotification(req)
 	return &pbFriend.RemoveBlacklistResp{CommonResp: &pbFriend.CommonResp{}}, nil
 }

internal/rpc/group/group.go

@@ -13,6 +13,7 @@ import (
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbGroup "Open_IM/pkg/proto/group"
 	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
 	"net"
@@ -160,6 +161,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	resp.GroupInfo.OwnerUserID = req.OwnerUserID
 
 	log.NewInfo(req.OperationID, "rpc CreateGroup return ", resp.String())
+
 	chat.GroupCreatedNotification(req.OperationID, req.OpUserID, groupId, okUserIDList)
 	return resp, nil
 }
@@ -202,15 +204,19 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
 	log.NewInfo(req.OperationID, "InviteUserToGroup args ", req.String())
 
-	if !imdb.IsExistGroupMember(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsExistGroupMember(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.NewError(req.OperationID, "no permission InviteUserToGroup ", req.GroupID, req.OpUserID)
 		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}
 
-	_, err := imdb.GetGroupInfoByGroupID(req.GroupID)
+	groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID)
 	if err != nil {
 		log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.GroupID, err)
-		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
+	}
+	if groupInfo.Status == constant.GroupStatusDismissed {
+		errMsg := " group status is dismissed "
+		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}, nil
 	}
 	//
 	//from User:  invite: applicant
@@ -254,7 +260,53 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		}
 		resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 	}
-
+	var haveConUserID []string
+	conversations, err := imdb.GetConversationsByConversationIDMultipleOwner(okUserIDList, utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType))
+	for _, v := range conversations {
+		haveConUserID = append(haveConUserID, v.OwnerUserID)
+	}
+	var reqPb pbUser.SetConversationReq
+	var c pbUser.Conversation
+	for _, v := range conversations {
+		reqPb.OperationID = req.OperationID
+		c.OwnerUserID = v.OwnerUserID
+		c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
+		c.RecvMsgOpt = v.RecvMsgOpt
+		c.ConversationType = constant.GroupChatType
+		c.GroupID = req.GroupID
+		c.IsPinned = v.IsPinned
+		c.AttachedInfo = v.AttachedInfo
+		c.IsPrivateChat = v.IsPrivateChat
+		c.GroupAtType = v.GroupAtType
+		c.IsNotInGroup = false
+		c.Ex = v.Ex
+		reqPb.Conversation = &c
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+		client := pbUser.NewUserClient(etcdConn)
+		respPb, err := client.SetConversation(context.Background(), &reqPb)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error(), v.OwnerUserID)
+		} else {
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "SetConversation success", respPb.String(), v.OwnerUserID)
+		}
+	}
+	for _, v := range utils.DifferenceString(haveConUserID, okUserIDList) {
+		reqPb.OperationID = req.OperationID
+		c.OwnerUserID = v
+		c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
+		c.ConversationType = constant.GroupChatType
+		c.GroupID = req.GroupID
+		c.IsNotInGroup = false
+		reqPb.Conversation = &c
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+		client := pbUser.NewUserClient(etcdConn)
+		respPb, err := client.SetConversation(context.Background(), &reqPb)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error(), v)
+		} else {
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "SetConversation success", respPb.String(), v)
+		}
+	}
 	chat.MemberInvitedNotification(req.OperationID, req.GroupID, req.OpUserID, req.Reason, okUserIDList)
 	resp.ErrCode = 0
 	log.NewInfo(req.OperationID, "InviteUserToGroup rpc return ", resp.String())
@@ -331,7 +383,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 
 	//op is app manager
 	if flag != 1 {
-		if token_verify.IsMangerUserID(req.OpUserID) {
+		if token_verify.IsManagerUserID(req.OpUserID) {
 			flag = 1
 			log.NewDebug(req.OperationID, "is app manager ", req.OpUserID)
 		}
@@ -374,9 +426,28 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 			okUserIDList = append(okUserIDList, v)
 		}
 
-		err = db.DB.DelGroupMember(req.GroupID, v)
+		//err = db.DB.DelGroupMember(req.GroupID, v)
+		//if err != nil {
+		//	log.NewError(req.OperationID, "DelGroupMember failed ", err.Error(), req.GroupID, v)
+		//}
+	}
+	var reqPb pbUser.SetConversationReq
+	var c pbUser.Conversation
+	for _, v := range okUserIDList {
+		reqPb.OperationID = req.OperationID
+		c.OwnerUserID = v
+		c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
+		c.ConversationType = constant.GroupChatType
+		c.GroupID = req.GroupID
+		c.IsNotInGroup = true
+		reqPb.Conversation = &c
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+		client := pbUser.NewUserClient(etcdConn)
+		respPb, err := client.SetConversation(context.Background(), &reqPb)
 		if err != nil {
-			log.NewError(req.OperationID, "DelGroupMember failed ", err.Error(), req.GroupID, v)
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error(), v)
+		} else {
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "SetConversation success", respPb.String(), v)
 		}
 	}
 	chat.MemberKickedNotification(req, okUserIDList)
@@ -467,8 +538,8 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
 	groupRequest.UserID = req.FromUserID
 	groupRequest.HandleUserID = req.OpUserID
 	groupRequest.HandledTime = time.Now()
-	if !token_verify.IsMangerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
-		log.NewError(req.OperationID, "IsMangerUserID IsGroupOwnerAdmin false ", req.GroupID, req.OpUserID)
+	if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
+		log.NewError(req.OperationID, "IsManagerUserID IsGroupOwnerAdmin false ", req.GroupID, req.OpUserID)
 		return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 	err := imdb.UpdateGroupRequest(groupRequest)
@@ -497,6 +568,38 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
 			log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), member)
 			return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 		}
+		var reqPb pbUser.SetConversationReq
+		reqPb.OperationID = req.OperationID
+		var c pbUser.Conversation
+		conversation, err := imdb.GetConversation(req.FromUserID, utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType))
+		if err != nil {
+			c.OwnerUserID = req.FromUserID
+			c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
+			c.ConversationType = constant.GroupChatType
+			c.GroupID = req.GroupID
+			c.IsNotInGroup = false
+		} else {
+			c.OwnerUserID = conversation.OwnerUserID
+			c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
+			c.RecvMsgOpt = conversation.RecvMsgOpt
+			c.ConversationType = constant.GroupChatType
+			c.GroupID = req.GroupID
+			c.IsPinned = conversation.IsPinned
+			c.AttachedInfo = conversation.AttachedInfo
+			c.IsPrivateChat = conversation.IsPrivateChat
+			c.GroupAtType = conversation.GroupAtType
+			c.IsNotInGroup = false
+			c.Ex = conversation.Ex
+		}
+		reqPb.Conversation = &c
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+		client := pbUser.NewUserClient(etcdConn)
+		respPb, err := client.SetConversation(context.Background(), &reqPb)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
+		} else {
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "SetConversation success", respPb.String())
+		}
 		chat.GroupApplicationAcceptedNotification(req)
 		chat.MemberEnterNotification(req)
 	} else if req.HandleResult == constant.GroupResponseRefuse {
@@ -518,6 +621,16 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
+	groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.GroupID, err)
+		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	if groupInfo.Status == constant.GroupStatusDismissed {
+		errMsg := " group status is dismissed "
+		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}}, nil
+	}
+
 	var groupRequest db.GroupRequest
 	groupRequest.UserID = req.OpUserID
 	groupRequest.ReqMsg = req.ReqMessage
@@ -542,7 +655,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 }
 
 func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (*pbGroup.QuitGroupResp, error) {
-	log.NewError(req.OperationID, "QuitGroup args ", req.String())
+	log.NewInfo(req.OperationID, "QuitGroup args ", req.String())
 	_, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.OpUserID)
 	if err != nil {
 		log.NewError(req.OperationID, "GetGroupMemberInfoByGroupIDAndUserID failed ", err.Error(), req.GroupID, req.OpUserID)
@@ -560,7 +673,40 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
 		log.NewError(req.OperationID, "DelGroupMember failed ", req.GroupID, req.OpUserID)
 		//	return &pbGroup.CommonResp{ErrorCode: constant.ErrQuitGroup.ErrCode, ErrorMsg: constant.ErrQuitGroup.ErrMsg}, nil
 	}
-
+	//modify quitter conversation info
+	var reqPb pbUser.SetConversationReq
+	var c pbUser.Conversation
+	reqPb.OperationID = req.OperationID
+	c.OwnerUserID = req.OpUserID
+	c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
+	c.ConversationType = constant.GroupChatType
+	c.GroupID = req.GroupID
+	c.IsNotInGroup = true
+	reqPb.Conversation = &c
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.SetConversation(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
+	} else {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "SetConversation success", respPb.String())
+	}
+	//reduceGroupMemberFromCacheReq := &pbCache.ReduceGroupMemberFromCacheReq{
+	//	UserIDList:           []string{req.OpUserID},
+	//	GroupID:              req.GroupID,
+	//	OperationID:          req.OperationID,
+	//}
+	//etcdConn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	//cacheClient := pbCache.NewCacheClient(etcdConn)
+	//respCachePb, err := cacheClient.ReduceGroupMemberFromCache(context.Background(), reduceGroupMemberFromCacheReq)
+	//if err != nil {
+	//	log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", err.Error(), reduceGroupMemberFromCacheReq.String())
+	//	return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrServer.ErrCode, ErrMsg: constant.ErrServer.ErrMsg}}, nil
+	//}
+	//if respPb.CommonResp.ErrCode != 0 {
+	//	log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddFriendToCache failed", reduceGroupMemberFromCacheReq.String())
+	//	return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode:respCachePb.CommonResp.ErrCode, ErrMsg: respCachePb.CommonResp.ErrMsg}}, nil
+	//}
 	chat.MemberQuitNotification(req)
 	log.NewInfo(req.OperationID, "rpc QuitGroup return ", pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}})
 	return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@@ -595,6 +741,11 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, http.WrapError(constant.ErrDB)
 	}
 
+	if group.Status == constant.GroupStatusDismissed {
+		errMsg := " group status is dismissed "
+		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}}, nil
+	}
+
 	////bitwise operators: 0001:groupName; 0010:Notification  0100:Introduction; 1000:FaceUrl; 10000:owner
 	var changedType int32
 	if group.GroupName != req.GroupInfo.GroupName && req.GroupInfo.GroupName != "" {
@@ -627,12 +778,22 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) {
 	log.NewInfo(req.OperationID, "TransferGroupOwner ", req.String())
 
+	groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.GroupID, err)
+		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	if groupInfo.Status == constant.GroupStatusDismissed {
+		errMsg := " group status is dismissed "
+		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}}, nil
+	}
+
 	if req.OldOwnerUserID == req.NewOwnerUserID {
 		log.NewError(req.OperationID, "same owner ", req.OldOwnerUserID, req.NewOwnerUserID)
 		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
 	}
 	groupMemberInfo := db.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
-	err := imdb.UpdateGroupMemberInfo(groupMemberInfo)
+	err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
 		log.NewError(req.OperationID, "UpdateGroupMemberInfo failed ", groupMemberInfo)
 		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
@@ -656,7 +817,7 @@ func (s *groupServer) GetGroupById(_ context.Context, req *pbGroup.GetGroupByIdR
 	}}
 	group, err := imdb.GetGroupById(req.GroupId)
 	if err != nil {
-		log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroupById error", err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById error", err.Error())
 		return resp, http.WrapError(constant.ErrDB)
 	}
 	resp.CMSGroup.GroupInfo = &open_im_sdk.GroupInfo{
@@ -867,6 +1028,25 @@ func (s *groupServer) RemoveGroupMembersCMS(_ context.Context, req *pbGroup.Remo
 		OperationID:      req.OperationID,
 		OpUserID:         req.OpUserId,
 	}
+	var reqPb pbUser.SetConversationReq
+	var c pbUser.Conversation
+	for _, v := range resp.Success {
+		reqPb.OperationID = req.OperationID
+		c.OwnerUserID = v
+		c.ConversationID = utils.GetConversationIDBySessionType(req.GroupId, constant.GroupChatType)
+		c.ConversationType = constant.GroupChatType
+		c.GroupID = req.GroupId
+		c.IsNotInGroup = true
+		reqPb.Conversation = &c
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+		client := pbUser.NewUserClient(etcdConn)
+		respPb, err := client.SetConversation(context.Background(), &reqPb)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error(), v)
+		} else {
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "SetConversation success", respPb.String(), v)
+		}
+	}
 	chat.MemberKickedNotification(reqKick, resp.Success)
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "success: ", resp.Success)
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "failed: ", resp.Failed)
@@ -948,7 +1128,7 @@ func (s *groupServer) GetUserReqApplicationList(_ context.Context, req *pbGroup.
 
 func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (*pbGroup.DismissGroupResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
+	if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
 		log.NewError(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
 		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -958,14 +1138,38 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 		log.NewError(req.OperationID, "OperateGroupStatus failed ", req.GroupID, constant.GroupStatusDismissed)
 		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
+	memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupMemberListByGroupID failed,", err.Error(), req.GroupID)
+	}
+	//modify quitter conversation info
+	var reqPb pbUser.SetConversationReq
+	var c pbUser.Conversation
+	for _, v := range memberList {
+		reqPb.OperationID = req.OperationID
+		c.OwnerUserID = v.UserID
+		c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
+		c.ConversationType = constant.GroupChatType
+		c.GroupID = req.GroupID
+		c.IsNotInGroup = true
+		reqPb.Conversation = &c
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+		client := pbUser.NewUserClient(etcdConn)
+		respPb, err := client.SetConversation(context.Background(), &reqPb)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error(), v.UserID)
+		} else {
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "SetConversation success", respPb.String(), v.UserID)
+		}
+	}
 	chat.GroupDismissedNotification(req)
-
 	err = imdb.DeleteGroupMemberByGroupID(req.GroupID)
 	if err != nil {
 		log.NewError(req.OperationID, "DeleteGroupMemberByGroupID failed ", req.GroupID)
 		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 
 	}
+
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 }
@@ -977,7 +1181,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 
 func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (*pbGroup.MuteGroupMemberResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.Error(req.OperationID, "verify failed ", req.GroupID, req.UserID)
 		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -996,7 +1200,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 
 func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (*pbGroup.CancelMuteGroupMemberResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.Error(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
 		return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -1014,7 +1218,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 
 func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (*pbGroup.MuteGroupResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.Error(req.OperationID, "verify failed ", req.GroupID, req.GroupID)
 		return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -1030,7 +1234,7 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
 
 func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.Error(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
 		return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -1044,3 +1248,36 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 }
+
+func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (*pbGroup.SetGroupMemberNicknameResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
+	if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " verify failed " + req.OpUserID + req.GroupID
+		log.Error(req.OperationID, errMsg)
+		return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+
+	groupMemberInfo := db.GroupMember{}
+	groupMemberInfo.UserID = req.UserID
+	groupMemberInfo.GroupID = req.GroupID
+	if req.Nickname == "" {
+		userNickname, err := imdb.GetUserNameByUserID(groupMemberInfo.UserID)
+		if err != nil {
+			errMsg := req.OperationID + " GetUserNameByUserID failed " + err.Error()
+			log.Error(req.OperationID, errMsg)
+			return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		}
+		groupMemberInfo.Nickname = userNickname
+	} else {
+		groupMemberInfo.Nickname = req.Nickname
+	}
+	err := imdb.UpdateGroupMemberInfo(groupMemberInfo)
+	if err != nil {
+		errMsg := req.OperationID + " UpdateGroupMemberInfo failed " + err.Error()
+		log.Error(req.OperationID, errMsg)
+		return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
+	return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
+}

internal/rpc/msg/group_notification.go

@@ -22,7 +22,7 @@ import (
 //} creator->group
 
 func setOpUserInfo(opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
-	if token_verify.IsMangerUserID(opUserID) {
+	if token_verify.IsManagerUserID(opUserID) {
 		u, err := imdb.GetUserByUserID(opUserID)
 		if err != nil {
 			return utils.Wrap(err, "GetUserByUserID failed")
@@ -168,6 +168,9 @@ func groupNotification(contentType int32, m proto.Message, sendID, groupID, recv
 		tips.DefaultTips = toNickname + "" + cn.GroupMemberMuted.DefaultTips.Tips
 	case constant.GroupMemberCancelMutedNotification:
 		tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips
+	case constant.GroupMemberInfoSetNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberInfoSet.DefaultTips.Tips
+
 	default:
 		log.Error(operationID, "contentType failed ", contentType)
 		return
@@ -282,6 +285,24 @@ func GroupMemberMutedNotification(operationID, opUserID, groupID, groupMemberUse
 	groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID)
 }
 
+func GroupMemberInfoSetNotification(operationID, opUserID, groupID, groupMemberUserID string) {
+	tips := open_im_sdk.GroupMemberInfoSetTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, ChangedUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, tips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
+		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
+		return
+	}
+	groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID)
+}
+
 func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
 	tips := open_im_sdk.GroupMemberCancelMutedTips{Group: &open_im_sdk.GroupInfo{},
 		OpUser: &open_im_sdk.GroupMemberFullInfo{}, MutedUser: &open_im_sdk.GroupMemberFullInfo{}}

internal/rpc/msg/organization_notification.go

@@ -0,0 +1,76 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/constant"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	utils2 "Open_IM/pkg/common/utils"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+)
+
+func OrganizationNotificationToAll(opUserID string, operationID string) {
+	err, userIDList := imdb.GetAllOrganizationUserID()
+	if err != nil {
+		log.Error(operationID, "GetAllOrganizationUserID failed ", err.Error())
+		return
+	}
+
+	tips := open_im_sdk.OrganizationChangedTips{OpUser: &open_im_sdk.UserInfo{}}
+
+	user, err := imdb.GetUserByUserID(opUserID)
+	if err != nil {
+		log.NewError(operationID, "GetUserByUserID failed ", err.Error(), opUserID)
+		return
+	}
+	utils2.UserDBCopyOpenIM(tips.OpUser, user)
+
+	for _, v := range userIDList {
+		log.Debug(operationID, "OrganizationNotification", opUserID, v, constant.OrganizationChangedNotification, &tips, operationID)
+		OrganizationNotification(opUserID, v, constant.OrganizationChangedNotification, &tips, operationID)
+	}
+}
+
+func OrganizationNotification(opUserID string, recvUserID string, contentType int32, m proto.Message, operationID string) {
+	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType, opUserID)
+	var err error
+	var tips open_im_sdk.TipsComm
+	tips.Detail, err = proto.Marshal(m)
+	if err != nil {
+		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
+		return
+	}
+
+	marshaler := jsonpb.Marshaler{
+		OrigName:     true,
+		EnumsAsInts:  false,
+		EmitDefaults: false,
+	}
+
+	tips.JsonDetail, _ = marshaler.MarshalToString(m)
+
+	switch contentType {
+	case constant.OrganizationChangedNotification:
+		tips.DefaultTips = "OrganizationChangedNotification"
+
+	default:
+		log.Error(operationID, "contentType failed ", contentType)
+		return
+	}
+
+	var n NotificationMsg
+	n.SendID = opUserID
+	n.RecvID = recvUserID
+	n.ContentType = contentType
+	n.SessionType = constant.SingleChatType
+	n.MsgFrom = constant.SysMsgType
+	n.OperationID = operationID
+	n.Content, err = proto.Marshal(&tips)
+	if err != nil {
+		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
+		return
+	}
+	Notification(&n)
+}

internal/rpc/msg/send_msg.go

@@ -6,8 +6,9 @@ import (
 	"Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	cacheRpc "Open_IM/pkg/proto/cache"
 	pbChat "Open_IM/pkg/proto/chat"
-	rpc "Open_IM/pkg/proto/friend"
+	pbConversation "Open_IM/pkg/proto/conversation"
 	pbGroup "Open_IM/pkg/proto/group"
 	sdk_ws "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
@@ -17,6 +18,7 @@ import (
 	"math/rand"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -47,36 +49,38 @@ func userRelationshipVerification(data *pbChat.SendMsgReq) (bool, int32, string)
 		return true, 0, ""
 	}
 	log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
-	req := &rpc.IsInBlackListReq{CommID: &rpc.CommID{}}
-	req.CommID.OperationID = data.OperationID
-	req.CommID.OpUserID = data.MsgData.RecvID
-	req.CommID.FromUserID = data.MsgData.RecvID
-	req.CommID.ToUserID = data.MsgData.SendID
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := rpc.NewFriendClient(etcdConn)
-	reply, err := client.IsInBlackList(context.Background(), req)
+	reqGetBlackIDListFromCache := &cacheRpc.GetBlackIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+	cacheClient := cacheRpc.NewCacheClient(etcdConn)
+	cacheResp, err := cacheClient.GetBlackIDListFromCache(context.Background(), reqGetBlackIDListFromCache)
 	if err != nil {
-		log.NewDebug(data.OperationID, "IsInBlackListReq rpc failed, ", req.String(), err.Error())
-	} else if reply.Response == true {
-		log.NewDebug(data.OperationID, "IsInBlackListReq  ", req.String())
-		return false, 600, "in black list"
+		log.NewError(data.OperationID, "GetBlackIDListFromCache rpc call failed ", err.Error())
+	} else {
+		if cacheResp.CommonResp.ErrCode != 0 {
+			log.NewError(data.OperationID, "GetBlackIDListFromCache rpc logic call failed ", cacheResp.String())
+		} else {
+			if utils.IsContain(data.MsgData.SendID, cacheResp.UserIDList) {
+				return false, 600, "in black list"
+			}
+		}
 	}
 	log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify)
 	if config.Config.MessageVerify.FriendVerify {
-		friendReq := &rpc.IsFriendReq{CommID: &rpc.CommID{}}
-		friendReq.CommID.OperationID = data.OperationID
-		friendReq.CommID.OpUserID = data.MsgData.RecvID
-		friendReq.CommID.FromUserID = data.MsgData.RecvID
-		friendReq.CommID.ToUserID = data.MsgData.SendID
-		friendReply, err := client.IsFriend(context.Background(), friendReq)
+		reqGetFriendIDListFromCache := &cacheRpc.GetFriendIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID}
+		etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName)
+		cacheClient := cacheRpc.NewCacheClient(etcdConn)
+		cacheResp, err := cacheClient.GetFriendIDListFromCache(context.Background(), reqGetFriendIDListFromCache)
 		if err != nil {
-			log.NewDebug(data.OperationID, "IsFriendReq rpc failed, ", req.String(), err.Error())
-			return true, 0, ""
-		} else if friendReply.Response == false {
-			log.NewDebug(data.OperationID, "not friend  ", req.String())
-			return friendReply.Response, 601, "not friend"
+			log.NewError(data.OperationID, "GetFriendIDListFromCache rpc call failed ", err.Error())
+		} else {
+			if cacheResp.CommonResp.ErrCode != 0 {
+				log.NewError(data.OperationID, "GetFriendIDListFromCache rpc logic call failed ", cacheResp.String())
+			} else {
+				if !utils.IsContain(data.MsgData.SendID, cacheResp.UserIDList) {
+					return false, 601, "not friend"
+				}
+			}
 		}
-		log.NewDebug(data.OperationID, config.Config.MessageVerify.FriendVerify, friendReply.Response)
 		return true, 0, ""
 	} else {
 		return true, 0, ""
@@ -227,6 +231,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:
@@ -246,22 +256,55 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 			}
 		case constant.MemberQuitNotification:
 			addUidList = append(addUidList, pb.MsgData.SendID)
+
 		default:
 		}
 		groupID := pb.MsgData.GroupID
-		for _, v := range reply.MemberList {
-			pb.MsgData.RecvID = v.UserID
-			isSend := modifyMessageByUserMessageReceiveOpt(v.UserID, groupID, constant.GroupChatType, pb)
-			if isSend {
-				msgToMQ.MsgData = pb.MsgData
-				err := rpc.sendMsgToKafka(&msgToMQ, v.UserID)
-				if err != nil {
-					log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v.UserID, msgToMQ.String())
-					return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+		//split  parallel send
+		var wg sync.WaitGroup
+		var sendTag bool
+		var split = 50
+		remain := len(memberUserIDList) % split
+		for i := 0; i < len(memberUserIDList)/split; i++ {
+			wg.Add(1)
+			go func(list []string) {
+				for _, v := range list {
+					pb.MsgData.RecvID = v
+					isSend := modifyMessageByUserMessageReceiveOpt(v, groupID, constant.GroupChatType, pb)
+					if isSend {
+						msgToMQ.MsgData = pb.MsgData
+						err := rpc.sendMsgToKafka(&msgToMQ, v)
+						if err != nil {
+							log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v, msgToMQ.String())
+						} else {
+							sendTag = true
+						}
+					}
 				}
-			}
-
+				wg.Done()
+			}(memberUserIDList[i*split : (i+1)*split])
 		}
+		if remain > 0 {
+			wg.Add(1)
+			go func(list []string) {
+				for _, v := range list {
+					pb.MsgData.RecvID = v
+					isSend := modifyMessageByUserMessageReceiveOpt(v, groupID, constant.GroupChatType, pb)
+					if isSend {
+						msgToMQ.MsgData = pb.MsgData
+						err := rpc.sendMsgToKafka(&msgToMQ, v)
+						if err != nil {
+							log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v, msgToMQ.String())
+						} else {
+							sendTag = true
+						}
+					}
+				}
+				wg.Done()
+			}(memberUserIDList[split*(len(memberUserIDList)/split):])
+		}
+		wg.Wait()
+
 		log.Info(msgToMQ.OperationID, "addUidList", addUidList)
 		for _, v := range addUidList {
 			pb.MsgData.RecvID = v
@@ -272,7 +315,8 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 				err := rpc.sendMsgToKafka(&msgToMQ, v)
 				if err != nil {
 					log.NewError(msgToMQ.OperationID, "kafka send msg err:UserId", v, msgToMQ.String())
-					return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+				} else {
+					sendTag = true
 				}
 			}
 		}
@@ -280,7 +324,63 @@ func (rpc *rpcChat) SendMsg(_ context.Context, pb *pbChat.SendMsgReq) (*pbChat.S
 		if err := callbackAfterSendGroupMsg(pb); err != nil {
 			log.NewError(pb.OperationID, utils.GetSelfFuncName(), "callbackAfterSendGroupMsg failed", err.Error())
 		}
-		return returnMsg(&replay, pb, 0, "", msgToMQ.MsgData.ServerMsgID, msgToMQ.MsgData.SendTime)
+		if !sendTag {
+			return returnMsg(&replay, pb, 201, "kafka send msg err", "", 0)
+		} else {
+			if pb.MsgData.ContentType == constant.AtText {
+				go func() {
+					var conversationReq pbConversation.ModifyConversationFieldReq
+					var tag bool
+					var atUserID []string
+					conversation := pbConversation.Conversation{
+						OwnerUserID:      pb.MsgData.SendID,
+						ConversationID:   utils.GetConversationIDBySessionType(pb.MsgData.GroupID, constant.GroupChatType),
+						ConversationType: constant.GroupChatType,
+						GroupID:          pb.MsgData.GroupID,
+					}
+					conversationReq.Conversation = &conversation
+					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())
+						}
+					}
+				}()
+			}
+			return returnMsg(&replay, pb, 0, "", msgToMQ.MsgData.ServerMsgID, msgToMQ.MsgData.SendTime)
+
+		}
 	case constant.NotificationChatType:
 		msgToMQ.MsgData = pb.MsgData
 		log.NewInfo(msgToMQ.OperationID, msgToMQ)
@@ -562,6 +662,38 @@ func Notification(n *NotificationMsg) {
 		ex = config.Config.Notification.GroupMemberCancelMuted.OfflinePush.Ext
 		reliabilityLevel = config.Config.Notification.GroupMemberCancelMuted.Conversation.ReliabilityLevel
 		unReadCount = config.Config.Notification.GroupMemberCancelMuted.Conversation.UnreadCount
+
+	case constant.GroupMemberInfoSetNotification:
+		pushSwitch = config.Config.Notification.GroupMemberInfoSet.OfflinePush.PushSwitch
+		title = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Title
+		desc = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Desc
+		ex = config.Config.Notification.GroupMemberInfoSet.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.GroupMemberInfoSet.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.GroupMemberInfoSet.Conversation.UnreadCount
+
+	case constant.OrganizationChangedNotification:
+		pushSwitch = config.Config.Notification.OrganizationChanged.OfflinePush.PushSwitch
+		title = config.Config.Notification.OrganizationChanged.OfflinePush.Title
+		desc = config.Config.Notification.OrganizationChanged.OfflinePush.Desc
+		ex = config.Config.Notification.OrganizationChanged.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.OrganizationChanged.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.OrganizationChanged.Conversation.UnreadCount
+
+	case constant.WorkMomentNotification:
+		pushSwitch = config.Config.Notification.WorkMomentsNotification.OfflinePush.PushSwitch
+		title = config.Config.Notification.WorkMomentsNotification.OfflinePush.Title
+		desc = config.Config.Notification.WorkMomentsNotification.OfflinePush.Desc
+		ex = config.Config.Notification.WorkMomentsNotification.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.WorkMomentsNotification.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.WorkMomentsNotification.Conversation.UnreadCount
+
+	case constant.ConversationPrivateChatNotification:
+		pushSwitch = config.Config.Notification.ConversationSetPrivate.OfflinePush.PushSwitch
+		title = config.Config.Notification.ConversationSetPrivate.OfflinePush.Title
+		desc = config.Config.Notification.ConversationSetPrivate.OfflinePush.Desc
+		ex = config.Config.Notification.ConversationSetPrivate.OfflinePush.Ext
+		reliabilityLevel = config.Config.Notification.ConversationSetPrivate.Conversation.ReliabilityLevel
+		unReadCount = config.Config.Notification.ConversationSetPrivate.Conversation.UnreadCount
 	}
 	switch reliabilityLevel {
 	case constant.UnreliableNotification:

internal/rpc/msg/work_moments_notification.go

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

internal/rpc/office/office.go

@@ -165,7 +165,7 @@ func (s *officeServer) SendMsg2Tag(_ context.Context, req *pbOffice.SendMsg2TagR
 			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMemberIDListByGroupID failed", err.Error())
 			continue
 		}
-		log.NewInfo(req.OperationID, utils.GetSelfFuncName(), userIDList)
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), userIDList)
 		groupUserIDList = append(groupUserIDList, userIDList...)
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), groupUserIDList, req.GroupList)
@@ -266,3 +266,280 @@ func (s *officeServer) GetUserTagByID(_ context.Context, req *pbOffice.GetUserTa
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
 }
+
+func (s *officeServer) CreateOneWorkMoment(_ context.Context, req *pbOffice.CreateOneWorkMomentReq) (resp *pbOffice.CreateOneWorkMomentResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.CreateOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
+	workMoment := db.WorkMoment{
+		Comments:     []*db.Comment{},
+		LikeUserList: []*db.LikeUser{},
+	}
+	createUser, err := imdb.GetUserByUserID(req.WorkMoment.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	if err := utils.CopyStructFields(&workMoment, req.WorkMoment); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	workMoment.UserName = createUser.Nickname
+	workMoment.FaceURL = createUser.FaceURL
+	workMoment.PermissionUserIDList = s.getPermissionUserIDList(req.OperationID, req.WorkMoment.PermissionGroupList, req.WorkMoment.PermissionUserList)
+	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "workMoment to create", workMoment)
+	err = db.DB.CreateOneWorkMoment(&workMoment)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CreateOneWorkMoment", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+
+	// send notification to at users
+	for _, atUser := range req.WorkMoment.AtUserList {
+		workMomentNotificationMsg := &pbOffice.WorkMomentNotificationMsg{
+			NotificationMsgType: constant.WorkMomentAtUserNotification,
+			WorkMomentID:        workMoment.WorkMomentID,
+			WorkMomentContent:   workMoment.Content,
+			UserID:              workMoment.UserID,
+			FaceURL:             createUser.FaceURL,
+			UserName:            createUser.Nickname,
+			CreateTime:          workMoment.CreateTime,
+		}
+		msg.WorkMomentSendNotification(req.OperationID, atUser.UserID, workMomentNotificationMsg)
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+// count and distinct permission users
+func (s *officeServer) getPermissionUserIDList(operationID string, groupList []*pbOffice.PermissionGroup, userList []*pbOffice.WorkMomentUser) []string {
+	var permissionUserIDList []string
+	for _, group := range groupList {
+		groupMemberIDList, err := imdb.GetGroupMemberIDListByGroupID(group.GroupID)
+		if err != nil {
+			log.NewError(operationID, utils.GetSelfFuncName(), "GetGroupMemberIDListByGroupID failed", group, err.Error())
+			continue
+		}
+		log.NewDebug(operationID, utils.GetSelfFuncName(), "groupMemberIDList: ", groupMemberIDList)
+		permissionUserIDList = append(permissionUserIDList, groupMemberIDList...)
+	}
+	var userIDList []string
+	for _, user := range userList {
+		userIDList = append(userIDList, user.UserID)
+	}
+	permissionUserIDList = append(permissionUserIDList, userIDList...)
+	permissionUserIDList = utils.RemoveRepeatedStringInList(permissionUserIDList)
+	return permissionUserIDList
+}
+
+func (s *officeServer) DeleteOneWorkMoment(_ context.Context, req *pbOffice.DeleteOneWorkMomentReq) (resp *pbOffice.DeleteOneWorkMomentResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.DeleteOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
+	workMoment, err := db.DB.GetWorkMomentByID(req.WorkMomentID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetWorkMomentByID failed", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "workMoment", workMoment)
+	if workMoment.UserID != req.UserID {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "workMoment.UserID != req.WorkMomentID, delete failed", workMoment, req.WorkMomentID)
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}
+		return resp, nil
+	}
+	err = db.DB.DeleteOneWorkMoment(req.WorkMomentID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DeleteOneWorkMoment", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func isUserCanSeeWorkMoment(userID string, workMoment db.WorkMoment) bool {
+	if userID != workMoment.UserID {
+		switch workMoment.Permission {
+		case constant.WorkMomentPublic:
+			return true
+		case constant.WorkMomentPrivate:
+			return false
+		case constant.WorkMomentPermissionCanSee:
+			return utils.IsContain(userID, workMoment.PermissionUserIDList)
+		case constant.WorkMomentPermissionCantSee:
+			return !utils.IsContain(userID, workMoment.PermissionUserIDList)
+		}
+		return false
+	}
+	return true
+}
+
+func (s *officeServer) LikeOneWorkMoment(_ context.Context, req *pbOffice.LikeOneWorkMomentReq) (resp *pbOffice.LikeOneWorkMomentResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.LikeOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
+	user, err := imdb.GetUserByUserID(req.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID failed", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	workMoment, like, err := db.DB.LikeOneWorkMoment(req.UserID, user.Nickname, req.WorkMomentID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "LikeOneWorkMoment failed ", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	workMomentNotificationMsg := &pbOffice.WorkMomentNotificationMsg{
+		NotificationMsgType: constant.WorkMomentLikeNotification,
+		WorkMomentID:        workMoment.WorkMomentID,
+		WorkMomentContent:   workMoment.Content,
+		UserID:              user.UserID,
+		FaceURL:             user.FaceURL,
+		UserName:            user.Nickname,
+		CreateTime:          int32(time.Now().Unix()),
+	}
+	// send notification
+	if like && workMoment.UserID != req.UserID {
+		msg.WorkMomentSendNotification(req.OperationID, workMoment.UserID, workMomentNotificationMsg)
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *officeServer) CommentOneWorkMoment(_ context.Context, req *pbOffice.CommentOneWorkMomentReq) (resp *pbOffice.CommentOneWorkMomentResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.CommentOneWorkMomentResp{CommonResp: &pbOffice.CommonResp{}}
+	commentUser, err := imdb.GetUserByUserID(req.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID commentUserName failed", req.UserID, err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	var replyUserName string
+	if req.ReplyUserID != "" {
+		replyUserName, err = imdb.GetUserNameByUserID(req.ReplyUserID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserNameByUserID get replyUserName failed", req.ReplyUserID, err.Error())
+			resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+			return resp, nil
+		}
+	}
+	comment := &db.Comment{
+		UserID:        req.UserID,
+		UserName:      commentUser.Nickname,
+		ReplyUserID:   req.ReplyUserID,
+		ReplyUserName: replyUserName,
+		Content:       req.Content,
+		CreateTime:    int32(time.Now().Unix()),
+	}
+	workMoment, err := db.DB.CommentOneWorkMoment(comment, req.WorkMomentID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CommentOneWorkMoment failed", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	workMomentNotificationMsg := &pbOffice.WorkMomentNotificationMsg{
+		NotificationMsgType: constant.WorkMomentCommentNotification,
+		WorkMomentID:        workMoment.WorkMomentID,
+		WorkMomentContent:   workMoment.Content,
+		UserID:              commentUser.UserID,
+		FaceURL:             commentUser.FaceURL,
+		UserName:            commentUser.Nickname,
+		ReplyUserID:         comment.ReplyUserID,
+		ReplyUserName:       comment.ReplyUserName,
+		ContentID:           comment.ContentID,
+		Content:             comment.Content,
+		CreateTime:          comment.CreateTime,
+	}
+	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "msg: ", *workMomentNotificationMsg)
+	if req.UserID != workMoment.UserID {
+		msg.WorkMomentSendNotification(req.OperationID, workMoment.UserID, workMomentNotificationMsg)
+	}
+	if req.ReplyUserID != "" && req.ReplyUserID != workMoment.UserID && req.ReplyUserID != req.UserID {
+		msg.WorkMomentSendNotification(req.OperationID, req.ReplyUserID, workMomentNotificationMsg)
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *officeServer) GetWorkMomentByID(_ context.Context, req *pbOffice.GetWorkMomentByIDReq) (resp *pbOffice.GetWorkMomentByIDResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.GetWorkMomentByIDResp{
+		WorkMoment: &pbOffice.WorkMoment{},
+		CommonResp: &pbOffice.CommonResp{},
+	}
+	workMoment, err := db.DB.GetWorkMomentByID(req.WorkMomentID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetWorkMomentByID failed", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	canSee := isUserCanSeeWorkMoment(req.OpUserID, *workMoment)
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), canSee, req.OpUserID, *workMoment)
+	if !canSee {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "workMoments not access to user", canSee, workMoment, req.OpUserID)
+	}
+	if err := utils.CopyStructFields(resp.WorkMoment, workMoment); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *officeServer) GetUserWorkMoments(_ context.Context, req *pbOffice.GetUserWorkMomentsReq) (resp *pbOffice.GetUserWorkMomentsResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.GetUserWorkMomentsResp{CommonResp: &pbOffice.CommonResp{}, WorkMoments: []*pbOffice.WorkMoment{}}
+	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
+	var workMoments []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(), "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())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *officeServer) GetUserFriendWorkMoments(_ context.Context, req *pbOffice.GetUserFriendWorkMomentsReq) (resp *pbOffice.GetUserFriendWorkMomentsResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.GetUserFriendWorkMomentsResp{CommonResp: &pbOffice.CommonResp{}, WorkMoments: []*pbOffice.WorkMoment{}}
+	resp.Pagination = &pbCommon.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}
+	workMoments, err := db.DB.GetUserFriendWorkMoments(req.Pagination.ShowNumber, req.Pagination.PageNumber, req.UserID)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserFriendWorkMoments", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	if err := utils.CopyStructFields(&resp.WorkMoments, workMoments); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *officeServer) SetUserWorkMomentsLevel(_ context.Context, req *pbOffice.SetUserWorkMomentsLevelReq) (resp *pbOffice.SetUserWorkMomentsLevelResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.SetUserWorkMomentsLevelResp{CommonResp: &pbOffice.CommonResp{}}
+	if err := db.DB.SetUserWorkMomentsLevel(req.UserID, req.Level); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetUserWorkMomentsLevel failed", err.Error())
+		resp.CommonResp = &pbOffice.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
+		return resp, nil
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}
+
+func (s *officeServer) ChangeWorkMomentPermission(_ context.Context, req *pbOffice.ChangeWorkMomentPermissionReq) (resp *pbOffice.ChangeWorkMomentPermissionResp, err error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp = &pbOffice.ChangeWorkMomentPermissionResp{CommonResp: &pbOffice.CommonResp{}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
+	return resp, nil
+}

internal/rpc/organization/organization.go

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

internal/rpc/user/user.go

@@ -75,7 +75,7 @@ func (s *userServer) Run() {
 func syncPeerUserConversation(conversation *pbUser.Conversation, operationID string) error {
 	peerUserConversation := db.Conversation{
 		OwnerUserID:      conversation.UserID,
-		ConversationID:   "single_" + conversation.OwnerUserID,
+		ConversationID:   utils.GetConversationIDBySessionType(conversation.OwnerUserID, constant.SingleChatType),
 		ConversationType: constant.SingleChatType,
 		UserID:           conversation.OwnerUserID,
 		GroupID:          "",
@@ -129,6 +129,7 @@ func (s *userServer) BatchSetConversations(ctx context.Context, req *pbUser.Batc
 		if err := utils.CopyStructFields(&conversation, v); err != nil {
 			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), v.String(), "CopyStructFields failed", err.Error())
 		}
+		//redis op
 		if err := db.DB.SetSingleConversationRecvMsgOpt(req.OwnerUserID, v.ConversationID, v.RecvMsgOpt); err != nil {
 			log.NewError(req.OperationID, utils.GetSelfFuncName(), "cache failed, rpc return", err.Error())
 			resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
@@ -206,10 +207,23 @@ func (s *userServer) GetConversations(ctx context.Context, req *pbUser.GetConver
 
 func (s *userServer) SetConversation(ctx context.Context, req *pbUser.SetConversationReq) (*pbUser.SetConversationResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbUser.SetConversationResp{}
 	if req.NotificationType == 0 {
 		req.NotificationType = constant.ConversationOptChangeNotification
 	}
-	resp := &pbUser.SetConversationResp{}
+	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 = &pbUser.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 = &pbUser.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())
@@ -278,8 +292,8 @@ func (s *userServer) SetRecvMsgOpt(ctx context.Context, req *pbUser.SetRecvMsgOp
 
 func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) (*pbUser.DeleteUsersResp, error) {
 	log.NewInfo(req.OperationID, "DeleteUsers args ", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) {
-		log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
 		return &pbUser.DeleteUsersResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, FailedUserIDList: req.DeleteUserIDList}, nil
 	}
 	var common pbUser.CommonResp
@@ -299,8 +313,8 @@ func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq)
 
 func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq) (*pbUser.GetAllUserIDResp, error) {
 	log.NewInfo(req.OperationID, "GetAllUserID args ", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) {
-		log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
 		return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 	uidList, err := imdb.SelectAllUserID()
@@ -315,8 +329,8 @@ func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq
 
 func (s *userServer) AccountCheck(_ context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
 	log.NewInfo(req.OperationID, "AccountCheck args ", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) {
-		log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
 		return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 	uidList, err := imdb.SelectSomeUserID(req.CheckUserIDList)
@@ -375,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

@@ -43,6 +43,8 @@ type Conversation struct {
 	DraftTextTime    int64  `json:"draftTextTime"`
 	IsPinned         bool   `json:"isPinned" binding:"omitempty"`
 	IsPrivateChat    bool   `json:"isPrivateChat"`
+	GroupAtType      int32  `json:"groupAtType"`
+	IsNotInGroup     bool   `json:"isNotInGroup"`
 	AttachedInfo     string `json:"attachedInfo"`
 	Ex               string `json:"ex"`
 }
@@ -56,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/group_api_struct.go

@@ -220,3 +220,14 @@ type CancelMuteGroupReq struct {
 type CancelMuteGroupResp struct {
 	CommResp
 }
+
+type SetGroupMemberNicknameReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	GroupID     string `json:"groupID" binding:"required"`
+	UserID      string `json:"userID" binding:"required"`
+	Nickname    string `json:"nickname"`
+}
+
+type SetGroupMemberNicknameResp struct {
+	CommResp
+}

pkg/base_info/organization_api_struct.go

@@ -0,0 +1,110 @@
+package base_info
+
+import open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+
+type CreateDepartmentReq struct {
+	*open_im_sdk.Department
+	OperationID string `json:"operationID" binding:"required"`
+}
+type CreateDepartmentResp struct {
+	CommResp
+	Department *open_im_sdk.Department `json:"-"`
+	Data       map[string]interface{}  `json:"data"`
+}
+
+type UpdateDepartmentReq struct {
+	*open_im_sdk.Department
+	DepartmentID string `json:"departmentID" binding:"required"`
+	OperationID  string `json:"operationID" binding:"required"`
+}
+type UpdateDepartmentResp struct {
+	CommResp
+}
+
+type GetSubDepartmentReq struct {
+	OperationID  string `json:"operationID" binding:"required"`
+	DepartmentID string `json:"departmentID" binding:"required"`
+}
+type GetSubDepartmentResp struct {
+	CommResp
+	DepartmentList []*open_im_sdk.Department `json:"-"`
+	Data           []map[string]interface{}  `json:"data"`
+}
+
+type DeleteDepartmentReq struct {
+	OperationID  string `json:"operationID" binding:"required"`
+	DepartmentID string `json:"departmentID" binding:"required"`
+}
+type DeleteDepartmentResp struct {
+	CommResp
+}
+
+type CreateOrganizationUserReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	*open_im_sdk.OrganizationUser
+}
+type CreateOrganizationUserResp struct {
+	CommResp
+}
+
+type UpdateOrganizationUserReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	*open_im_sdk.OrganizationUser
+}
+type UpdateOrganizationUserResp struct {
+	CommResp
+}
+
+type CreateDepartmentMemberReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	*open_im_sdk.DepartmentMember
+}
+
+type CreateDepartmentMemberResp struct {
+	CommResp
+}
+
+type GetUserInDepartmentReq struct {
+	UserID      string `json:"userID" binding:"required"`
+	OperationID string `json:"operationID" binding:"required"`
+}
+type GetUserInDepartmentResp struct {
+	CommResp
+	UserInDepartment *open_im_sdk.UserInDepartment `json:"-"`
+	Data             map[string]interface{}        `json:"data"`
+}
+
+type UpdateUserInDepartmentReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	*open_im_sdk.DepartmentMember
+}
+type UpdateUserInDepartmentResp struct {
+	CommResp
+}
+
+type DeleteOrganizationUserReq struct {
+	UserID      string `json:"userID" binding:"required"`
+	OperationID string `json:"operationID" binding:"required"`
+}
+type DeleteOrganizationUserResp struct {
+	CommResp
+}
+
+type GetDepartmentMemberReq struct {
+	DepartmentID string `json:"departmentID" binding:"required"`
+	OperationID  string `json:"operationID" binding:"required"`
+}
+type GetDepartmentMemberResp struct {
+	CommResp
+	UserInDepartmentList []*open_im_sdk.UserDepartmentMember `json:"-"`
+	Data                 []map[string]interface{}            `json:"data"`
+}
+
+type DeleteUserInDepartmentReq struct {
+	DepartmentID string `json:"departmentID" binding:"required"`
+	UserID       string `json:"userID" binding:"required"`
+	OperationID  string `json:"operationID" binding:"required"`
+}
+type DeleteUserInDepartmentResp struct {
+	CommResp
+}

pkg/base_info/user_api_struct.go

@@ -32,3 +32,21 @@ type GetSelfUserInfoResp struct {
 	UserInfo *open_im_sdk.UserInfo  `json:"-"`
 	Data     map[string]interface{} `json:"data"`
 }
+
+type GetFriendIDListFromCacheReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+type GetFriendIDListFromCacheResp struct {
+	CommResp
+	UserIDList []string `json:"userIDList" binding:"required"`
+}
+
+type GetBlackIDListFromCacheReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+type GetBlackIDListFromCacheResp struct {
+	CommResp
+	UserIDList []string `json:"userIDList" binding:"required"`
+}

pkg/base_info/work_moments_struct.go

@@ -0,0 +1,114 @@
+package base_info
+
+import "Open_IM/pkg/proto/office"
+
+type CreateOneWorkMomentReq struct {
+	office.CreateOneWorkMomentReq
+}
+
+type CreateOneWorkMomentResp struct {
+	CommResp
+}
+
+type DeleteOneWorkMomentReq struct {
+	office.DeleteOneWorkMomentReq
+}
+
+type DeleteOneWorkMomentResp struct {
+	CommResp
+}
+
+type LikeOneWorkMomentReq struct {
+	office.LikeOneWorkMomentReq
+}
+
+type LikeOneWorkMomentResp struct {
+	CommResp
+}
+
+type CommentOneWorkMomentReq struct {
+	office.CommentOneWorkMomentReq
+}
+
+type CommentOneWorkMomentResp struct {
+	CommResp
+}
+
+type WorkMomentsUserCommonReq struct {
+	PageNumber  int32  `json:"pageNumber" binding:"required"`
+	ShowNumber  int32  `json:"showNumber" binding:"required"`
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+type GetWorkMomentByIDReq struct {
+	office.GetWorkMomentByIDReq
+}
+
+type WorkMoment struct {
+	WorkMomentID string            `json:"workMomentID"`
+	UserID       string            `json:"userID"`
+	Content      string            `json:"content"`
+	LikeUserList []*WorkMomentUser `json:"likeUsers"`
+	Comments     []*Comment        `json:"comments"`
+	FaceURL      string            `json:"faceURL"`
+	UserName     string            `json:"userName"`
+	AtUserList   []*WorkMomentUser `json:"atUsers"`
+	CreateTime   int32             `json:"createTime"`
+}
+
+type WorkMomentUser struct {
+	UserID   string `json:"userID"`
+	UserName string `json:"userName"`
+}
+
+type Comment struct {
+	UserID        string `json:"userID"`
+	UserName      string `json:"userName"`
+	ReplyUserID   string `json:"replyUserID"`
+	ReplyUserName string `json:"replyUserName"`
+	ContentID     string `json:"contentID"`
+	Content       string `json:"content"`
+	CreateTime    int32  `json:"createTime"`
+}
+
+type GetWorkMomentByIDResp struct {
+	CommResp
+	Data struct {
+		WorkMoment *WorkMoment `json:"workMoment"`
+	} `json:"data"`
+}
+
+type GetUserWorkMomentsReq struct {
+	WorkMomentsUserCommonReq
+	UserID string `json:"userID"`
+}
+
+type GetUserWorkMomentsResp struct {
+	CommResp
+	Data struct {
+		WorkMoments []*WorkMoment `json:"workMoments"`
+		CurrentPage int32         `json:"currentPage"`
+		ShowNumber  int32         `json:"showNumber"`
+	} `json:"data"`
+}
+
+type GetUserFriendWorkMomentsReq struct {
+	WorkMomentsUserCommonReq
+}
+
+type GetUserFriendWorkMomentsResp struct {
+	CommResp
+	Data struct {
+		WorkMoments []*WorkMoment `json:"workMoments"`
+		CurrentPage int32         `json:"currentPage"`
+		ShowNumber  int32         `json:"showNumber"`
+	} `json:"data"`
+}
+
+type SetUserWorkMomentsLevelReq struct {
+	office.SetUserWorkMomentsLevelReq
+}
+
+type SetUserWorkMomentsLevelResp struct {
+	CommResp
+}

pkg/common/config/config.go

@@ -56,11 +56,13 @@ type config struct {
 			OssRoleArn         string `yaml:"OssRoleArn"`
 		}
 		Minio struct {
-			Bucket          string `yaml:"bucket"`
-			Location        string `yaml:"location"`
-			Endpoint        string `yaml:"endpoint"`
-			AccessKeyID     string `yaml:"accessKeyID"`
-			SecretAccessKey string `yaml:"secretAccessKey"`
+			Bucket              string `yaml:"bucket"`
+			Location            string `yaml:"location"`
+			Endpoint            string `yaml:"endpoint"`
+			AccessKeyID         string `yaml:"accessKeyID"`
+			SecretAccessKey     string `yaml:"secretAccessKey"`
+			EndpointInner       string `yaml:"endpointInner"`
+			EndpointInnerEnable bool   `yaml:"endpointInnerEnable"`
 		} `yaml:"minio"`
 	}
 
@@ -115,6 +117,9 @@ type config struct {
 		OpenImMessageCMSName         string `yaml:"openImMessageCMSName"`
 		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"`
@@ -173,6 +178,7 @@ type config struct {
 		AppManagerUid []string `yaml:"appManagerUid"`
 		Secrets       []string `yaml:"secrets"`
 	}
+
 	Kafka struct {
 		Ws2mschat struct {
 			Addr  []string `yaml:"addr"`
@@ -188,9 +194,11 @@ type config struct {
 			MsgToPush  string `yaml:"msgToPush"`
 		}
 	}
-	Secret           string `yaml:"secret"`
-	MultiLoginPolicy int    `yaml:"multiloginpolicy"`
-	TokenPolicy      struct {
+	Secret               string `yaml:"secret"`
+	MultiLoginPolicy     int    `yaml:"multiloginpolicy"`
+	ChatPersistenceMysql bool   `yaml:"chatPersistenceMysql"`
+
+	TokenPolicy struct {
 		AccessSecret string `yaml:"accessSecret"`
 		AccessExpire int64  `yaml:"accessExpire"`
 	}
@@ -301,6 +309,16 @@ type config struct {
 			OfflinePush  POfflinePush  `yaml:"offlinePush"`
 			DefaultTips  PDefaultTips  `yaml:"defaultTips"`
 		} `yaml:"groupMemberCancelMuted"`
+		GroupMemberInfoSet struct {
+			Conversation PConversation `yaml:"conversation"`
+			OfflinePush  POfflinePush  `yaml:"offlinePush"`
+			DefaultTips  PDefaultTips  `yaml:"defaultTips"`
+		} `yaml:"groupMemberInfoSet"`
+		OrganizationChanged struct {
+			Conversation PConversation `yaml:"conversation"`
+			OfflinePush  POfflinePush  `yaml:"offlinePush"`
+			DefaultTips  PDefaultTips  `yaml:"defaultTips"`
+		} `yaml:"organizationChanged"`
 
 		////////////////////////user///////////////////////
 		UserInfoUpdated struct {
@@ -366,6 +384,11 @@ type config struct {
 				CloseTips string `yaml:"closeTips"`
 			} `yaml:"defaultTips"`
 		} `yaml:"conversationSetPrivate"`
+		WorkMomentsNotification struct {
+			Conversation PConversation `yaml:"conversation"`
+			OfflinePush  POfflinePush  `yaml:"offlinePush"`
+			DefaultTips  PDefaultTips  `yaml:"defaultTips"`
+		} `yaml:"workMomentsNotification"`
 	}
 	Demo struct {
 		Port         []int `yaml:"openImDemoPort"`

pkg/common/constant/constant.go

@@ -81,6 +81,7 @@ const (
 	GroupMemberCancelMutedNotification   = 1513
 	GroupMutedNotification               = 1514
 	GroupCancelMutedNotification         = 1515
+	GroupMemberInfoSetNotification       = 1516
 
 	SignalingNotificationBegin = 1600
 	SignalingNotification      = 1601
@@ -88,6 +89,11 @@ const (
 
 	ConversationPrivateChatNotification = 1701
 
+	OrganizationChangedNotification = 1801
+
+	WorkMomentNotificationBegin = 1900
+	WorkMomentNotification      = 1901
+
 	NotificationEnd = 2000
 
 	//status
@@ -177,6 +183,24 @@ const (
 	OtherType = 1
 	VideoType = 2
 	ImageType = 3
+
+	// workMoment permission
+	WorkMomentPublic            = 0
+	WorkMomentPrivate           = 1
+	WorkMomentPermissionCanSee  = 2
+	WorkMomentPermissionCantSee = 3
+
+	// workMoment sdk notification type
+	WorkMomentCommentNotification = 0
+	WorkMomentLikeNotification    = 1
+	WorkMomentAtUserNotification  = 2
+)
+const (
+	AtAllString = "AtAllTag"
+	AtNormal    = 0
+	AtMe        = 1
+	AtAll       = 2
+	AtAllAtMe   = 3
 )
 
 var ContentType2PushContent = map[int64]string{
@@ -190,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/constant/error.go

@@ -51,7 +51,8 @@ var (
 
 	ErrAccess   = ErrInfo{ErrCode: 801, ErrMsg: AccessMsg.Error()}
 	ErrDB       = ErrInfo{ErrCode: 802, ErrMsg: DBMsg.Error()}
-	ErrArgs     = ErrInfo{ErrCode: 8003, ErrMsg: ArgsMsg.Error()}
+	ErrArgs     = ErrInfo{ErrCode: 803, ErrMsg: ArgsMsg.Error()}
+	ErrStatus   = ErrInfo{ErrCode: 804, ErrMsg: StatusMsg.Error()}
 	ErrCallback = ErrInfo{ErrCode: 809, ErrMsg: CallBackMsg.Error()}
 )
 
@@ -64,6 +65,7 @@ var (
 	TokenUnknownMsg     = errors.New("couldn't handle this token")
 	TokenUserKickedMsg  = errors.New("user has been kicked")
 	AccessMsg           = errors.New("no permission")
+	StatusMsg           = errors.New("status is abnormal")
 	DBMsg               = errors.New("db failed")
 	ArgsMsg             = errors.New("args failed")
 	CallBackMsg         = errors.New("callback failed")

pkg/common/db/model.go

@@ -2,6 +2,8 @@ package db
 
 import (
 	"Open_IM/pkg/common/config"
+	"go.mongodb.org/mongo-driver/bson"
+
 	//"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
 	"fmt"
@@ -34,7 +36,6 @@ func key(dbAddress, dbName string) string {
 
 func init() {
 	//log.NewPrivateLog(constant.LogFileName)
-	//var mgoSession *mgo.Session
 	var mongoClient *mongo.Client
 	var err1 error
 	//mysql init
@@ -46,11 +47,15 @@ func init() {
 		// example: mongodb://$user:$password@mongo1.mongo:27017,mongo2.mongo:27017,mongo3.mongo:27017/$DBDatabase/?replicaSet=rs0&readPreference=secondary&authSource=admin&maxPoolSize=$DBMaxPoolSize
 		uri = config.Config.Mongo.DBUri
 	} else {
-		uri = fmt.Sprintf("mongodb://%s/%s/?maxPoolSize=%d",
-			config.Config.Mongo.DBAddress[0], config.Config.Mongo.DBDatabase,
-			config.Config.Mongo.DBMaxPoolSize)
+		if config.Config.Mongo.DBPassword != "" && config.Config.Mongo.DBUserName != "" {
+			uri = fmt.Sprintf("mongodb://%s:%s@%s/%s?maxPoolSize=%d", config.Config.Mongo.DBUserName, config.Config.Mongo.DBPassword, config.Config.Mongo.DBAddress[0],
+				config.Config.Mongo.DBDatabase, config.Config.Mongo.DBMaxPoolSize)
+		} else {
+			uri = fmt.Sprintf("mongodb://%s/%s/?maxPoolSize=%d",
+				config.Config.Mongo.DBAddress[0], config.Config.Mongo.DBDatabase,
+				config.Config.Mongo.DBMaxPoolSize)
+		}
 	}
-
 	mongoClient, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
 	if err != nil {
 		fmt.Println(" mongo.Connect  failed, try ", utils.GetSelfFuncName(), err.Error(), uri)
@@ -61,40 +66,58 @@ func init() {
 			panic(err1.Error())
 		}
 	}
-	fmt.Println("0", utils.GetSelfFuncName(), "mongo driver client init success")
+	fmt.Println("0", utils.GetSelfFuncName(), "mongo driver client init success: ", uri)
+	// mongodb create index
+	opts := options.CreateIndexes().SetMaxTime(10 * time.Second)
+	dataBase := mongoClient.Database(config.Config.Mongo.DBDatabase)
 
+	cSendLogModels := []mongo.IndexModel{
+		{
+			Keys: bson.M{"user_id": -1},
+		},
+	}
+	result, err := dataBase.Collection(cSendLog).Indexes().CreateMany(context.Background(), cSendLogModels, opts)
+	if err != nil {
+		//fmt.Println("mongodb create cSendLogModels failed", result, err.Error())
+	}
+
+	cChatModels := []mongo.IndexModel{
+		{
+			Keys: bson.M{"uid": -1},
+		},
+	}
+	result, err = dataBase.Collection(cChat).Indexes().CreateMany(context.Background(), cChatModels, opts)
+	if err != nil {
+		fmt.Println("mongodb create cChatModels failed", result, err.Error())
+	}
+
+	cWorkMomentModels := []mongo.IndexModel{
+		{
+			Keys: bson.M{"work_moment_id": -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())
+	}
+
+	cTagModels := []mongo.IndexModel{
+		{
+			Keys: bson.M{"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())
+	}
 	DB.mongoClient = mongoClient
 
-	//mgoDailInfo := &mgo.DialInfo{
-	//	Addrs:     config.Config.Mongo.DBAddress,
-	//	Direct:    config.Config.Mongo.DBDirect,
-	//	Timeout:   time.Second * time.Duration(config.Config.Mongo.DBTimeout),
-	//	Database:  config.Config.Mongo.DBDatabase,
-	//	Source:    config.Config.Mongo.DBSource,
-	//	Username:  config.Config.Mongo.DBUserName,
-	//	Password:  config.Config.Mongo.DBPassword,
-	//	PoolLimit: config.Config.Mongo.DBMaxPoolSize,
-	//}
-	//mgoSession, err = mgo.DialWithInfo(mgoDailInfo)
-	//
-	//if err != nil {
-	//
-	//	mgoSession, err1 = mgo.DialWithInfo(mgoDailInfo)
-	//	if err1 != nil {
-	//		log.NewError(" mongo.Connect  failed, panic", err.Error())
-	//		panic(err1.Error())
-	//	}
-	//}
-
-	//DB.mgoSession = mgoSession
-	//DB.mgoSession.SetMode(mgo.Monotonic, true)
-	//c := DB.mgoSession.DB(config.Config.Mongo.DBDatabase).C(cChat)
-	//err = c.EnsureIndexKey("uid")
-	//if err != nil {
-	//	panic(err.Error())
-	//}
-	//
-
 	// redis pool init
 	DB.redisPool = &redis.Pool{
 		MaxIdle:     config.Config.Redis.DBMaxIdle,

pkg/common/db/model_struct.go

@@ -215,6 +215,8 @@ type Conversation struct {
 	DraftTextTime    int64  `gorm:"column:draft_text_time" json:"draftTextTime"`
 	IsPinned         bool   `gorm:"column:is_pinned" json:"isPinned"`
 	IsPrivateChat    bool   `gorm:"column:is_private_chat" json:"isPrivateChat"`
+	GroupAtType      int32  `gorm:"column:group_at_type" json:"groupAtType"`
+	IsNotInGroup     bool   `gorm:"column:is_not_in_group" json:"isNotInGroup"`
 	AttachedInfo     string `gorm:"column:attached_info;type:varchar(1024)" json:"attachedInfo"`
 	Ex               string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
 }
@@ -222,3 +224,51 @@ type Conversation struct {
 func (Conversation) TableName() string {
 	return "conversations"
 }
+
+type Department struct {
+	DepartmentID   string    `gorm:"column:department_id;primary_key;size:64" json:"departmentID"`
+	FaceURL        string    `gorm:"column:face_url;size:255" json:"faceURL"`
+	Name           string    `gorm:"column:name;size:256" json:"name" binding:"required"`
+	ParentID       string    `gorm:"column:parent_id;size:64" json:"parentID" binding:"required"` // "0" or Real parent id
+	Order          int32     `gorm:"column:order" json:"order" `                                  // 1, 2, ...
+	DepartmentType int32     `gorm:"column:department_type" json:"departmentType"`                //1, 2...
+	CreateTime     time.Time `gorm:"column:create_time" json:"createTime"`
+	Ex             string    `gorm:"column:ex;type:varchar(1024)" json:"ex"`
+}
+
+func (Department) TableName() string {
+	return "departments"
+}
+
+type OrganizationUser struct {
+	UserID      string    `gorm:"column:user_id;primary_key;size:64"`
+	Nickname    string    `gorm:"column:nickname;size:256"`
+	EnglishName string    `gorm:"column:english_name;size:256"`
+	FaceURL     string    `gorm:"column:face_url;size:256"`
+	Gender      int32     `gorm:"column:gender"` //1 ,2
+	Mobile      string    `gorm:"column:mobile;size:32"`
+	Telephone   string    `gorm:"column:telephone;size:32"`
+	Birth       time.Time `gorm:"column:birth"`
+	Email       string    `gorm:"column:email;size:64"`
+	CreateTime  time.Time `gorm:"column:create_time"`
+	Ex          string    `gorm:"column:ex;size:1024"`
+}
+
+func (OrganizationUser) TableName() string {
+	return "organization_users"
+}
+
+type DepartmentMember struct {
+	UserID       string    `gorm:"column:user_id;primary_key;size:64"`
+	DepartmentID string    `gorm:"column:department_id;primary_key;size:64"`
+	Order        int32     `gorm:"column:order" json:"order"` //1,2
+	Position     string    `gorm:"column:position;size:256" json:"position"`
+	Leader       int32     `gorm:"column:leader" json:"leader"` //-1, 1
+	Status       int32     `gorm:"column:status" json:"status"` //-1, 1
+	CreateTime   time.Time `gorm:"column:create_time"`
+	Ex           string    `gorm:"column:ex;type:varchar(1024)" json:"ex"`
+}
+
+func (DepartmentMember) TableName() string {
+	return "department_members"
+}

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"
@@ -26,6 +26,8 @@ const cChat = "msg"
 const cGroup = "group"
 const cTag = "tag"
 const cSendLog = "send_log"
+const cWorkMoment = "work_moment"
+const cCommentMsg = "comment_msg"
 const singleGocMsgNum = 5000
 
 type MsgInfo struct {
@@ -563,10 +565,169 @@ func (d *DataBases) GetTagSendLogs(userID string, showNumber, pageNumber int32)
 	return tagSendLogs, nil
 }
 
+type WorkMoment struct {
+	WorkMomentID         string      `bson:"work_moment_id"`
+	UserID               string      `bson:"user_id"`
+	UserName             string      `bson:"user_name"`
+	FaceURL              string      `bson:"face_url"`
+	Content              string      `bson:"content"`
+	LikeUserList         []*LikeUser `bson:"like_user_list"`
+	AtUserList           []*AtUser   `bson:"at_user_list"`
+	Comments             []*Comment  `bson:"comments"`
+	PermissionUserIDList []string    `bson:"permission_user_id_list"`
+	Permission           int32       `bson:"permission"`
+	CreateTime           int32       `bson:"create_time"`
+}
+
+type AtUser struct {
+	UserID   string `bson:"user_id"`
+	UserName string `bson:"user_name"`
+}
+
+type LikeUser struct {
+	UserID   string `bson:"user_id"`
+	UserName string `bson:"user_name"`
+}
+
+type Comment struct {
+	UserID        string `bson:"user_id" json:"user_id"`
+	UserName      string `bson:"user_name" json:"user_name"`
+	ReplyUserID   string `bson:"reply_user_id" json:"reply_user_id"`
+	ReplyUserName string `bson:"reply_user_name" json:"reply_user_name"`
+	ContentID     string `bson:"content_id" json:"content_id"`
+	Content       string `bson:"content" json:"content"`
+	CreateTime    int32  `bson:"create_time" json:"create_time"`
+}
+
+func (d *DataBases) CreateOneWorkMoment(workMoment *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)
+	workMomentID := generateWorkMomentID(workMoment.UserID)
+	workMoment.WorkMomentID = workMomentID
+	workMoment.CreateTime = int32(time.Now().Unix())
+	_, err := c.InsertOne(ctx, workMoment)
+	return err
+}
+
+func (d *DataBases) DeleteOneWorkMoment(workMomentID string) error {
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cWorkMoment)
+	_, err := c.DeleteOne(ctx, bson.M{"work_moment_id": workMomentID})
+	return err
+}
+
+func (d *DataBases) GetWorkMomentByID(workMomentID 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)
+	workMoment := &WorkMoment{}
+	err := c.FindOne(ctx, bson.M{"work_moment_id": workMomentID}).Decode(workMoment)
+	return workMoment, err
+}
+
+func (d *DataBases) LikeOneWorkMoment(likeUserID, userName, workMomentID string) (*WorkMoment, bool, error) {
+	workMoment, err := d.GetWorkMomentByID(workMomentID)
+	if err != nil {
+		return nil, false, err
+	}
+	var isAlreadyLike bool
+	for i, user := range workMoment.LikeUserList {
+		if likeUserID == user.UserID {
+			isAlreadyLike = true
+			workMoment.LikeUserList = append(workMoment.LikeUserList[0:i], workMoment.LikeUserList[i+1:]...)
+		}
+	}
+	if !isAlreadyLike {
+		workMoment.LikeUserList = append(workMoment.LikeUserList, &LikeUser{UserID: likeUserID, UserName: userName})
+	}
+	log.NewDebug("", utils.GetSelfFuncName(), workMoment)
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cWorkMoment)
+	_, err = c.UpdateOne(ctx, bson.M{"work_moment_id": workMomentID}, bson.M{"$set": bson.M{"like_user_list": workMoment.LikeUserList}})
+	return workMoment, !isAlreadyLike, err
+}
+
+func (d *DataBases) SetUserWorkMomentsLevel(userID string, level int32) error {
+	return nil
+}
+
+func (d *DataBases) CommentOneWorkMoment(comment *Comment, workMomentID string) (WorkMoment, error) {
+	comment.ContentID = generateWorkMomentCommentID(workMomentID)
+	ctx, _ := context.WithTimeout(context.Background(), time.Duration(config.Config.Mongo.DBTimeout)*time.Second)
+	c := d.mongoClient.Database(config.Config.Mongo.DBDatabase).Collection(cWorkMoment)
+	var workMoment WorkMoment
+	err := c.FindOneAndUpdate(ctx, bson.M{"work_moment_id": workMomentID}, bson.M{"$push": bson.M{"comments": comment}}).Decode(&workMoment)
+	return workMoment, err
+}
+
+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
+	findOpts := options.Find().SetLimit(int64(showNumber)).SetSkip(int64(showNumber) * (int64(pageNumber) - 1)).SetSort(bson.M{"create_time": -1})
+	result, err := c.Find(ctx, bson.M{"user_id": userID}, findOpts)
+	if err != nil {
+		return workMomentList, nil
+	}
+	err = result.All(ctx, &workMomentList)
+	return workMomentList, err
+}
+
+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, bson.D{ // 等价条件: select * from
+		{"user_id", userID},
+		{"$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, nil
+	}
+	err = result.All(ctx, &workMomentList)
+	return workMomentList, err
+}
+
+func (d *DataBases) GetUserFriendWorkMoments(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{
+				{"$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
+	}
+	err = result.All(ctx, &workMomentList)
+	return workMomentList, err
+}
+
 func generateTagID(tagName, userID string) string {
 	return utils.Md5(tagName + userID + strconv.Itoa(rand.Int()) + time.Now().String())
 }
 
+func generateWorkMomentID(userID string) string {
+	return utils.Md5(userID + strconv.Itoa(rand.Int()) + time.Now().String())
+}
+
+func generateWorkMomentCommentID(workMomentID string) string {
+	return utils.Md5(workMomentID + strconv.Itoa(rand.Int()) + time.Now().String())
+}
+
 func getCurrentTimestampByMill() int64 {
 	return time.Now().UnixNano() / 1e6
 }
@@ -588,9 +749,7 @@ func getMsgIndex(seq uint32) int {
 }
 
 func isContainInt32(target uint32, List []uint32) bool {
-
 	for _, element := range List {
-
 		if target == element {
 			return true
 		}

pkg/common/db/mysql.go

@@ -82,169 +82,45 @@ func initMysqlDB() {
 		fmt.Println("CreateTable GroupMember")
 		db.CreateTable(&GroupMember{})
 	}
-
 	if !db.HasTable(&GroupRequest{}) {
 		fmt.Println("CreateTable GroupRequest")
 		db.CreateTable(&GroupRequest{})
 	}
-
 	if !db.HasTable(&User{}) {
 		fmt.Println("CreateTable User")
 		db.CreateTable(&User{})
 	}
-
 	if !db.HasTable(&Black{}) {
 		fmt.Println("CreateTable Black")
 		db.CreateTable(&Black{})
 	}
 	if !db.HasTable(&ChatLog{}) {
-		fmt.Println("CreateTable Black")
+		fmt.Println("CreateTable ChatLog")
 		db.CreateTable(&ChatLog{})
 	}
 	if !db.HasTable(&Register{}) {
-		fmt.Println("CreateTable Black")
+		fmt.Println("CreateTable Register")
 		db.CreateTable(&Register{})
 	}
 	if !db.HasTable(&Conversation{}) {
-		fmt.Println("CreateTable Black")
+		fmt.Println("CreateTable Conversation")
 		db.CreateTable(&Conversation{})
 	}
 
+	if !db.HasTable(&Department{}) {
+		fmt.Println("CreateTable Department")
+		db.CreateTable(&Department{})
+	}
+	if !db.HasTable(&OrganizationUser{}) {
+		fmt.Println("CreateTable OrganizationUser")
+		db.CreateTable(&OrganizationUser{})
+	}
+	if !db.HasTable(&DepartmentMember{}) {
+		fmt.Println("CreateTable DepartmentMember")
+		db.CreateTable(&DepartmentMember{})
+	}
+
 	return
-
-	sqlTable := "CREATE TABLE IF NOT EXISTS `user` (" +
-		" `uid` varchar(64) NOT NULL," +
-		" `name` varchar(64) DEFAULT NULL," +
-		" `icon` varchar(1024) DEFAULT NULL," +
-		" `gender` tinyint(4) unsigned zerofill DEFAULT NULL," +
-		" `mobile` varchar(32) DEFAULT NULL," +
-		" `birth` varchar(16) DEFAULT NULL," +
-		" `email` varchar(64) DEFAULT NULL," +
-		" `ex` varchar(1024) DEFAULT NULL," +
-		" `create_time` datetime DEFAULT NULL," +
-		" PRIMARY KEY (`uid`)," +
-		" UNIQUE KEY `uk_uid` (`uid`)" +
-		" ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
-	sqlTable = "CREATE TABLE IF NOT EXISTS `friend` (" +
-		" `owner_id` varchar(64) NOT NULL," +
-		" `friend_id` varchar(64) NOT NULL," +
-		" `comment` varchar(255) DEFAULT NULL," +
-		" `friend_flag` int(11) NOT NULL," +
-		" `create_time` datetime NOT NULL," +
-		" PRIMARY KEY (`owner_id`,`friend_id`) USING BTREE" +
-		" ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
-	sqlTable = "CREATE TABLE IF NOT EXISTS  `friend_request` (" +
-		" `req_id` varchar(64) NOT NULL," +
-		" `user_id` varchar(64) NOT NULL," +
-		" `flag` int(11) NOT NULL DEFAULT '0'," +
-		" `req_message` varchar(255) DEFAULT NULL," +
-		" `create_time` datetime NOT NULL," +
-		" PRIMARY KEY (`user_id`,`req_id`) USING BTREE" +
-		" ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
-	sqlTable = "CREATE TABLE IF NOT EXISTS `user_black_list` (" +
-		" `owner_id` varchar(64) NOT NULL," +
-		" `block_id` varchar(64) NOT NULL," +
-		" `create_time` datetime NOT NULL," +
-		" PRIMARY KEY (`owner_id`,`block_id`) USING BTREE" +
-		" ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
-	sqlTable = "CREATE TABLE IF NOT EXISTS `group` (" +
-		" `group_id` varchar(64) NOT NULL," +
-		" `name` varchar(255) DEFAULT NULL," +
-		" `introduction` varchar(255) DEFAULT NULL," +
-		" `notification` varchar(255) DEFAULT NULL," +
-		" `face_url` varchar(255) DEFAULT NULL," +
-		" `create_time` datetime DEFAULT NULL," +
-		" `ex` varchar(255) DEFAULT NULL," +
-		" PRIMARY KEY (`group_id`)" +
-		" ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
-	sqlTable = "CREATE TABLE IF NOT EXISTS `group_member` (" +
-		" `group_id` varchar(64) NOT NULL," +
-		" `uid` varchar(64) NOT NULL," +
-		" `nickname` varchar(255) DEFAULT NULL," +
-		" `user_group_face_url` varchar(255) DEFAULT NULL," +
-		" `administrator_level` int(11) NOT NULL," +
-		" `join_time` datetime NOT NULL," +
-		"  PRIMARY KEY (`group_id`,`uid`) USING BTREE" +
-		" ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
-	sqlTable = "CREATE TABLE IF NOT EXISTS `group_request` (" +
-		" `id` int(11) NOT NULL AUTO_INCREMENT," +
-		" `group_id` varchar(64) NOT NULL," +
-		" `from_user_id` varchar(255) NOT NULL," +
-		" `to_user_id` varchar(255) NOT NULL," +
-		" `flag` int(10) NOT NULL DEFAULT '0'," +
-		" `req_msg` varchar(255) DEFAULT ''," +
-		" `handled_msg` varchar(255) DEFAULT ''," +
-		" `create_time` datetime NOT NULL," +
-		" `from_user_nickname` varchar(255) DEFAULT ''," +
-		" `to_user_nickname` varchar(255) DEFAULT NULL," +
-		" `from_user_face_url` varchar(255) DEFAULT ''," +
-		" `to_user_face_url` varchar(255) DEFAULT ''," +
-		" `handled_user` varchar(255) DEFAULT ''," +
-		" PRIMARY KEY (`id`)" +
-		" ) ENGINE=InnoDB AUTO_INCREMENT=38 DEFAULT CHARSET=utf8mb4;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
-	sqlTable = "CREATE TABLE IF NOT EXISTS  `chat_log` (" +
-		" `msg_id` varchar(128) NOT NULL," +
-		" `send_id` varchar(255) NOT NULL," +
-		" `session_type` int(11) NOT NULL," +
-		" `recv_id` varchar(255) NOT NULL," +
-		" `content_type` int(11) NOT NULL," +
-		" `msg_from` int(11) NOT NULL," +
-		" `content` varchar(1000) NOT NULL," +
-		" `remark` varchar(100) DEFAULT NULL," +
-		" `sender_platform_id` int(11) NOT NULL," +
-		" `send_time` datetime NOT NULL," +
-		" PRIMARY KEY (`msg_id`) USING BTREE" +
-		" ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
-	sqlTable = "CREATE TABLE IF NOT EXISTS `register` (" +
-		" `account` varchar(255) NOT NULL," +
-		" `password` varchar(255) NOT NULL," +
-		" PRIMARY KEY (`account`)  USING BTREE" +
-		" ) ENGINE=InnoDB DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC;"
-	err = db.Exec(sqlTable).Error
-	if err != nil {
-		panic(err.Error())
-	}
-
 }
 
 func (m *mysqlDB) DefaultGormDB() (*gorm.DB, error) {

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,6 +49,19 @@ func GetFriendListByUserID(OwnerUserID string) ([]db.Friend, error) {
 	return friends, nil
 }
 
+func GetFriendIDListByUserID(OwnerUserID string) ([]string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var friendIDList []string
+	err = dbConn.Table("friends").Where("owner_user_id=?", OwnerUserID).Pluck("friend_user_id", &friendIDList).Error
+	if err != nil {
+		return nil, err
+	}
+	return friendIDList, nil
+}
+
 func UpdateFriendComment(OwnerUserID, FriendUserID, Remark string) error {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
 	if err != nil {

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

@@ -72,15 +72,11 @@ func GetGroupMemberIDListByGroupID(groupID string) ([]string, error) {
 		return nil, err
 	}
 	dbConn.LogMode(false)
-	var groupMembers []db.GroupMember
-	err = dbConn.Table("group_members").Select("user_id").Where("group_id=?", groupID).Find(&groupMembers).Error
+	var groupMemberIDList []string
+	err = dbConn.Table("group_members").Where("group_id=?", groupID).Pluck("user_id", &groupMemberIDList).Error
 	if err != nil {
 		return nil, err
 	}
-	var groupMemberIDList []string
-	for _, v := range groupMembers {
-		groupMemberIDList = append(groupMemberIDList, v.UserID)
-	}
 	return groupMemberIDList, nil
 }
 

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

@@ -223,3 +223,13 @@ func UpdateGroupInfoDefaultZero(groupID string, args map[string]interface{}) err
 	}
 	return dbConn.Table("groups").Where("group_id = ? ", groupID).Update(args).Error
 }
+
+func GetAllGroupIDList() ([]string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupIDList []string
+	err = dbConn.Table("groups").Pluck("group_id", &groupIDList).Error
+	return groupIDList, err
+}

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

@@ -0,0 +1,238 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/utils"
+	"time"
+)
+
+func CreateDepartment(department *db.Department) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	department.CreateTime = time.Now()
+	return dbConn.Table("departments").Create(department).Error
+}
+
+func GetDepartment(departmentID string) (error, *db.Department) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var department db.Department
+	err = dbConn.Table("departments").Where("department_id=?", departmentID).Find(&department).Error
+	return err, &department
+}
+
+func UpdateDepartment(department *db.Department, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("departments").Where("department_id=?", department.DepartmentID).Updates(department).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("departments").Where("department_id=?", department.DepartmentID).Updates(args).Error
+	}
+	return nil
+}
+
+func GetSubDepartmentList(departmentID string) (error, []db.Department) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentList []db.Department
+	if departmentID == "-1" {
+		err = dbConn.Table("departments").Find(&departmentList).Error
+	} else {
+		err = dbConn.Table("departments").Where("parent_id=?", departmentID).Find(&departmentList).Error
+	}
+
+	return err, departmentList
+}
+
+func DeleteDepartment(departmentID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("departments").Where("department_id=?", departmentID).Delete(db.Department{}).Error; err != nil {
+		return err
+	}
+	if err = dbConn.Table("department_members").Where("department_id=?", departmentID).Delete(db.DepartmentMember{}).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func CreateOrganizationUser(organizationUser *db.OrganizationUser) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	organizationUser.CreateTime = time.Now()
+
+	return dbConn.Table("organization_users").Create(organizationUser).Error
+}
+
+func GetOrganizationUser(userID string) (error, *db.OrganizationUser) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	organizationUser := db.OrganizationUser{}
+	err = dbConn.Table("organization_users").Where("user_id=?", userID).Take(&organizationUser).Error
+	return err, &organizationUser
+}
+
+func UpdateOrganizationUser(organizationUser *db.OrganizationUser, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(organizationUser).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(args).Error
+	}
+	return nil
+}
+
+func CreateDepartmentMember(departmentMember *db.DepartmentMember) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	departmentMember.CreateTime = time.Now()
+	return dbConn.Table("department_members").Create(departmentMember).Error
+}
+
+func GetUserInDepartment(userID string) (error, []db.DepartmentMember) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentMemberList []db.DepartmentMember
+	err = dbConn.Table("department_members").Where("user_id=?", userID).Find(&departmentMemberList).Error
+	return err, departmentMemberList
+}
+
+func UpdateUserInDepartment(departmentMember *db.DepartmentMember, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("department_members").Where("department_id=? AND user_id=?", departmentMember.DepartmentID, departmentMember.UserID).
+		Updates(departmentMember).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("department_members").Where("department_id=? AND user_id=?", departmentMember.DepartmentID, departmentMember.UserID).
+			Updates(args).Error
+	}
+	return nil
+}
+
+func DeleteUserInDepartment(departmentID, userID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("department_members").Where("department_id=? AND user_id=?", departmentID, userID).Delete(db.DepartmentMember{}).Error
+}
+
+func DeleteUserInAllDepartment(userID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("department_members").Where("user_id=?", userID).Delete(db.DepartmentMember{}).Error
+}
+
+func DeleteOrganizationUser(OrganizationUserID string) error {
+	if err := DeleteUserInAllDepartment(OrganizationUserID); err != nil {
+		return err
+	}
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("organization_users").Where("user_id=?", OrganizationUserID).Delete(db.OrganizationUser{}).Error
+}
+
+func GetDepartmentMemberUserIDList(departmentID string) (error, []string) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentMemberList []db.DepartmentMember
+	err = dbConn.Table("department_members").Where("department_id=?", departmentID).Take(&departmentMemberList).Error
+	if err != nil {
+		return err, nil
+	}
+	var userIDList []string = make([]string, 0)
+	for _, v := range departmentMemberList {
+		userIDList = append(userIDList, v.UserID)
+	}
+	return err, userIDList
+}
+
+func GetDepartmentMemberList(departmentID string) (error, []db.DepartmentMember) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentMemberList []db.DepartmentMember
+	if departmentID == "-1" {
+		err = dbConn.Table("department_members").Find(&departmentMemberList).Error
+	} else {
+		err = dbConn.Table("department_members").Where("department_id=?", departmentID).Find(&departmentMemberList).Error
+	}
+
+	if err != nil {
+		return err, nil
+	}
+	return err, departmentMemberList
+}
+
+func GetAllOrganizationUserID() (error, []string) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var OrganizationUser db.OrganizationUser
+	var result []string
+	return dbConn.Model(&OrganizationUser).Pluck("user_id", &result).Error, result
+}
+
+func GetDepartmentMemberNum(departmentID string) (error, uint32) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return utils.Wrap(err, "DefaultGormDB failed"), 0
+	}
+	var number uint32
+	err = dbConn.Table("department_members").Where("department_id=?", departmentID).Count(&number).Error
+	if err != nil {
+		return utils.Wrap(err, ""), 0
+	}
+	return nil, number
+
+}
+
+func GetSubDepartmentNum(departmentID string) (error, uint32) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return utils.Wrap(err, "DefaultGormDB failed"), 0
+	}
+	var number uint32
+	err = dbConn.Table("departments").Where("parent_id=?", departmentID).Count(&number).Error
+	if err != nil {
+		return utils.Wrap(err, ""), 0
+	}
+	return nil, number
+
+}

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

@@ -56,3 +56,16 @@ func GetBlackListByUserID(ownerUserID string) ([]db.Black, error) {
 	}
 	return blackListUsersInfo, nil
 }
+
+func GetBlackIDListByUserID(ownerUserID string) ([]string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var blackIDList []string
+	err = dbConn.Table("blacks").Where("owner_user_id=?", ownerUserID).Pluck("block_user_id", &blackIDList).Error
+	if err != nil {
+		return nil, err
+	}
+	return blackIDList, nil
+}

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"
@@ -61,6 +60,16 @@ func DeleteUser(userID string) (i int64) {
 	return i
 }
 
+func GetAllUser() ([]db.User, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var userList []db.User
+	err = dbConn.Table("users").Find(&userList).Error
+	return userList, err
+}
+
 func GetUserByUserID(userID string) (*db.User, error) {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
 	if err != nil {
@@ -305,94 +314,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}).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.Model(&db.Conversation{
-		OwnerUserID:    OwnerUserID,
-		ConversationID: conversationID,
-	}).Find(&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
-}

pkg/common/db/redisModel.go

@@ -3,18 +3,24 @@ 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"
 )
 
 const (
-	AccountTempCode               = "ACCOUNT_TEMP_CODE"
+	accountTempCode               = "ACCOUNT_TEMP_CODE"
 	resetPwdTempCode              = "RESET_PWD_TEMP_CODE"
 	userIncrSeq                   = "REDIS_USER_INCR_SEQ:" // user incr seq
 	appleDeviceToken              = "DEVICE_TOKEN"
 	userMinSeq                    = "REDIS_USER_MIN_SEQ:"
 	uidPidToken                   = "UID_PID_TOKEN_STATUS:"
 	conversationReceiveMessageOpt = "CON_RECV_MSG_OPT:"
-	GetuiToken                    = "GETUI"
+	getuiToken                    = "GETUI"
+	userInfoCache                 = "USER_INFO_CACHE:"
+	friendRelationCache           = "FRIEND_RELATION_CACHE:"
+	blackListCache                = "BLACK_LIST_CACHE:"
+	groupCache                    = "GROUP_CACHE:"
 )
 
 func (d *DataBases) Exec(cmd string, key interface{}, args ...interface{}) (interface{}, error) {
@@ -37,16 +43,16 @@ func (d *DataBases) Exec(cmd string, key interface{}, args ...interface{}) (inte
 	return con.Do(cmd, params...)
 }
 func (d *DataBases) JudgeAccountEXISTS(account string) (bool, error) {
-	key := AccountTempCode + account
+	key := accountTempCode + account
 	return redis.Bool(d.Exec("EXISTS", key))
 }
 func (d *DataBases) SetAccountCode(account string, code, ttl int) (err error) {
-	key := AccountTempCode + account
+	key := accountTempCode + account
 	_, err = d.Exec("SET", key, code, "ex", ttl)
 	return err
 }
 func (d *DataBases) GetAccountCode(account string) (string, error) {
-	key := AccountTempCode + account
+	key := accountTempCode + account
 	return redis.String(d.Exec("GET", key))
 }
 
@@ -147,11 +153,100 @@ func (d *DataBases) GetMultiConversationMsgOpt(userID string, conversationIDs []
 }
 
 func (d *DataBases) SetGetuiToken(token string, expireTime int64) error {
-	_, err := d.Exec("SET", GetuiToken, token, "ex", expireTime)
+	_, err := d.Exec("SET", getuiToken, token, "ex", expireTime)
 	return err
 }
 
 func (d *DataBases) GetGetuiToken() (string, error) {
-	result, err := redis.String(d.Exec("GET", GetuiToken))
+	result, err := redis.String(d.Exec("GET", getuiToken))
+	return result, err
+}
+
+func (d *DataBases) SearchContentType() {
+
+}
+
+func (d *DataBases) SetUserInfoToCache(userID string, m map[string]interface{}) error {
+	_, err := d.Exec("hmset", userInfoCache+userID, redis.Args{}.Add().AddFlat(m)...)
+	return err
+}
+
+func (d *DataBases) GetUserInfoFromCache(userID string) (*pbCommon.UserInfo, error) {
+	result, err := redis.String(d.Exec("hgetall", userInfoCache+userID))
+	log2.NewInfo("", result)
+	if err != nil {
+		return nil, err
+	}
+	userInfo := &pbCommon.UserInfo{}
+	err = json.Unmarshal([]byte(result), userInfo)
+	return userInfo, err
+}
+
+func (d *DataBases) AddFriendToCache(userID string, friendIDList ...string) error {
+	var IDList []interface{}
+	for _, id := range friendIDList {
+		IDList = append(IDList, id)
+	}
+	_, err := d.Exec("SADD", friendRelationCache+userID, IDList...)
+	return err
+}
+
+func (d *DataBases) ReduceFriendToCache(userID string, friendIDList ...string) error {
+	var IDList []interface{}
+	for _, id := range friendIDList {
+		IDList = append(IDList, id)
+	}
+	_, err := d.Exec("SREM", friendRelationCache+userID, IDList...)
+	return err
+}
+
+func (d *DataBases) GetFriendIDListFromCache(userID string) ([]string, error) {
+	result, err := redis.Strings(d.Exec("SMEMBERS", friendRelationCache+userID))
+	return result, err
+}
+
+func (d *DataBases) AddBlackUserToCache(userID string, blackList ...string) error {
+	var IDList []interface{}
+	for _, id := range blackList {
+		IDList = append(IDList, id)
+	}
+	_, err := d.Exec("SADD", blackListCache+userID, IDList...)
+	return err
+}
+
+func (d *DataBases) ReduceBlackUserFromCache(userID string, blackList ...string) error {
+	var IDList []interface{}
+	for _, id := range blackList {
+		IDList = append(IDList, id)
+	}
+	_, err := d.Exec("SREM", blackListCache+userID, IDList...)
+	return err
+}
+
+func (d *DataBases) GetBlackListFromCache(userID string) ([]string, error) {
+	result, err := redis.Strings(d.Exec("SMEMBERS", blackListCache+userID))
+	return result, err
+}
+
+func (d *DataBases) AddGroupMemberToCache(groupID string, userIDList ...string) error {
+	var IDList []interface{}
+	for _, id := range userIDList {
+		IDList = append(IDList, id)
+	}
+	_, err := d.Exec("SADD", blackListCache+groupID, IDList...)
+	return err
+}
+
+func (d *DataBases) ReduceGroupMemberFromCache(groupID string, userIDList ...string) error {
+	var IDList []interface{}
+	for _, id := range userIDList {
+		IDList = append(IDList, id)
+	}
+	_, err := d.Exec("SREM", blackListCache+groupID, IDList...)
+	return err
+}
+
+func (d *DataBases) GetGroupMemberIDListFromCache(groupID string) ([]string, error) {
+	result, err := redis.Strings(d.Exec("SMEMBERS", groupCache+groupID))
 	return result, err
 }

pkg/common/http/http_resp.go

@@ -38,6 +38,6 @@ func RespHttp200(ctx *gin.Context, err error, data interface{}) {
 }
 
 // warp error
-func WrapError(err constant.ErrInfo, msg ...string) error {
-	return status.Error(codes.Code(err.ErrCode), err.ErrMsg+msg[0])
+func WrapError(err constant.ErrInfo) error {
+	return status.Error(codes.Code(err.ErrCode), err.ErrMsg)
 }

pkg/common/token_verify/jwt_token.go

@@ -93,7 +93,7 @@ func GetClaimFromToken(tokensString string) (*Claims, error) {
 		}
 	} else {
 		if claims, ok := token.Claims.(*Claims); ok && token.Valid {
-			log.NewDebug("", claims.UID, claims.Platform)
+			//log.NewDebug("", claims.UID, claims.Platform)
 			return claims, nil
 		}
 		return nil, &constant.ErrTokenNotValidYet
@@ -111,7 +111,7 @@ func IsAppManagerAccess(token string, OpUserID string) bool {
 	return false
 }
 
-func IsMangerUserID(OpUserID string) bool {
+func IsManagerUserID(OpUserID string) bool {
 	if utils.IsContain(OpUserID, config.Config.Manager.AppManagerUid) {
 		return true
 	} else {
@@ -138,21 +138,29 @@ func GetUserIDFromToken(token string, operationID string) (bool, string) {
 	return true, claims.UID
 }
 
+func ParseTokenGetUserID(token string, operationID string) (error, string) {
+	claims, err := ParseToken(token, operationID)
+	if err != nil {
+		return utils.Wrap(err, ""), ""
+	}
+	return nil, claims.UID
+}
+
 func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
 	claims, err = GetClaimFromToken(tokensString)
 	if err != nil {
 		log.NewError(operationID, "token validate err", err.Error(), tokensString)
-		return nil, err
+		return nil, utils.Wrap(err, "")
 	}
 
 	m, err := commonDB.DB.GetTokenMapByUidPid(claims.UID, claims.Platform)
 	if err != nil {
 		log.NewError(operationID, "get token from redis err", err.Error(), tokensString)
-		return nil, &constant.ErrTokenInvalid
+		return nil, utils.Wrap(&constant.ErrTokenInvalid, "get token from redis err")
 	}
 	if m == nil {
 		log.NewError(operationID, "get token from redis err", "m is nil", tokensString)
-		return nil, &constant.ErrTokenInvalid
+		return nil, utils.Wrap(&constant.ErrTokenInvalid, "get token from redis err")
 	}
 	if v, ok := m[tokensString]; ok {
 		switch v {
@@ -160,18 +168,18 @@ func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
 			log.NewDebug(operationID, "this is normal return", claims)
 			return claims, nil
 		case constant.InValidToken:
-			return nil, &constant.ErrTokenInvalid
+			return nil, utils.Wrap(&constant.ErrTokenInvalid, "")
 		case constant.KickedToken:
 			log.Error(operationID, "this token has been kicked by other same terminal ", constant.ErrTokenKicked)
-			return nil, &constant.ErrTokenKicked
+			return nil, utils.Wrap(&constant.ErrTokenKicked, "this token has been kicked by other same terminal ")
 		case constant.ExpiredToken:
-			return nil, &constant.ErrTokenExpired
+			return nil, utils.Wrap(&constant.ErrTokenExpired, "")
 		default:
-			return nil, &constant.ErrTokenUnknown
+			return nil, utils.Wrap(&constant.ErrTokenUnknown, "")
 		}
 	}
 	log.NewError(operationID, "redis token map not find", constant.ErrTokenUnknown)
-	return nil, &constant.ErrTokenUnknown
+	return nil, utils.Wrap(&constant.ErrTokenUnknown, "redis token map not find")
 }
 
 //func MakeTheTokenInvalid(currentClaims *Claims, platformClass string) (bool, error) {
@@ -198,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
@@ -207,17 +215,17 @@ 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) {
-	claims, err := ParseToken(token, "")
+func WsVerifyToken(token, uid string, platformID string, operationID string) (bool, error, string) {
+	claims, err := ParseToken(token, operationID)
 	if err != nil {
-		return false, err, "parse token err"
+		return false, utils.Wrap(err, "parse token err"), "parse token err"
 	}
 	if claims.UID != uid {
-		return false, &constant.ErrTokenUnknown, "uid is not same to token uid"
+		return false, utils.Wrap(&constant.ErrTokenUnknown, "uid is not same to token uid"), "uid is not same to token uid"
 	}
 	if claims.Platform != constant.PlatformIDToName(utils.StringToInt32(platformID)) {
-		return false, &constant.ErrTokenUnknown, "platform is not same to token platform"
+		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/common/utils/utils.go

@@ -107,7 +107,7 @@ func GroupMemberOpenIMCopyDB(dst *db.GroupMember, src *open_im_sdk.GroupMemberFu
 
 func GroupMemberDBCopyOpenIM(dst *open_im_sdk.GroupMemberFullInfo, src *db.GroupMember) error {
 	utils.CopyStructFields(dst, src)
-	if token_verify.IsMangerUserID(src.UserID) {
+	if token_verify.IsManagerUserID(src.UserID) {
 		u, err := imdb.GetUserByUserID(src.UserID)
 		if err != nil {
 			return utils.Wrap(err, "")
@@ -154,8 +154,3 @@ func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src *db.User) {
 func UserDBCopyOpenIMPublicUser(dst *open_im_sdk.PublicUserInfo, src *db.User) {
 	utils.CopyStructFields(dst, src)
 }
-
-//
-//func PublicUserDBCopyOpenIM(dst *open_im_sdk.PublicUserInfo, src *db.User){
-//
-//}

pkg/grpc-etcdv3/getcdv3/resolver.go

@@ -1,6 +1,7 @@
 package getcdv3
 
 import (
+	"Open_IM/pkg/common/log"
 	"context"
 	"fmt"
 	"go.etcd.io/etcd/clientv3"
@@ -43,13 +44,19 @@ func NewResolver(schema, etcdAddr, serviceName string) (*Resolver, error) {
 	r.schema = schema
 	r.etcdAddr = etcdAddr
 	resolver.Register(&r)
-
-	conn, err := grpc.Dial(
-		GetPrefix(schema, serviceName),
+	//
+	ctx, _ := context.WithTimeout(context.Background(), time.Second*5)
+	conn, err := grpc.DialContext(ctx, GetPrefix(schema, serviceName),
 		grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, roundrobin.Name)),
-		grpc.WithInsecure(),
-		grpc.WithTimeout(time.Duration(5)*time.Second),
-	)
+		grpc.WithInsecure())
+	log.Debug("", "etcd key ", GetPrefix(schema, serviceName))
+
+	//conn, err := grpc.Dial(
+	//	GetPrefix(schema, serviceName),
+	//	grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, roundrobin.Name)),
+	//	grpc.WithInsecure(),
+	//	grpc.WithTimeout(time.Duration(5)*time.Second),
+	//)
 	if err == nil {
 		r.grpcClientConn = conn
 	}
@@ -67,6 +74,7 @@ func GetConn(schema, etcdaddr, serviceName string) *grpc.ClientConn {
 	r, ok := nameResolver[schema+serviceName]
 	rwNameResolverMutex.RUnlock()
 	if ok {
+		log.Debug("", "etcd key ", schema+serviceName, "value ", *r.grpcClientConn, *r)
 		return r.grpcClientConn
 	}
 
@@ -74,15 +82,18 @@ func GetConn(schema, etcdaddr, serviceName string) *grpc.ClientConn {
 	r, ok = nameResolver[schema+serviceName]
 	if ok {
 		rwNameResolverMutex.Unlock()
+		log.Debug("", "etcd key ", schema+serviceName, "value ", *r.grpcClientConn, *r)
 		return r.grpcClientConn
 	}
 
 	r, err := NewResolver(schema, etcdaddr, serviceName)
 	if err != nil {
+		log.Error("", "etcd failed ", schema, etcdaddr, serviceName)
 		rwNameResolverMutex.Unlock()
 		return nil
 	}
 
+	log.Debug("", "etcd key ", schema+serviceName, "value ", *r.grpcClientConn, *r)
 	nameResolver[schema+serviceName] = r
 	rwNameResolverMutex.Unlock()
 	return r.grpcClientConn
@@ -93,7 +104,7 @@ func (r *Resolver) Build(target resolver.Target, cc resolver.ClientConn, opts re
 		return nil, fmt.Errorf("etcd clientv3 client failed, etcd:%s", target)
 	}
 	r.cc = cc
-
+	log.Debug("", "Build..")
 	ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
 	//     "%s:///%s"
 	prefix := GetPrefix(r.schema, r.serviceName)
@@ -102,7 +113,7 @@ func (r *Resolver) Build(target resolver.Target, cc resolver.ClientConn, opts re
 	if err == nil {
 		var addrList []resolver.Address
 		for i := range resp.Kvs {
-			//log.Debug("", "init addr: ", string(resp.Kvs[i].Value))
+			log.Debug("", "etcd init addr: ", string(resp.Kvs[i].Value))
 			addrList = append(addrList, resolver.Address{Addr: string(resp.Kvs[i].Value)})
 		}
 		r.cc.UpdateState(resolver.State{Addresses: addrList})
@@ -148,27 +159,27 @@ func (r *Resolver) watch(prefix string, addrList []resolver.Address) {
 				if !exists(addrList, string(ev.Kv.Value)) {
 					flag = 1
 					addrList = append(addrList, resolver.Address{Addr: string(ev.Kv.Value)})
-					//log.Debug("", "after add, new list: ", addrList)
+					log.Debug("", "after add, new list: ", addrList)
 				}
 			case mvccpb.DELETE:
-				//log.Debug("remove addr key: ", string(ev.Kv.Key), "value:", string(ev.Kv.Value))
+				log.Debug("remove addr key: ", string(ev.Kv.Key), "value:", string(ev.Kv.Value))
 				i := strings.LastIndexAny(string(ev.Kv.Key), "/")
 				if i < 0 {
 					return
 				}
 				t := string(ev.Kv.Key)[i+1:]
-				//log.Debug("remove addr key: ", string(ev.Kv.Key), "value:", string(ev.Kv.Value), "addr:", t)
+				log.Debug("remove addr key: ", string(ev.Kv.Key), "value:", string(ev.Kv.Value), "addr:", t)
 				if s, ok := remove(addrList, t); ok {
 					flag = 1
 					addrList = s
-					//log.Debug("after remove, new list: ", addrList)
+					log.Debug("after remove, new list: ", addrList)
 				}
 			}
 		}
 
 		if flag == 1 {
 			r.cc.UpdateState(resolver.State{Addresses: addrList})
-			//log.Debug("update: ", addrList)
+			log.Debug("update: ", addrList)
 		}
 	}
 }
@@ -176,7 +187,7 @@ func (r *Resolver) watch(prefix string, addrList []resolver.Address) {
 func GetConn4Unique(schema, etcdaddr, servicename string) []*grpc.ClientConn {
 	gEtcdCli, err := clientv3.New(clientv3.Config{Endpoints: strings.Split(etcdaddr, ",")})
 	if err != nil {
-		//log.Error("clientv3.New failed", err.Error())
+		log.Error("clientv3.New failed", err.Error())
 		return nil
 	}
 

pkg/proto/cache/cache.proto

@@ -0,0 +1,142 @@
+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 GetUserInfoFromCacheReq{
+  repeated string userIDList = 1;
+  string operationID = 2;
+}
+
+message GetUserInfoFromCacheResp{
+  CommonResp  commonResp = 1;
+  repeated server_api_params.UserInfo userInfoList = 2;
+}
+
+
+message UpdateUserInfoToCacheReq{
+  repeated server_api_params.UserInfo userInfoList = 1;
+  string operationID = 2;
+}
+
+message UpdateUserInfoToCacheResp{
+  CommonResp commonResp = 1;
+}
+
+message GetFriendIDListFromCacheReq {
+  string userID = 1;
+  string operationID = 2;
+}
+
+message GetFriendIDListFromCacheResp {
+  repeated string userIDList = 1;
+  CommonResp commonResp = 2;
+}
+
+message AddFriendToCacheReq {
+   string userID = 1;
+   string friendID = 2;
+   string operationID = 3;
+}
+
+message AddFriendToCacheResp {
+  CommonResp commonResp = 1;
+}
+
+message ReduceFriendFromCacheReq {
+   string userID = 1;
+   string friendID = 2;
+   string operationID = 3;
+}
+
+message ReduceFriendFromCacheResp {
+  CommonResp commonResp = 1;
+}
+
+message GetBlackIDListFromCacheReq {
+  string userID = 1;
+  string operationID = 2;
+}
+
+message GetBlackIDListFromCacheResp {
+  repeated string userIDList = 1;
+  CommonResp commonResp = 2;
+}
+
+message AddBlackUserToCacheReq {
+  string userID = 1;
+  string blackUserID = 2;
+  string operationID = 3;
+}
+
+message AddBlackUserToCacheResp {
+  CommonResp commonResp = 1;
+}
+
+message ReduceBlackUserFromCacheReq {
+  string userID = 1;
+  string blackUserID = 2;
+  string operationID = 3;
+}
+
+message ReduceBlackUserFromCacheResp {
+  CommonResp commonResp = 1;
+}
+
+message GetGroupMemberIDListFromCacheReq {
+  string operationID = 1;
+  string groupID = 2;
+}
+
+message GetGroupMemberIDListFromCacheResp {
+  CommonResp commonResp = 1;
+  repeated string userIDList = 2;
+}
+
+message AddGroupMemberToCacheReq {
+  repeated string userIDList = 1;
+  string groupID = 2;
+  string operationID = 3;
+}
+
+message AddGroupMemberToCacheResp {
+  CommonResp commonResp = 1;
+}
+
+message ReduceGroupMemberFromCacheReq {
+  repeated string userIDList = 1;
+  string groupID = 2;
+  string operationID = 3;
+}
+
+message ReduceGroupMemberFromCacheResp {
+  CommonResp commonResp = 1;
+}
+
+service cache{
+  // userInfo
+  rpc GetUserInfoFromCache(GetUserInfoFromCacheReq) returns(GetUserInfoFromCacheResp);
+  rpc UpdateUserInfoToCache(UpdateUserInfoToCacheReq) returns(UpdateUserInfoToCacheResp);
+
+  // friendInfo
+  rpc GetFriendIDListFromCache(GetFriendIDListFromCacheReq) returns(GetFriendIDListFromCacheResp);
+  rpc AddFriendToCache(AddFriendToCacheReq) returns(AddFriendToCacheResp);
+  rpc ReduceFriendFromCache(ReduceFriendFromCacheReq) returns(ReduceFriendFromCacheResp);
+
+  // blackList
+  rpc GetBlackIDListFromCache(GetBlackIDListFromCacheReq) returns(GetBlackIDListFromCacheResp);
+  rpc AddBlackUserToCache(AddBlackUserToCacheReq) returns(AddBlackUserToCacheResp);
+  rpc ReduceBlackUserFromCache(ReduceBlackUserFromCacheReq) returns(ReduceBlackUserFromCacheResp);
+
+  // group
+  rpc GetGroupMemberIDListFromCache(GetGroupMemberIDListFromCacheReq) returns(GetGroupMemberIDListFromCacheResp);
+  rpc AddGroupMemberToCache(AddGroupMemberToCacheReq) returns(AddGroupMemberToCacheResp);
+  rpc ReduceGroupMemberFromCache(ReduceGroupMemberFromCacheReq) returns(ReduceGroupMemberFromCacheResp);
+}
+
+

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

@@ -0,0 +1,38 @@
+syntax = "proto3";
+option go_package = "./conversation;conversation";
+package conversation;
+
+message CommonResp{
+  int32  errCode = 1;
+  string errMsg = 2;
+}
+message Conversation{
+  string ownerUserID = 1;
+  string conversationID = 2;
+  int32 recvMsgOpt = 3;
+  int32 conversationType = 4;
+  string userID = 5;
+  string groupID = 6;
+  int32 unreadCount = 7;
+  int64 draftTextTime = 8;
+  bool isPinned = 9;
+  string attachedInfo = 10;
+  bool isPrivateChat = 11;
+  int32 groupAtType = 12;
+  bool isNotInGroup = 13;
+  string ex = 14;
+}
+message ModifyConversationFieldReq{
+  Conversation conversation = 1;
+  int32 fieldType = 2;
+  repeated string userIDList = 3;
+  string operationID = 4;
+}
+
+message ModifyConversationFieldResp{
+  CommonResp  commonResp = 1;
+}
+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/group/group.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_group_3c77315b028a1402, []int{0}
+	return fileDescriptor_group_95c16320d90511af, []int{0}
 }
 func (m *CommonResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@@ -82,7 +82,7 @@ func (m *GroupAddMemberInfo) Reset()         { *m = GroupAddMemberInfo{} }
 func (m *GroupAddMemberInfo) String() string { return proto.CompactTextString(m) }
 func (*GroupAddMemberInfo) ProtoMessage()    {}
 func (*GroupAddMemberInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{1}
+	return fileDescriptor_group_95c16320d90511af, []int{1}
 }
 func (m *GroupAddMemberInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupAddMemberInfo.Unmarshal(m, b)
@@ -131,7 +131,7 @@ func (m *CreateGroupReq) Reset()         { *m = CreateGroupReq{} }
 func (m *CreateGroupReq) String() string { return proto.CompactTextString(m) }
 func (*CreateGroupReq) ProtoMessage()    {}
 func (*CreateGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{2}
+	return fileDescriptor_group_95c16320d90511af, []int{2}
 }
 func (m *CreateGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateGroupReq.Unmarshal(m, b)
@@ -199,7 +199,7 @@ func (m *CreateGroupResp) Reset()         { *m = CreateGroupResp{} }
 func (m *CreateGroupResp) String() string { return proto.CompactTextString(m) }
 func (*CreateGroupResp) ProtoMessage()    {}
 func (*CreateGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{3}
+	return fileDescriptor_group_95c16320d90511af, []int{3}
 }
 func (m *CreateGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateGroupResp.Unmarshal(m, b)
@@ -253,7 +253,7 @@ func (m *GetGroupsInfoReq) Reset()         { *m = GetGroupsInfoReq{} }
 func (m *GetGroupsInfoReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupsInfoReq) ProtoMessage()    {}
 func (*GetGroupsInfoReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{4}
+	return fileDescriptor_group_95c16320d90511af, []int{4}
 }
 func (m *GetGroupsInfoReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupsInfoReq.Unmarshal(m, b)
@@ -307,7 +307,7 @@ func (m *GetGroupsInfoResp) Reset()         { *m = GetGroupsInfoResp{} }
 func (m *GetGroupsInfoResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupsInfoResp) ProtoMessage()    {}
 func (*GetGroupsInfoResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{5}
+	return fileDescriptor_group_95c16320d90511af, []int{5}
 }
 func (m *GetGroupsInfoResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupsInfoResp.Unmarshal(m, b)
@@ -361,7 +361,7 @@ func (m *SetGroupInfoReq) Reset()         { *m = SetGroupInfoReq{} }
 func (m *SetGroupInfoReq) String() string { return proto.CompactTextString(m) }
 func (*SetGroupInfoReq) ProtoMessage()    {}
 func (*SetGroupInfoReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{6}
+	return fileDescriptor_group_95c16320d90511af, []int{6}
 }
 func (m *SetGroupInfoReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetGroupInfoReq.Unmarshal(m, b)
@@ -413,7 +413,7 @@ func (m *SetGroupInfoResp) Reset()         { *m = SetGroupInfoResp{} }
 func (m *SetGroupInfoResp) String() string { return proto.CompactTextString(m) }
 func (*SetGroupInfoResp) ProtoMessage()    {}
 func (*SetGroupInfoResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{7}
+	return fileDescriptor_group_95c16320d90511af, []int{7}
 }
 func (m *SetGroupInfoResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetGroupInfoResp.Unmarshal(m, b)
@@ -453,7 +453,7 @@ func (m *GetGroupApplicationListReq) Reset()         { *m = GetGroupApplicationL
 func (m *GetGroupApplicationListReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupApplicationListReq) ProtoMessage()    {}
 func (*GetGroupApplicationListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{8}
+	return fileDescriptor_group_95c16320d90511af, []int{8}
 }
 func (m *GetGroupApplicationListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupApplicationListReq.Unmarshal(m, b)
@@ -507,7 +507,7 @@ func (m *GetGroupApplicationListResp) Reset()         { *m = GetGroupApplication
 func (m *GetGroupApplicationListResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupApplicationListResp) ProtoMessage()    {}
 func (*GetGroupApplicationListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{9}
+	return fileDescriptor_group_95c16320d90511af, []int{9}
 }
 func (m *GetGroupApplicationListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupApplicationListResp.Unmarshal(m, b)
@@ -561,7 +561,7 @@ func (m *GetUserReqApplicationListReq) Reset()         { *m = GetUserReqApplicat
 func (m *GetUserReqApplicationListReq) String() string { return proto.CompactTextString(m) }
 func (*GetUserReqApplicationListReq) ProtoMessage()    {}
 func (*GetUserReqApplicationListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{10}
+	return fileDescriptor_group_95c16320d90511af, []int{10}
 }
 func (m *GetUserReqApplicationListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserReqApplicationListReq.Unmarshal(m, b)
@@ -614,7 +614,7 @@ func (m *GetUserReqApplicationListResp) Reset()         { *m = GetUserReqApplica
 func (m *GetUserReqApplicationListResp) String() string { return proto.CompactTextString(m) }
 func (*GetUserReqApplicationListResp) ProtoMessage()    {}
 func (*GetUserReqApplicationListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{11}
+	return fileDescriptor_group_95c16320d90511af, []int{11}
 }
 func (m *GetUserReqApplicationListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserReqApplicationListResp.Unmarshal(m, b)
@@ -663,7 +663,7 @@ func (m *TransferGroupOwnerReq) Reset()         { *m = TransferGroupOwnerReq{} }
 func (m *TransferGroupOwnerReq) String() string { return proto.CompactTextString(m) }
 func (*TransferGroupOwnerReq) ProtoMessage()    {}
 func (*TransferGroupOwnerReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{12}
+	return fileDescriptor_group_95c16320d90511af, []int{12}
 }
 func (m *TransferGroupOwnerReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TransferGroupOwnerReq.Unmarshal(m, b)
@@ -729,7 +729,7 @@ func (m *TransferGroupOwnerResp) Reset()         { *m = TransferGroupOwnerResp{}
 func (m *TransferGroupOwnerResp) String() string { return proto.CompactTextString(m) }
 func (*TransferGroupOwnerResp) ProtoMessage()    {}
 func (*TransferGroupOwnerResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{13}
+	return fileDescriptor_group_95c16320d90511af, []int{13}
 }
 func (m *TransferGroupOwnerResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TransferGroupOwnerResp.Unmarshal(m, b)
@@ -770,7 +770,7 @@ func (m *JoinGroupReq) Reset()         { *m = JoinGroupReq{} }
 func (m *JoinGroupReq) String() string { return proto.CompactTextString(m) }
 func (*JoinGroupReq) ProtoMessage()    {}
 func (*JoinGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{14}
+	return fileDescriptor_group_95c16320d90511af, []int{14}
 }
 func (m *JoinGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_JoinGroupReq.Unmarshal(m, b)
@@ -829,7 +829,7 @@ func (m *JoinGroupResp) Reset()         { *m = JoinGroupResp{} }
 func (m *JoinGroupResp) String() string { return proto.CompactTextString(m) }
 func (*JoinGroupResp) ProtoMessage()    {}
 func (*JoinGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{15}
+	return fileDescriptor_group_95c16320d90511af, []int{15}
 }
 func (m *JoinGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_JoinGroupResp.Unmarshal(m, b)
@@ -872,7 +872,7 @@ func (m *GroupApplicationResponseReq) Reset()         { *m = GroupApplicationRes
 func (m *GroupApplicationResponseReq) String() string { return proto.CompactTextString(m) }
 func (*GroupApplicationResponseReq) ProtoMessage()    {}
 func (*GroupApplicationResponseReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{16}
+	return fileDescriptor_group_95c16320d90511af, []int{16}
 }
 func (m *GroupApplicationResponseReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupApplicationResponseReq.Unmarshal(m, b)
@@ -945,7 +945,7 @@ func (m *GroupApplicationResponseResp) Reset()         { *m = GroupApplicationRe
 func (m *GroupApplicationResponseResp) String() string { return proto.CompactTextString(m) }
 func (*GroupApplicationResponseResp) ProtoMessage()    {}
 func (*GroupApplicationResponseResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{17}
+	return fileDescriptor_group_95c16320d90511af, []int{17}
 }
 func (m *GroupApplicationResponseResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupApplicationResponseResp.Unmarshal(m, b)
@@ -985,7 +985,7 @@ func (m *QuitGroupReq) Reset()         { *m = QuitGroupReq{} }
 func (m *QuitGroupReq) String() string { return proto.CompactTextString(m) }
 func (*QuitGroupReq) ProtoMessage()    {}
 func (*QuitGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{18}
+	return fileDescriptor_group_95c16320d90511af, []int{18}
 }
 func (m *QuitGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_QuitGroupReq.Unmarshal(m, b)
@@ -1037,7 +1037,7 @@ func (m *QuitGroupResp) Reset()         { *m = QuitGroupResp{} }
 func (m *QuitGroupResp) String() string { return proto.CompactTextString(m) }
 func (*QuitGroupResp) ProtoMessage()    {}
 func (*QuitGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{19}
+	return fileDescriptor_group_95c16320d90511af, []int{19}
 }
 func (m *QuitGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_QuitGroupResp.Unmarshal(m, b)
@@ -1079,7 +1079,7 @@ func (m *GetGroupMemberListReq) Reset()         { *m = GetGroupMemberListReq{} }
 func (m *GetGroupMemberListReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMemberListReq) ProtoMessage()    {}
 func (*GetGroupMemberListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{20}
+	return fileDescriptor_group_95c16320d90511af, []int{20}
 }
 func (m *GetGroupMemberListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMemberListReq.Unmarshal(m, b)
@@ -1148,7 +1148,7 @@ func (m *GetGroupMemberListResp) Reset()         { *m = GetGroupMemberListResp{}
 func (m *GetGroupMemberListResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMemberListResp) ProtoMessage()    {}
 func (*GetGroupMemberListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{21}
+	return fileDescriptor_group_95c16320d90511af, []int{21}
 }
 func (m *GetGroupMemberListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMemberListResp.Unmarshal(m, b)
@@ -1210,7 +1210,7 @@ func (m *GetGroupMembersInfoReq) Reset()         { *m = GetGroupMembersInfoReq{}
 func (m *GetGroupMembersInfoReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMembersInfoReq) ProtoMessage()    {}
 func (*GetGroupMembersInfoReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{22}
+	return fileDescriptor_group_95c16320d90511af, []int{22}
 }
 func (m *GetGroupMembersInfoReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMembersInfoReq.Unmarshal(m, b)
@@ -1271,7 +1271,7 @@ func (m *GetGroupMembersInfoResp) Reset()         { *m = GetGroupMembersInfoResp
 func (m *GetGroupMembersInfoResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMembersInfoResp) ProtoMessage()    {}
 func (*GetGroupMembersInfoResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{23}
+	return fileDescriptor_group_95c16320d90511af, []int{23}
 }
 func (m *GetGroupMembersInfoResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMembersInfoResp.Unmarshal(m, b)
@@ -1327,7 +1327,7 @@ func (m *KickGroupMemberReq) Reset()         { *m = KickGroupMemberReq{} }
 func (m *KickGroupMemberReq) String() string { return proto.CompactTextString(m) }
 func (*KickGroupMemberReq) ProtoMessage()    {}
 func (*KickGroupMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{24}
+	return fileDescriptor_group_95c16320d90511af, []int{24}
 }
 func (m *KickGroupMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_KickGroupMemberReq.Unmarshal(m, b)
@@ -1394,7 +1394,7 @@ func (m *Id2Result) Reset()         { *m = Id2Result{} }
 func (m *Id2Result) String() string { return proto.CompactTextString(m) }
 func (*Id2Result) ProtoMessage()    {}
 func (*Id2Result) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{25}
+	return fileDescriptor_group_95c16320d90511af, []int{25}
 }
 func (m *Id2Result) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Id2Result.Unmarshal(m, b)
@@ -1441,7 +1441,7 @@ func (m *KickGroupMemberResp) Reset()         { *m = KickGroupMemberResp{} }
 func (m *KickGroupMemberResp) String() string { return proto.CompactTextString(m) }
 func (*KickGroupMemberResp) ProtoMessage()    {}
 func (*KickGroupMemberResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{26}
+	return fileDescriptor_group_95c16320d90511af, []int{26}
 }
 func (m *KickGroupMemberResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_KickGroupMemberResp.Unmarshal(m, b)
@@ -1495,7 +1495,7 @@ func (m *GetJoinedGroupListReq) Reset()         { *m = GetJoinedGroupListReq{} }
 func (m *GetJoinedGroupListReq) String() string { return proto.CompactTextString(m) }
 func (*GetJoinedGroupListReq) ProtoMessage()    {}
 func (*GetJoinedGroupListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{27}
+	return fileDescriptor_group_95c16320d90511af, []int{27}
 }
 func (m *GetJoinedGroupListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetJoinedGroupListReq.Unmarshal(m, b)
@@ -1549,7 +1549,7 @@ func (m *GetJoinedGroupListResp) Reset()         { *m = GetJoinedGroupListResp{}
 func (m *GetJoinedGroupListResp) String() string { return proto.CompactTextString(m) }
 func (*GetJoinedGroupListResp) ProtoMessage()    {}
 func (*GetJoinedGroupListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{28}
+	return fileDescriptor_group_95c16320d90511af, []int{28}
 }
 func (m *GetJoinedGroupListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetJoinedGroupListResp.Unmarshal(m, b)
@@ -1605,7 +1605,7 @@ func (m *InviteUserToGroupReq) Reset()         { *m = InviteUserToGroupReq{} }
 func (m *InviteUserToGroupReq) String() string { return proto.CompactTextString(m) }
 func (*InviteUserToGroupReq) ProtoMessage()    {}
 func (*InviteUserToGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{29}
+	return fileDescriptor_group_95c16320d90511af, []int{29}
 }
 func (m *InviteUserToGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InviteUserToGroupReq.Unmarshal(m, b)
@@ -1673,7 +1673,7 @@ func (m *InviteUserToGroupResp) Reset()         { *m = InviteUserToGroupResp{} }
 func (m *InviteUserToGroupResp) String() string { return proto.CompactTextString(m) }
 func (*InviteUserToGroupResp) ProtoMessage()    {}
 func (*InviteUserToGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{30}
+	return fileDescriptor_group_95c16320d90511af, []int{30}
 }
 func (m *InviteUserToGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InviteUserToGroupResp.Unmarshal(m, b)
@@ -1727,7 +1727,7 @@ func (m *GetGroupAllMemberReq) Reset()         { *m = GetGroupAllMemberReq{} }
 func (m *GetGroupAllMemberReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupAllMemberReq) ProtoMessage()    {}
 func (*GetGroupAllMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{31}
+	return fileDescriptor_group_95c16320d90511af, []int{31}
 }
 func (m *GetGroupAllMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupAllMemberReq.Unmarshal(m, b)
@@ -1781,7 +1781,7 @@ func (m *GetGroupAllMemberResp) Reset()         { *m = GetGroupAllMemberResp{} }
 func (m *GetGroupAllMemberResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupAllMemberResp) ProtoMessage()    {}
 func (*GetGroupAllMemberResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{32}
+	return fileDescriptor_group_95c16320d90511af, []int{32}
 }
 func (m *GetGroupAllMemberResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupAllMemberResp.Unmarshal(m, b)
@@ -1835,7 +1835,7 @@ func (m *CMSGroup) Reset()         { *m = CMSGroup{} }
 func (m *CMSGroup) String() string { return proto.CompactTextString(m) }
 func (*CMSGroup) ProtoMessage()    {}
 func (*CMSGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{33}
+	return fileDescriptor_group_95c16320d90511af, []int{33}
 }
 func (m *CMSGroup) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CMSGroup.Unmarshal(m, b)
@@ -1889,7 +1889,7 @@ func (m *GetGroupReq) Reset()         { *m = GetGroupReq{} }
 func (m *GetGroupReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupReq) ProtoMessage()    {}
 func (*GetGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{34}
+	return fileDescriptor_group_95c16320d90511af, []int{34}
 }
 func (m *GetGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupReq.Unmarshal(m, b)
@@ -1943,7 +1943,7 @@ func (m *GetGroupResp) Reset()         { *m = GetGroupResp{} }
 func (m *GetGroupResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupResp) ProtoMessage()    {}
 func (*GetGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{35}
+	return fileDescriptor_group_95c16320d90511af, []int{35}
 }
 func (m *GetGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupResp.Unmarshal(m, b)
@@ -1996,7 +1996,7 @@ func (m *GetGroupsReq) Reset()         { *m = GetGroupsReq{} }
 func (m *GetGroupsReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupsReq) ProtoMessage()    {}
 func (*GetGroupsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{36}
+	return fileDescriptor_group_95c16320d90511af, []int{36}
 }
 func (m *GetGroupsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupsReq.Unmarshal(m, b)
@@ -2043,7 +2043,7 @@ func (m *GetGroupsResp) Reset()         { *m = GetGroupsResp{} }
 func (m *GetGroupsResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupsResp) ProtoMessage()    {}
 func (*GetGroupsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{37}
+	return fileDescriptor_group_95c16320d90511af, []int{37}
 }
 func (m *GetGroupsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupsResp.Unmarshal(m, b)
@@ -2096,7 +2096,7 @@ func (m *GetGroupMemberReq) Reset()         { *m = GetGroupMemberReq{} }
 func (m *GetGroupMemberReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMemberReq) ProtoMessage()    {}
 func (*GetGroupMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{38}
+	return fileDescriptor_group_95c16320d90511af, []int{38}
 }
 func (m *GetGroupMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMemberReq.Unmarshal(m, b)
@@ -2143,7 +2143,7 @@ func (m *OperateGroupStatusReq) Reset()         { *m = OperateGroupStatusReq{} }
 func (m *OperateGroupStatusReq) String() string { return proto.CompactTextString(m) }
 func (*OperateGroupStatusReq) ProtoMessage()    {}
 func (*OperateGroupStatusReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{39}
+	return fileDescriptor_group_95c16320d90511af, []int{39}
 }
 func (m *OperateGroupStatusReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperateGroupStatusReq.Unmarshal(m, b)
@@ -2194,7 +2194,7 @@ func (m *OperateGroupStatusResp) Reset()         { *m = OperateGroupStatusResp{}
 func (m *OperateGroupStatusResp) String() string { return proto.CompactTextString(m) }
 func (*OperateGroupStatusResp) ProtoMessage()    {}
 func (*OperateGroupStatusResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{40}
+	return fileDescriptor_group_95c16320d90511af, []int{40}
 }
 func (m *OperateGroupStatusResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperateGroupStatusResp.Unmarshal(m, b)
@@ -2228,7 +2228,7 @@ func (m *OperateUserRoleReq) Reset()         { *m = OperateUserRoleReq{} }
 func (m *OperateUserRoleReq) String() string { return proto.CompactTextString(m) }
 func (*OperateUserRoleReq) ProtoMessage()    {}
 func (*OperateUserRoleReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{41}
+	return fileDescriptor_group_95c16320d90511af, []int{41}
 }
 func (m *OperateUserRoleReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperateUserRoleReq.Unmarshal(m, b)
@@ -2286,7 +2286,7 @@ func (m *OperateUserRoleResp) Reset()         { *m = OperateUserRoleResp{} }
 func (m *OperateUserRoleResp) String() string { return proto.CompactTextString(m) }
 func (*OperateUserRoleResp) ProtoMessage()    {}
 func (*OperateUserRoleResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{42}
+	return fileDescriptor_group_95c16320d90511af, []int{42}
 }
 func (m *OperateUserRoleResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperateUserRoleResp.Unmarshal(m, b)
@@ -2318,7 +2318,7 @@ func (m *DeleteGroupReq) Reset()         { *m = DeleteGroupReq{} }
 func (m *DeleteGroupReq) String() string { return proto.CompactTextString(m) }
 func (*DeleteGroupReq) ProtoMessage()    {}
 func (*DeleteGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{43}
+	return fileDescriptor_group_95c16320d90511af, []int{43}
 }
 func (m *DeleteGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteGroupReq.Unmarshal(m, b)
@@ -2362,7 +2362,7 @@ func (m *DeleteGroupResp) Reset()         { *m = DeleteGroupResp{} }
 func (m *DeleteGroupResp) String() string { return proto.CompactTextString(m) }
 func (*DeleteGroupResp) ProtoMessage()    {}
 func (*DeleteGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{44}
+	return fileDescriptor_group_95c16320d90511af, []int{44}
 }
 func (m *DeleteGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteGroupResp.Unmarshal(m, b)
@@ -2394,7 +2394,7 @@ func (m *GetGroupByIdReq) Reset()         { *m = GetGroupByIdReq{} }
 func (m *GetGroupByIdReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupByIdReq) ProtoMessage()    {}
 func (*GetGroupByIdReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{45}
+	return fileDescriptor_group_95c16320d90511af, []int{45}
 }
 func (m *GetGroupByIdReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupByIdReq.Unmarshal(m, b)
@@ -2439,7 +2439,7 @@ func (m *GetGroupByIdResp) Reset()         { *m = GetGroupByIdResp{} }
 func (m *GetGroupByIdResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupByIdResp) ProtoMessage()    {}
 func (*GetGroupByIdResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{46}
+	return fileDescriptor_group_95c16320d90511af, []int{46}
 }
 func (m *GetGroupByIdResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupByIdResp.Unmarshal(m, b)
@@ -2480,7 +2480,7 @@ func (m *GetGroupMembersCMSReq) Reset()         { *m = GetGroupMembersCMSReq{} }
 func (m *GetGroupMembersCMSReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMembersCMSReq) ProtoMessage()    {}
 func (*GetGroupMembersCMSReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{47}
+	return fileDescriptor_group_95c16320d90511af, []int{47}
 }
 func (m *GetGroupMembersCMSReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMembersCMSReq.Unmarshal(m, b)
@@ -2541,7 +2541,7 @@ func (m *GetGroupMembersCMSResp) Reset()         { *m = GetGroupMembersCMSResp{}
 func (m *GetGroupMembersCMSResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMembersCMSResp) ProtoMessage()    {}
 func (*GetGroupMembersCMSResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{48}
+	return fileDescriptor_group_95c16320d90511af, []int{48}
 }
 func (m *GetGroupMembersCMSResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMembersCMSResp.Unmarshal(m, b)
@@ -2596,7 +2596,7 @@ func (m *RemoveGroupMembersCMSReq) Reset()         { *m = RemoveGroupMembersCMSR
 func (m *RemoveGroupMembersCMSReq) String() string { return proto.CompactTextString(m) }
 func (*RemoveGroupMembersCMSReq) ProtoMessage()    {}
 func (*RemoveGroupMembersCMSReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{49}
+	return fileDescriptor_group_95c16320d90511af, []int{49}
 }
 func (m *RemoveGroupMembersCMSReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RemoveGroupMembersCMSReq.Unmarshal(m, b)
@@ -2656,7 +2656,7 @@ func (m *RemoveGroupMembersCMSResp) Reset()         { *m = RemoveGroupMembersCMS
 func (m *RemoveGroupMembersCMSResp) String() string { return proto.CompactTextString(m) }
 func (*RemoveGroupMembersCMSResp) ProtoMessage()    {}
 func (*RemoveGroupMembersCMSResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{50}
+	return fileDescriptor_group_95c16320d90511af, []int{50}
 }
 func (m *RemoveGroupMembersCMSResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RemoveGroupMembersCMSResp.Unmarshal(m, b)
@@ -2704,7 +2704,7 @@ func (m *AddGroupMembersCMSReq) Reset()         { *m = AddGroupMembersCMSReq{} }
 func (m *AddGroupMembersCMSReq) String() string { return proto.CompactTextString(m) }
 func (*AddGroupMembersCMSReq) ProtoMessage()    {}
 func (*AddGroupMembersCMSReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{51}
+	return fileDescriptor_group_95c16320d90511af, []int{51}
 }
 func (m *AddGroupMembersCMSReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddGroupMembersCMSReq.Unmarshal(m, b)
@@ -2764,7 +2764,7 @@ func (m *AddGroupMembersCMSResp) Reset()         { *m = AddGroupMembersCMSResp{}
 func (m *AddGroupMembersCMSResp) String() string { return proto.CompactTextString(m) }
 func (*AddGroupMembersCMSResp) ProtoMessage()    {}
 func (*AddGroupMembersCMSResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{52}
+	return fileDescriptor_group_95c16320d90511af, []int{52}
 }
 func (m *AddGroupMembersCMSResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddGroupMembersCMSResp.Unmarshal(m, b)
@@ -2811,7 +2811,7 @@ func (m *DismissGroupReq) Reset()         { *m = DismissGroupReq{} }
 func (m *DismissGroupReq) String() string { return proto.CompactTextString(m) }
 func (*DismissGroupReq) ProtoMessage()    {}
 func (*DismissGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{53}
+	return fileDescriptor_group_95c16320d90511af, []int{53}
 }
 func (m *DismissGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DismissGroupReq.Unmarshal(m, b)
@@ -2863,7 +2863,7 @@ func (m *DismissGroupResp) Reset()         { *m = DismissGroupResp{} }
 func (m *DismissGroupResp) String() string { return proto.CompactTextString(m) }
 func (*DismissGroupResp) ProtoMessage()    {}
 func (*DismissGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{54}
+	return fileDescriptor_group_95c16320d90511af, []int{54}
 }
 func (m *DismissGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DismissGroupResp.Unmarshal(m, b)
@@ -2905,7 +2905,7 @@ func (m *MuteGroupMemberReq) Reset()         { *m = MuteGroupMemberReq{} }
 func (m *MuteGroupMemberReq) String() string { return proto.CompactTextString(m) }
 func (*MuteGroupMemberReq) ProtoMessage()    {}
 func (*MuteGroupMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{55}
+	return fileDescriptor_group_95c16320d90511af, []int{55}
 }
 func (m *MuteGroupMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MuteGroupMemberReq.Unmarshal(m, b)
@@ -2971,7 +2971,7 @@ func (m *MuteGroupMemberResp) Reset()         { *m = MuteGroupMemberResp{} }
 func (m *MuteGroupMemberResp) String() string { return proto.CompactTextString(m) }
 func (*MuteGroupMemberResp) ProtoMessage()    {}
 func (*MuteGroupMemberResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{56}
+	return fileDescriptor_group_95c16320d90511af, []int{56}
 }
 func (m *MuteGroupMemberResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MuteGroupMemberResp.Unmarshal(m, b)
@@ -3012,7 +3012,7 @@ func (m *CancelMuteGroupMemberReq) Reset()         { *m = CancelMuteGroupMemberR
 func (m *CancelMuteGroupMemberReq) String() string { return proto.CompactTextString(m) }
 func (*CancelMuteGroupMemberReq) ProtoMessage()    {}
 func (*CancelMuteGroupMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{57}
+	return fileDescriptor_group_95c16320d90511af, []int{57}
 }
 func (m *CancelMuteGroupMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CancelMuteGroupMemberReq.Unmarshal(m, b)
@@ -3071,7 +3071,7 @@ func (m *CancelMuteGroupMemberResp) Reset()         { *m = CancelMuteGroupMember
 func (m *CancelMuteGroupMemberResp) String() string { return proto.CompactTextString(m) }
 func (*CancelMuteGroupMemberResp) ProtoMessage()    {}
 func (*CancelMuteGroupMemberResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{58}
+	return fileDescriptor_group_95c16320d90511af, []int{58}
 }
 func (m *CancelMuteGroupMemberResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CancelMuteGroupMemberResp.Unmarshal(m, b)
@@ -3111,7 +3111,7 @@ func (m *MuteGroupReq) Reset()         { *m = MuteGroupReq{} }
 func (m *MuteGroupReq) String() string { return proto.CompactTextString(m) }
 func (*MuteGroupReq) ProtoMessage()    {}
 func (*MuteGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{59}
+	return fileDescriptor_group_95c16320d90511af, []int{59}
 }
 func (m *MuteGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MuteGroupReq.Unmarshal(m, b)
@@ -3163,7 +3163,7 @@ func (m *MuteGroupResp) Reset()         { *m = MuteGroupResp{} }
 func (m *MuteGroupResp) String() string { return proto.CompactTextString(m) }
 func (*MuteGroupResp) ProtoMessage()    {}
 func (*MuteGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{60}
+	return fileDescriptor_group_95c16320d90511af, []int{60}
 }
 func (m *MuteGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MuteGroupResp.Unmarshal(m, b)
@@ -3203,7 +3203,7 @@ func (m *CancelMuteGroupReq) Reset()         { *m = CancelMuteGroupReq{} }
 func (m *CancelMuteGroupReq) String() string { return proto.CompactTextString(m) }
 func (*CancelMuteGroupReq) ProtoMessage()    {}
 func (*CancelMuteGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{61}
+	return fileDescriptor_group_95c16320d90511af, []int{61}
 }
 func (m *CancelMuteGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CancelMuteGroupReq.Unmarshal(m, b)
@@ -3255,7 +3255,7 @@ func (m *CancelMuteGroupResp) Reset()         { *m = CancelMuteGroupResp{} }
 func (m *CancelMuteGroupResp) String() string { return proto.CompactTextString(m) }
 func (*CancelMuteGroupResp) ProtoMessage()    {}
 func (*CancelMuteGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{62}
+	return fileDescriptor_group_95c16320d90511af, []int{62}
 }
 func (m *CancelMuteGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CancelMuteGroupResp.Unmarshal(m, b)
@@ -3282,6 +3282,114 @@ func (m *CancelMuteGroupResp) GetCommonResp() *CommonResp {
 	return nil
 }
 
+type SetGroupMemberNicknameReq struct {
+	GroupID              string   `protobuf:"bytes,1,opt,name=groupID" json:"groupID,omitempty"`
+	Nickname             string   `protobuf:"bytes,2,opt,name=nickname" json:"nickname,omitempty"`
+	OpUserID             string   `protobuf:"bytes,3,opt,name=opUserID" json:"opUserID,omitempty"`
+	OperationID          string   `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"`
+	UserID               string   `protobuf:"bytes,5,opt,name=userID" json:"userID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetGroupMemberNicknameReq) Reset()         { *m = SetGroupMemberNicknameReq{} }
+func (m *SetGroupMemberNicknameReq) String() string { return proto.CompactTextString(m) }
+func (*SetGroupMemberNicknameReq) ProtoMessage()    {}
+func (*SetGroupMemberNicknameReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_group_95c16320d90511af, []int{63}
+}
+func (m *SetGroupMemberNicknameReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SetGroupMemberNicknameReq.Unmarshal(m, b)
+}
+func (m *SetGroupMemberNicknameReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SetGroupMemberNicknameReq.Marshal(b, m, deterministic)
+}
+func (dst *SetGroupMemberNicknameReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetGroupMemberNicknameReq.Merge(dst, src)
+}
+func (m *SetGroupMemberNicknameReq) XXX_Size() int {
+	return xxx_messageInfo_SetGroupMemberNicknameReq.Size(m)
+}
+func (m *SetGroupMemberNicknameReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetGroupMemberNicknameReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetGroupMemberNicknameReq proto.InternalMessageInfo
+
+func (m *SetGroupMemberNicknameReq) GetGroupID() string {
+	if m != nil {
+		return m.GroupID
+	}
+	return ""
+}
+
+func (m *SetGroupMemberNicknameReq) GetNickname() string {
+	if m != nil {
+		return m.Nickname
+	}
+	return ""
+}
+
+func (m *SetGroupMemberNicknameReq) GetOpUserID() string {
+	if m != nil {
+		return m.OpUserID
+	}
+	return ""
+}
+
+func (m *SetGroupMemberNicknameReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+func (m *SetGroupMemberNicknameReq) GetUserID() string {
+	if m != nil {
+		return m.UserID
+	}
+	return ""
+}
+
+type SetGroupMemberNicknameResp 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 *SetGroupMemberNicknameResp) Reset()         { *m = SetGroupMemberNicknameResp{} }
+func (m *SetGroupMemberNicknameResp) String() string { return proto.CompactTextString(m) }
+func (*SetGroupMemberNicknameResp) ProtoMessage()    {}
+func (*SetGroupMemberNicknameResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_group_95c16320d90511af, []int{64}
+}
+func (m *SetGroupMemberNicknameResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SetGroupMemberNicknameResp.Unmarshal(m, b)
+}
+func (m *SetGroupMemberNicknameResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SetGroupMemberNicknameResp.Marshal(b, m, deterministic)
+}
+func (dst *SetGroupMemberNicknameResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetGroupMemberNicknameResp.Merge(dst, src)
+}
+func (m *SetGroupMemberNicknameResp) XXX_Size() int {
+	return xxx_messageInfo_SetGroupMemberNicknameResp.Size(m)
+}
+func (m *SetGroupMemberNicknameResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetGroupMemberNicknameResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetGroupMemberNicknameResp proto.InternalMessageInfo
+
+func (m *SetGroupMemberNicknameResp) GetCommonResp() *CommonResp {
+	if m != nil {
+		return m.CommonResp
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*CommonResp)(nil), "group.CommonResp")
 	proto.RegisterType((*GroupAddMemberInfo)(nil), "group.GroupAddMemberInfo")
@@ -3346,6 +3454,8 @@ func init() {
 	proto.RegisterType((*MuteGroupResp)(nil), "group.MuteGroupResp")
 	proto.RegisterType((*CancelMuteGroupReq)(nil), "group.CancelMuteGroupReq")
 	proto.RegisterType((*CancelMuteGroupResp)(nil), "group.CancelMuteGroupResp")
+	proto.RegisterType((*SetGroupMemberNicknameReq)(nil), "group.SetGroupMemberNicknameReq")
+	proto.RegisterType((*SetGroupMemberNicknameResp)(nil), "group.SetGroupMemberNicknameResp")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3388,6 +3498,7 @@ type GroupClient interface {
 	CancelMuteGroupMember(ctx context.Context, in *CancelMuteGroupMemberReq, opts ...grpc.CallOption) (*CancelMuteGroupMemberResp, error)
 	MuteGroup(ctx context.Context, in *MuteGroupReq, opts ...grpc.CallOption) (*MuteGroupResp, error)
 	CancelMuteGroup(ctx context.Context, in *CancelMuteGroupReq, opts ...grpc.CallOption) (*CancelMuteGroupResp, error)
+	SetGroupMemberNickname(ctx context.Context, in *SetGroupMemberNicknameReq, opts ...grpc.CallOption) (*SetGroupMemberNicknameResp, error)
 }
 
 type groupClient struct {
@@ -3659,6 +3770,15 @@ func (c *groupClient) CancelMuteGroup(ctx context.Context, in *CancelMuteGroupRe
 	return out, nil
 }
 
+func (c *groupClient) SetGroupMemberNickname(ctx context.Context, in *SetGroupMemberNicknameReq, opts ...grpc.CallOption) (*SetGroupMemberNicknameResp, error) {
+	out := new(SetGroupMemberNicknameResp)
+	err := grpc.Invoke(ctx, "/group.group/SetGroupMemberNickname", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for Group service
 
 type GroupServer interface {
@@ -3691,6 +3811,7 @@ type GroupServer interface {
 	CancelMuteGroupMember(context.Context, *CancelMuteGroupMemberReq) (*CancelMuteGroupMemberResp, error)
 	MuteGroup(context.Context, *MuteGroupReq) (*MuteGroupResp, error)
 	CancelMuteGroup(context.Context, *CancelMuteGroupReq) (*CancelMuteGroupResp, error)
+	SetGroupMemberNickname(context.Context, *SetGroupMemberNicknameReq) (*SetGroupMemberNicknameResp, error)
 }
 
 func RegisterGroupServer(s *grpc.Server, srv GroupServer) {
@@ -4219,6 +4340,24 @@ func _Group_CancelMuteGroup_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Group_SetGroupMemberNickname_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SetGroupMemberNicknameReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GroupServer).SetGroupMemberNickname(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/group.group/SetGroupMemberNickname",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GroupServer).SetGroupMemberNickname(ctx, req.(*SetGroupMemberNicknameReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Group_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "group.group",
 	HandlerType: (*GroupServer)(nil),
@@ -4339,143 +4478,151 @@ var _Group_serviceDesc = grpc.ServiceDesc{
 			MethodName: "CancelMuteGroup",
 			Handler:    _Group_CancelMuteGroup_Handler,
 		},
+		{
+			MethodName: "SetGroupMemberNickname",
+			Handler:    _Group_SetGroupMemberNickname_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "group/group.proto",
 }
 
-func init() { proto.RegisterFile("group/group.proto", fileDescriptor_group_3c77315b028a1402) }
+func init() { proto.RegisterFile("group/group.proto", fileDescriptor_group_95c16320d90511af) }
 
-var fileDescriptor_group_3c77315b028a1402 = []byte{
-	// 2068 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4f, 0x6f, 0xdb, 0xc8,
-	0x15, 0x07, 0xed, 0xc8, 0xb6, 0x9e, 0xad, 0xc8, 0x1e, 0x47, 0xb6, 0xc2, 0xf5, 0x66, 0xbd, 0xb3,
-	0xe9, 0x22, 0xe8, 0x1f, 0x1b, 0xcd, 0x02, 0x39, 0x74, 0x8b, 0xa6, 0xf1, 0x9f, 0xc4, 0x4a, 0x22,
-	0xbb, 0xa1, 0xd3, 0x4b, 0x2e, 0xa9, 0x56, 0x1c, 0x0b, 0xaa, 0x25, 0x92, 0xe6, 0x50, 0x4e, 0xdb,
-	0xcb, 0xa2, 0x97, 0x05, 0xb6, 0xed, 0xa1, 0x45, 0x81, 0x3d, 0x15, 0x68, 0x73, 0xeb, 0xa1, 0x87,
-	0x1e, 0xda, 0x73, 0xd1, 0x8f, 0xd1, 0x4f, 0xd1, 0xaf, 0x50, 0x70, 0x66, 0x38, 0x1c, 0x0e, 0x87,
-	0xb4, 0x42, 0x25, 0xcd, 0x45, 0xc0, 0xbc, 0x79, 0xc3, 0xf7, 0x7b, 0x6f, 0xe6, 0xbd, 0x79, 0xef,
-	0x8d, 0x60, 0x6d, 0x10, 0xfa, 0x93, 0x60, 0x97, 0xfd, 0xee, 0x04, 0xa1, 0x1f, 0xf9, 0xa8, 0xc6,
-	0x06, 0xf6, 0xc7, 0x27, 0x01, 0xf1, 0x5e, 0x76, 0xba, 0xbb, 0xc1, 0xf9, 0x60, 0x97, 0xcd, 0xec,
-	0x52, 0xf7, 0xfc, 0xe5, 0x2b, 0xba, 0xfb, 0x8a, 0x72, 0x4e, 0xfc, 0x23, 0x80, 0x7d, 0x7f, 0x3c,
-	0xf6, 0x3d, 0x87, 0xd0, 0x00, 0xb5, 0x61, 0xf1, 0x30, 0x0c, 0xf7, 0x7d, 0x97, 0xb4, 0xad, 0x6d,
-	0xeb, 0x4e, 0xcd, 0x49, 0x86, 0x68, 0x03, 0x16, 0x0e, 0xc3, 0xb0, 0x4b, 0x07, 0xed, 0xb9, 0x6d,
-	0xeb, 0x4e, 0xdd, 0x11, 0x23, 0xfc, 0x18, 0xd0, 0xa3, 0x58, 0xd6, 0x03, 0xd7, 0xed, 0x92, 0xf1,
-	0x17, 0x24, 0xec, 0x78, 0x67, 0x7e, 0xcc, 0xfd, 0x53, 0x4a, 0xc2, 0xce, 0x01, 0xfb, 0x4c, 0xdd,
-	0x11, 0x23, 0xb4, 0x05, 0x75, 0xc7, 0x1f, 0x91, 0xa7, 0xe4, 0x92, 0x8c, 0xd8, 0x87, 0x6a, 0x4e,
-	0x4a, 0xc0, 0xff, 0xb5, 0xe0, 0xfa, 0x7e, 0x48, 0x7a, 0x11, 0x61, 0x9f, 0x74, 0xc8, 0x05, 0x7a,
-	0x00, 0xd7, 0x3b, 0xde, 0x30, 0xe2, 0x9f, 0x7e, 0x3a, 0xa4, 0x51, 0xdb, 0xda, 0x9e, 0xbf, 0xb3,
-	0x7c, 0xf7, 0xe6, 0x0e, 0x57, 0x37, 0x2f, 0xdb, 0xd1, 0x16, 0xa0, 0x1f, 0x40, 0x9d, 0x71, 0xc5,
-	0x93, 0x4c, 0xe6, 0xf2, 0xdd, 0xad, 0x1d, 0x4a, 0xc2, 0x4b, 0x12, 0xbe, 0xec, 0x05, 0xc3, 0x97,
-	0x41, 0x2f, 0xec, 0x8d, 0xe9, 0x8e, 0xe4, 0x71, 0x52, 0x76, 0xb4, 0x0d, 0xcb, 0x27, 0x01, 0x09,
-	0x7b, 0xd1, 0xd0, 0xf7, 0x3a, 0x07, 0xed, 0x79, 0xa6, 0x8c, 0x4a, 0x42, 0x36, 0x2c, 0x9d, 0x04,
-	0x42, 0xd7, 0x6b, 0x6c, 0x5a, 0x8e, 0xd9, 0xea, 0x57, 0x1e, 0x09, 0xc5, 0x74, 0x4d, 0xac, 0x4e,
-	0x49, 0xf8, 0x4b, 0x68, 0x66, 0x14, 0xae, 0xb2, 0x05, 0x59, 0x05, 0xe7, 0xdf, 0x48, 0x41, 0x1c,
-	0xc2, 0xea, 0x23, 0x12, 0xb1, 0x31, 0x65, 0x73, 0xe4, 0x22, 0x86, 0xcd, 0x19, 0x0e, 0xa4, 0xc1,
-	0xeb, 0x8e, 0x4a, 0xd2, 0xcd, 0x32, 0x57, 0x6e, 0x96, 0xf9, 0xac, 0x59, 0xf0, 0xd7, 0x16, 0xac,
-	0x69, 0x42, 0x2b, 0xe9, 0xbd, 0x07, 0x0d, 0xa9, 0x08, 0x43, 0x3a, 0xcf, 0x8e, 0x46, 0xb9, 0xee,
-	0xd9, 0x25, 0xf8, 0xb7, 0x16, 0x34, 0x4f, 0x05, 0x96, 0x44, 0xff, 0x8c, 0x3d, 0xad, 0x37, 0x3b,
-	0x30, 0xaa, 0xde, 0x73, 0x86, 0xe3, 0x50, 0x7a, 0x98, 0xf0, 0x21, 0xac, 0x66, 0xc1, 0xd0, 0x00,
-	0x7d, 0x5f, 0x75, 0x50, 0x01, 0x67, 0x4d, 0x9c, 0xfe, 0x74, 0xc2, 0x51, 0x98, 0xf0, 0xaf, 0xc0,
-	0x4e, 0xec, 0xfb, 0x20, 0x08, 0x46, 0xc3, 0x3e, 0xfb, 0x7e, 0xac, 0x6f, 0xac, 0x9e, 0x0a, 0xd1,
-	0x2a, 0x87, 0x68, 0xd8, 0xd8, 0x5b, 0x00, 0x0f, 0x43, 0x7f, 0x9c, 0xd9, 0x5a, 0x85, 0x82, 0xff,
-	0x64, 0xc1, 0x07, 0x85, 0xc2, 0x2b, 0x6d, 0xf3, 0x13, 0x58, 0x4d, 0xc2, 0xc1, 0x84, 0xd0, 0x48,
-	0xd9, 0xe9, 0x8f, 0x8a, 0x76, 0x45, 0xb0, 0x3a, 0xb9, 0x85, 0x38, 0x82, 0xad, 0x47, 0x24, 0x8a,
-	0xb1, 0x3a, 0xe4, 0xc2, 0x60, 0x9c, 0xa2, 0xc0, 0x35, 0xdb, 0xbe, 0xfe, 0xd9, 0x82, 0x0f, 0x4b,
-	0xc4, 0x56, 0xda, 0x65, 0xa3, 0x5d, 0xe6, 0xaa, 0xda, 0xe5, 0x5f, 0x16, 0xb4, 0x9e, 0x87, 0x3d,
-	0x8f, 0x9e, 0x91, 0x90, 0x4d, 0xb2, 0x28, 0x15, 0x5b, 0xa4, 0x0d, 0x8b, 0xc2, 0xf5, 0x85, 0x49,
-	0x92, 0x21, 0xfa, 0x14, 0xae, 0x9f, 0x8c, 0x5c, 0x35, 0xc2, 0x71, 0xcb, 0x68, 0xd4, 0x98, 0xef,
-	0x98, 0xbc, 0x52, 0xf9, 0xb8, 0x89, 0x34, 0xaa, 0x6e, 0xc7, 0x6b, 0xe5, 0x51, 0xa5, 0xa6, 0x45,
-	0x95, 0x27, 0xb0, 0x61, 0x52, 0xa0, 0x9a, 0x07, 0x7d, 0x65, 0xc1, 0xca, 0x63, 0x7f, 0xe8, 0xc9,
-	0x7b, 0xa8, 0xd8, 0x0a, 0xb7, 0x00, 0x1c, 0x72, 0xd1, 0x25, 0x94, 0xf6, 0x06, 0x44, 0x58, 0x40,
-	0xa1, 0x94, 0x45, 0xc2, 0xab, 0x35, 0xc6, 0x7b, 0xd0, 0x50, 0x70, 0x54, 0x53, 0xe6, 0x3f, 0xb1,
-	0x4b, 0x6a, 0xfe, 0x18, 0x4f, 0xf8, 0x1e, 0x25, 0x22, 0xde, 0xab, 0x28, 0xac, 0x72, 0xbb, 0xeb,
-	0xa7, 0x5f, 0xb1, 0xcc, 0x7c, 0xce, 0x32, 0x4a, 0xa8, 0xb8, 0xa6, 0x87, 0x8a, 0x78, 0xfe, 0xa8,
-	0xe7, 0xb9, 0x23, 0xe2, 0xc6, 0x4e, 0xcf, 0xf7, 0x53, 0xa1, 0x20, 0x0c, 0x2b, 0x7c, 0xe4, 0x10,
-	0x3a, 0x19, 0x45, 0xed, 0x05, 0x16, 0x2f, 0x32, 0x34, 0xfc, 0x0c, 0xb6, 0x8a, 0x55, 0xab, 0x66,
-	0xae, 0x33, 0x58, 0x79, 0x36, 0x19, 0x46, 0x53, 0x6c, 0xfd, 0x6c, 0xd7, 0xe0, 0x1e, 0x34, 0x14,
-	0x39, 0xd5, 0xb0, 0xbe, 0xb6, 0xa0, 0x95, 0x44, 0xdb, 0x34, 0xe5, 0x29, 0x47, 0x3d, 0x53, 0x28,
-	0x8b, 0x03, 0xe4, 0xc3, 0xe1, 0x28, 0x22, 0x21, 0xdb, 0xd0, 0x9a, 0x23, 0x46, 0xb1, 0xbc, 0x63,
-	0xf2, 0x8b, 0xe8, 0x94, 0x5c, 0xb0, 0x9d, 0xac, 0x39, 0xc9, 0x10, 0xff, 0xcd, 0x82, 0x0d, 0x13,
-	0xc6, 0x4a, 0x97, 0xc1, 0x43, 0x80, 0x71, 0x9a, 0x0b, 0xf2, 0x6b, 0xe0, 0xd3, 0xa2, 0x70, 0xc7,
-	0xa5, 0x3d, 0x9c, 0x8c, 0x46, 0xec, 0x36, 0x55, 0x56, 0xc6, 0x92, 0x3d, 0x01, 0x97, 0xeb, 0x91,
-	0x0c, 0xf1, 0xef, 0x73, 0x70, 0x65, 0x62, 0x54, 0x1a, 0x04, 0x14, 0x58, 0x73, 0x2c, 0x63, 0x52,
-	0xc5, 0xcd, 0x16, 0x04, 0xfe, 0x68, 0xc1, 0xa6, 0x11, 0xd2, 0xfb, 0x34, 0x21, 0xfe, 0xbb, 0x05,
-	0xe8, 0xc9, 0xb0, 0x7f, 0xae, 0xf0, 0x95, 0x1b, 0xe9, 0xdb, 0xb0, 0x1a, 0xf3, 0x13, 0x97, 0x2b,
-	0xae, 0x98, 0x2a, 0x47, 0x8f, 0xc1, 0x3b, 0xa4, 0x47, 0x7d, 0x4f, 0x98, 0x4b, 0x8c, 0x74, 0x63,
-	0xd5, 0xca, 0x5d, 0x6e, 0x41, 0x73, 0xb9, 0xcf, 0xa1, 0xde, 0x71, 0xef, 0xf2, 0xd0, 0x51, 0x78,
-	0xd5, 0x33, 0xd1, 0x2c, 0xe0, 0xf0, 0x02, 0x45, 0x8c, 0xf0, 0x97, 0xb0, 0x9e, 0x53, 0xb7, 0xd2,
-	0x06, 0xdc, 0x83, 0x86, 0x44, 0xa1, 0xec, 0xc1, 0xaa, 0x70, 0x75, 0x39, 0xe7, 0x64, 0xd9, 0xf0,
-	0x84, 0xf9, 0x7a, 0x7c, 0x1d, 0x10, 0x97, 0xa1, 0x48, 0x7c, 0x3d, 0x1b, 0x68, 0xad, 0x5c, 0xa0,
-	0xdd, 0x86, 0x65, 0x3f, 0x1f, 0xa7, 0xfc, 0x29, 0xe3, 0xd4, 0x57, 0xdc, 0x21, 0x72, 0x72, 0x67,
-	0xaa, 0x55, 0xa6, 0xce, 0xd7, 0x53, 0x76, 0xfc, 0x0f, 0x0b, 0x6e, 0x74, 0xbc, 0xcb, 0x61, 0x44,
-	0x62, 0x64, 0xcf, 0x7d, 0x19, 0xa1, 0xaf, 0x8e, 0xc3, 0xc5, 0x97, 0x54, 0x7a, 0xd0, 0xae, 0x65,
-	0x0e, 0xda, 0x77, 0x61, 0x8d, 0xcb, 0x52, 0x4f, 0x6b, 0x8d, 0x9d, 0xd6, 0xfc, 0x44, 0xe9, 0xa1,
-	0xfb, 0xb5, 0x05, 0x2d, 0x03, 0xec, 0xff, 0xeb, 0xd1, 0xf1, 0xe0, 0x86, 0x4c, 0xca, 0x47, 0xa3,
-	0x69, 0x9c, 0x75, 0xb6, 0x84, 0xf7, 0x0f, 0xca, 0xbd, 0xa4, 0x08, 0x7c, 0xaf, 0xf1, 0xea, 0x1b,
-	0x0b, 0x96, 0xf6, 0xbb, 0xa7, 0x8c, 0x6d, 0xa6, 0x1a, 0xef, 0x0e, 0x34, 0xb9, 0xac, 0x1e, 0x8d,
-	0x48, 0x78, 0xdc, 0x1b, 0x27, 0x69, 0x9f, 0x4e, 0x46, 0xb7, 0x45, 0x85, 0xca, 0x49, 0x1d, 0x57,
-	0x98, 0x2a, 0x4b, 0x8c, 0xc3, 0xfb, 0x72, 0x62, 0xac, 0x78, 0x53, 0xb6, 0x04, 0x36, 0xf6, 0x65,
-	0xbe, 0x2d, 0x29, 0x01, 0x1d, 0x00, 0xfc, 0xa4, 0x37, 0x18, 0x7a, 0xcc, 0xd4, 0xa2, 0x9f, 0x71,
-	0xdb, 0x00, 0x5d, 0x64, 0xf7, 0x29, 0xaf, 0xa3, 0xac, 0x9b, 0x62, 0x0b, 0x5f, 0x5b, 0xb0, 0x92,
-	0xa2, 0xa2, 0x01, 0xfa, 0x1e, 0xd4, 0x13, 0xf3, 0x51, 0xd1, 0x85, 0x69, 0x26, 0xd9, 0x89, 0xa0,
-	0x3b, 0x29, 0xc7, 0x5b, 0xc2, 0x29, 0x6d, 0x31, 0x19, 0x53, 0x86, 0xb2, 0xe6, 0xa4, 0x04, 0x7c,
-	0x99, 0x42, 0xa4, 0xb1, 0xe5, 0xb2, 0x32, 0xad, 0xb7, 0x63, 0x9b, 0x7c, 0x38, 0xc1, 0x7f, 0xb1,
-	0xa0, 0xa1, 0x08, 0x7e, 0x5f, 0xc6, 0xb1, 0x61, 0x29, 0xb1, 0x85, 0xb0, 0x8d, 0x1c, 0xe3, 0x93,
-	0xb4, 0xc7, 0x62, 0x70, 0x77, 0x37, 0xeb, 0xee, 0xee, 0x14, 0x3a, 0x9f, 0x43, 0x8b, 0x0f, 0x79,
-	0xaf, 0xea, 0x34, 0xea, 0x45, 0x13, 0x5a, 0xfe, 0xd1, 0x0d, 0x58, 0xe0, 0x6c, 0xc9, 0x4d, 0xca,
-	0x47, 0x53, 0x1c, 0xbe, 0x36, 0x6c, 0x98, 0x84, 0xf1, 0xca, 0x0c, 0x89, 0x29, 0x56, 0x4e, 0xfb,
-	0x23, 0x72, 0x25, 0x08, 0x16, 0xb6, 0xdc, 0x24, 0xac, 0xf0, 0x51, 0xb6, 0x15, 0x39, 0xaf, 0xb5,
-	0x22, 0xa7, 0x48, 0xca, 0x5a, 0xb0, 0x9e, 0xc3, 0x41, 0x03, 0xfc, 0x14, 0xae, 0x1f, 0x90, 0x11,
-	0x51, 0x5a, 0x98, 0xb3, 0x18, 0x7d, 0x0d, 0x9a, 0x99, 0xaf, 0xd1, 0x00, 0x77, 0xa1, 0x99, 0x6c,
-	0xec, 0xde, 0x2f, 0x3b, 0xee, 0xac, 0x12, 0xee, 0xa7, 0x0d, 0x40, 0xfe, 0x39, 0x1a, 0xa0, 0xef,
-	0xa4, 0x81, 0x52, 0x38, 0x51, 0xee, 0x2c, 0x4b, 0x06, 0xfc, 0xcf, 0x5c, 0x09, 0x42, 0xf7, 0xbb,
-	0xa7, 0xe5, 0xb0, 0x6c, 0x58, 0x8a, 0x8d, 0xa6, 0x84, 0x4e, 0x39, 0xd6, 0x5c, 0x63, 0xfe, 0xed,
-	0xf8, 0xb0, 0x61, 0xff, 0xfe, 0x9d, 0xcf, 0xf3, 0x19, 0x6e, 0x1a, 0xa0, 0x1f, 0xc3, 0x22, 0xbf,
-	0x37, 0x12, 0x57, 0x9e, 0xf6, 0xba, 0x49, 0x96, 0xa1, 0x43, 0x83, 0x7f, 0x7f, 0xcb, 0xa8, 0x04,
-	0xaf, 0x55, 0x0b, 0xb4, 0xb8, 0x05, 0xc0, 0x25, 0x28, 0xe1, 0x4f, 0xa1, 0xe0, 0xdf, 0x59, 0xd0,
-	0x76, 0xc8, 0xd8, 0xbf, 0x24, 0x6f, 0x64, 0xfe, 0x36, 0x2c, 0x72, 0x27, 0xa0, 0x22, 0xff, 0x4e,
-	0x86, 0x6f, 0xd4, 0xef, 0x76, 0xb5, 0x7e, 0xb7, 0x8b, 0xbb, 0x70, 0xb3, 0x00, 0x0d, 0xbf, 0xf8,
-	0xe9, 0xa4, 0xdf, 0x27, 0x94, 0x8a, 0x8e, 0x72, 0x32, 0x8c, 0x3d, 0xf4, 0xac, 0x37, 0x1c, 0x11,
-	0x57, 0xa0, 0x11, 0x23, 0xfc, 0xb5, 0x05, 0xad, 0x07, 0xae, 0xfb, 0x2e, 0x54, 0x73, 0xf3, 0xaa,
-	0xb9, 0xa5, 0xaa, 0x3d, 0x86, 0x0d, 0x13, 0x94, 0x4a, 0x7a, 0x0d, 0xa1, 0x79, 0x30, 0xa4, 0xe3,
-	0x21, 0xa5, 0x32, 0x46, 0xd8, 0xb0, 0xe4, 0x6b, 0x3d, 0x59, 0x3f, 0x98, 0x3a, 0x7b, 0x6f, 0xc3,
-	0xe2, 0x20, 0x9b, 0xdd, 0x8a, 0x21, 0x3e, 0x84, 0xd5, 0xac, 0x28, 0xde, 0x66, 0xe8, 0x4f, 0xd3,
-	0x66, 0x48, 0x99, 0xf0, 0x5f, 0x2d, 0x40, 0xdd, 0x49, 0x44, 0xb4, 0xeb, 0xe4, 0x1d, 0xa1, 0x8e,
-	0x0d, 0x37, 0x51, 0x9b, 0x46, 0x62, 0x84, 0x30, 0xac, 0x8c, 0x27, 0x11, 0x71, 0x4f, 0x49, 0xdf,
-	0xf7, 0x5c, 0xca, 0xaa, 0xbf, 0x86, 0x93, 0xa1, 0xe1, 0x23, 0x58, 0xcf, 0x21, 0xad, 0xa6, 0xf4,
-	0x6f, 0x2c, 0x68, 0xef, 0xf7, 0xbc, 0x3e, 0x19, 0xbd, 0x7f, 0xd5, 0xf1, 0x31, 0xdc, 0x2c, 0xc0,
-	0x52, 0x4d, 0xb9, 0x33, 0x58, 0x91, 0x5f, 0x7a, 0x97, 0x07, 0x70, 0x0f, 0x1a, 0x8a, 0x9c, 0x6a,
-	0x58, 0x47, 0x80, 0x34, 0xdd, 0xdf, 0x25, 0xe2, 0x23, 0x58, 0xcf, 0x49, 0xab, 0x84, 0xfb, 0xee,
-	0x37, 0x6b, 0xc0, 0xdf, 0x61, 0xd1, 0x0f, 0x61, 0xb9, 0x9f, 0x3e, 0xf3, 0xa1, 0x56, 0xb2, 0x2e,
-	0xf3, 0xd6, 0x69, 0x6f, 0x98, 0xc8, 0x34, 0x40, 0xf7, 0xa0, 0xfe, 0xf3, 0xa4, 0x07, 0x8c, 0xd6,
-	0x05, 0x93, 0xda, 0x9d, 0xb6, 0x6f, 0xe4, 0x89, 0x7c, 0xdd, 0x45, 0xd2, 0x60, 0x94, 0xeb, 0xd4,
-	0xd6, 0xa6, 0x5c, 0x97, 0xed, 0x43, 0xee, 0x41, 0x63, 0xa0, 0x3e, 0xcf, 0xa1, 0xcd, 0xe4, 0xb1,
-	0x55, 0x7b, 0x29, 0xb4, 0xdb, 0xe6, 0x09, 0x1a, 0xa0, 0xfb, 0xb0, 0x42, 0x95, 0x97, 0x2c, 0x94,
-	0xe8, 0xa6, 0xbd, 0xb5, 0xd9, 0x9b, 0x46, 0x3a, 0x0d, 0xd0, 0xcf, 0x60, 0x73, 0x60, 0x7e, 0x46,
-	0x42, 0x1f, 0x6b, 0x52, 0xf3, 0xcf, 0x38, 0x36, 0xbe, 0x8a, 0x85, 0x06, 0xe8, 0x0c, 0x6e, 0x0e,
-	0x8a, 0xde, 0x64, 0xd0, 0x27, 0xe9, 0x07, 0x0a, 0x1f, 0x8b, 0xec, 0xdb, 0x57, 0x33, 0xd1, 0x00,
-	0x3d, 0x03, 0x14, 0xe5, 0x1e, 0x26, 0xd0, 0x96, 0x58, 0x6b, 0x7c, 0x74, 0xb1, 0x3f, 0x2c, 0x99,
-	0xa5, 0x01, 0xea, 0x43, 0x7b, 0x50, 0xd0, 0xf5, 0x46, 0x38, 0xf3, 0x32, 0x6e, 0xec, 0xf8, 0xdb,
-	0x9f, 0x5c, 0xc9, 0xc3, 0x71, 0x0f, 0x72, 0x6d, 0x5b, 0x89, 0xdb, 0xd8, 0x75, 0x96, 0xb8, 0x0b,
-	0xfa, 0xbd, 0xcf, 0x61, 0x7d, 0x90, 0xef, 0x63, 0x22, 0xf3, 0x2a, 0x79, 0xca, 0x6e, 0x95, 0x4d,
-	0xd3, 0x00, 0x1d, 0x41, 0xf3, 0x3c, 0xdb, 0x98, 0x43, 0xc9, 0xdf, 0x03, 0xf2, 0xfd, 0x49, 0xdb,
-	0x2e, 0x9a, 0x92, 0x2a, 0x6b, 0x9d, 0x2e, 0x55, 0xe5, 0x7c, 0xf3, 0x4d, 0x55, 0xd9, 0xd4, 0x22,
-	0x3b, 0x86, 0xb5, 0xa1, 0xde, 0xfc, 0x41, 0x1f, 0x24, 0xfd, 0x1a, 0x43, 0x37, 0xcb, 0xde, 0x2a,
-	0x9e, 0xe4, 0xdf, 0x1b, 0xe8, 0x8d, 0x15, 0xf9, 0x3d, 0x53, 0x8f, 0xc7, 0xde, 0x2a, 0x9e, 0xe4,
-	0x8e, 0xaa, 0xe6, 0xff, 0xd2, 0x51, 0xb5, 0x1a, 0xc3, 0xde, 0x34, 0xd2, 0x69, 0x80, 0x3e, 0x83,
-	0xa5, 0x84, 0x86, 0x90, 0xc6, 0x14, 0x2f, 0x5c, 0xcf, 0xd1, 0x78, 0x68, 0x92, 0x31, 0x03, 0xe9,
-	0x1c, 0x54, 0x0d, 0x4d, 0xd9, 0x32, 0xfb, 0x99, 0x2c, 0xfe, 0x94, 0xba, 0x50, 0x6e, 0x90, 0xb1,
-	0x3e, 0x95, 0x1b, 0x64, 0x2e, 0x28, 0xe3, 0xd3, 0xa3, 0xd5, 0x71, 0xf2, 0xf4, 0xe4, 0xeb, 0x4c,
-	0x79, 0x7a, 0x0c, 0xa5, 0x5f, 0x1c, 0xe5, 0x95, 0x62, 0x4d, 0x46, 0xf9, 0x6c, 0x39, 0x28, 0xa3,
-	0xbc, 0x56, 0xd7, 0xc5, 0xaa, 0xe5, 0xcb, 0x91, 0x02, 0x77, 0x13, 0x79, 0x70, 0x81, 0xbb, 0xc9,
-	0xd4, 0xf4, 0x05, 0xb4, 0x8c, 0xf9, 0x38, 0xfa, 0x48, 0xac, 0x2b, 0xaa, 0x1d, 0xec, 0xed, 0x72,
-	0x06, 0x0e, 0x37, 0x9f, 0x10, 0x4b, 0xb8, 0xc6, 0xb4, 0x5d, 0xc2, 0x2d, 0xc8, 0xa4, 0xef, 0xc3,
-	0x8a, 0x9a, 0xac, 0xca, 0xa3, 0xa8, 0x25, 0xcb, 0xf2, 0x28, 0xe6, 0x32, 0xdb, 0x23, 0x68, 0x6a,
-	0xe9, 0x91, 0xdc, 0xca, 0x7c, 0x0a, 0x27, 0xb7, 0xd2, 0x94, 0x51, 0xbd, 0x80, 0x96, 0x31, 0xdd,
-	0x92, 0x96, 0x2b, 0x4a, 0x0c, 0xa5, 0xe5, 0x8a, 0xb3, 0xb5, 0x7b, 0x50, 0x97, 0x64, 0x79, 0xf6,
-	0xd5, 0xd4, 0x46, 0x9e, 0xfd, 0x6c, 0x06, 0x72, 0x04, 0x4d, 0xed, 0xa3, 0x52, 0xbb, 0x7c, 0x7a,
-	0x24, 0xb5, 0x33, 0xe4, 0x32, 0x7b, 0xcd, 0x17, 0x8d, 0x1d, 0xfe, 0x77, 0xb1, 0xcf, 0xd9, 0xef,
-	0x17, 0x0b, 0xec, 0xbf, 0x60, 0x9f, 0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x2b, 0x24, 0xa7,
-	0x4a, 0x26, 0x00, 0x00,
+var fileDescriptor_group_95c16320d90511af = []byte{
+	// 2138 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x1a, 0x4d, 0x6f, 0x1c, 0x49,
+	0x55, 0xed, 0xf1, 0xd8, 0x9e, 0x67, 0x4f, 0xc6, 0x2e, 0xef, 0xd8, 0xe3, 0x5e, 0x6f, 0xd6, 0xa9,
+	0x0d, 0xab, 0x88, 0x0f, 0x5b, 0x64, 0xa5, 0x1c, 0x58, 0x44, 0x88, 0x3f, 0x12, 0x4f, 0x92, 0xb1,
+	0x49, 0x3b, 0x5c, 0x22, 0xa1, 0x30, 0x3b, 0x5d, 0x1e, 0x0d, 0x9e, 0xe9, 0x6e, 0x77, 0xf5, 0x38,
+	0xc0, 0x65, 0xc5, 0x65, 0xa5, 0x05, 0x0e, 0x20, 0x24, 0x4e, 0x48, 0xb0, 0x27, 0x38, 0x70, 0xe0,
+	0x00, 0x67, 0xc4, 0xcf, 0xe0, 0x57, 0x70, 0xe2, 0x8e, 0xba, 0xaa, 0xba, 0xba, 0xba, 0xab, 0xba,
+	0x3d, 0x99, 0x49, 0xc8, 0x65, 0xa4, 0xf7, 0xea, 0x55, 0xbf, 0x8f, 0x7a, 0xef, 0xd5, 0x7b, 0xaf,
+	0x06, 0xd6, 0xfa, 0xa1, 0x3f, 0x0e, 0xf6, 0xd8, 0xef, 0x6e, 0x10, 0xfa, 0x91, 0x8f, 0xaa, 0x0c,
+	0xb0, 0x6f, 0x9d, 0x06, 0xc4, 0x7b, 0xd9, 0xee, 0xec, 0x05, 0x17, 0xfd, 0x3d, 0xb6, 0xb2, 0x47,
+	0xdd, 0x8b, 0x97, 0xaf, 0xe8, 0xde, 0x2b, 0xca, 0x29, 0xf1, 0xf7, 0x00, 0x0e, 0xfc, 0xd1, 0xc8,
+	0xf7, 0x1c, 0x42, 0x03, 0xd4, 0x82, 0xc5, 0xa3, 0x30, 0x3c, 0xf0, 0x5d, 0xd2, 0xb2, 0x76, 0xac,
+	0x3b, 0x55, 0x27, 0x01, 0xd1, 0x06, 0x2c, 0x1c, 0x85, 0x61, 0x87, 0xf6, 0x5b, 0x73, 0x3b, 0xd6,
+	0x9d, 0x9a, 0x23, 0x20, 0xfc, 0x18, 0xd0, 0xa3, 0x98, 0xd7, 0x03, 0xd7, 0xed, 0x90, 0xd1, 0x67,
+	0x24, 0x6c, 0x7b, 0xe7, 0x7e, 0x4c, 0xfd, 0x43, 0x4a, 0xc2, 0xf6, 0x21, 0xfb, 0x4c, 0xcd, 0x11,
+	0x10, 0xda, 0x86, 0x9a, 0xe3, 0x0f, 0xc9, 0x53, 0x72, 0x45, 0x86, 0xec, 0x43, 0x55, 0x27, 0x45,
+	0xe0, 0xff, 0x58, 0x70, 0xe3, 0x20, 0x24, 0xdd, 0x88, 0xb0, 0x4f, 0x3a, 0xe4, 0x12, 0x3d, 0x80,
+	0x1b, 0x6d, 0x6f, 0x10, 0xf1, 0x4f, 0x3f, 0x1d, 0xd0, 0xa8, 0x65, 0xed, 0x54, 0xee, 0x2c, 0xdf,
+	0xdd, 0xda, 0xe5, 0xea, 0xea, 0xbc, 0x9d, 0xdc, 0x06, 0xf4, 0x1d, 0xa8, 0x31, 0xaa, 0x78, 0x91,
+	0xf1, 0x5c, 0xbe, 0xbb, 0xbd, 0x4b, 0x49, 0x78, 0x45, 0xc2, 0x97, 0xdd, 0x60, 0xf0, 0x32, 0xe8,
+	0x86, 0xdd, 0x11, 0xdd, 0x95, 0x34, 0x4e, 0x4a, 0x8e, 0x76, 0x60, 0xf9, 0x34, 0x20, 0x61, 0x37,
+	0x1a, 0xf8, 0x5e, 0xfb, 0xb0, 0x55, 0x61, 0xca, 0xa8, 0x28, 0x64, 0xc3, 0xd2, 0x69, 0x20, 0x74,
+	0x9d, 0x67, 0xcb, 0x12, 0x66, 0xbb, 0x5f, 0x79, 0x24, 0x14, 0xcb, 0x55, 0xb1, 0x3b, 0x45, 0xe1,
+	0xcf, 0xa1, 0x91, 0x51, 0x78, 0x9a, 0x23, 0xc8, 0x2a, 0x58, 0x79, 0x2d, 0x05, 0x71, 0x08, 0xab,
+	0x8f, 0x48, 0xc4, 0x60, 0xca, 0xd6, 0xc8, 0x65, 0x2c, 0x36, 0x27, 0x38, 0x94, 0x06, 0xaf, 0x39,
+	0x2a, 0x2a, 0x6f, 0x96, 0xb9, 0x72, 0xb3, 0x54, 0xb2, 0x66, 0xc1, 0x5f, 0x5a, 0xb0, 0x96, 0x63,
+	0x3a, 0x95, 0xde, 0xfb, 0x50, 0x97, 0x8a, 0x30, 0x49, 0x2b, 0xcc, 0x35, 0xca, 0x75, 0xcf, 0x6e,
+	0xc1, 0xbf, 0xb2, 0xa0, 0x71, 0x26, 0x64, 0x49, 0xf4, 0xcf, 0xd8, 0xd3, 0x7a, 0x3d, 0x87, 0x51,
+	0xf5, 0x9e, 0x33, 0xb8, 0x43, 0xa9, 0x33, 0xe1, 0x23, 0x58, 0xcd, 0x0a, 0x43, 0x03, 0xf4, 0x6d,
+	0x35, 0x40, 0x85, 0x38, 0x6b, 0xc2, 0xfb, 0xd3, 0x05, 0x47, 0x21, 0xc2, 0x3f, 0x07, 0x3b, 0xb1,
+	0xef, 0x83, 0x20, 0x18, 0x0e, 0x7a, 0xec, 0xfb, 0xb1, 0xbe, 0xb1, 0x7a, 0xaa, 0x88, 0x56, 0xb9,
+	0x88, 0x86, 0x83, 0xbd, 0x09, 0xf0, 0x30, 0xf4, 0x47, 0x99, 0xa3, 0x55, 0x30, 0xf8, 0x0f, 0x16,
+	0xbc, 0x5f, 0xc8, 0x7c, 0xaa, 0x63, 0x7e, 0x02, 0xab, 0x49, 0x3a, 0x18, 0x13, 0x1a, 0x29, 0x27,
+	0xfd, 0x61, 0xd1, 0xa9, 0x08, 0x52, 0x47, 0xdb, 0x88, 0x23, 0xd8, 0x7e, 0x44, 0xa2, 0x58, 0x56,
+	0x87, 0x5c, 0x1a, 0x8c, 0x53, 0x94, 0xb8, 0x66, 0x3b, 0xd7, 0x3f, 0x5a, 0xf0, 0x41, 0x09, 0xdb,
+	0xa9, 0x4e, 0xd9, 0x68, 0x97, 0xb9, 0x69, 0xed, 0xf2, 0x4f, 0x0b, 0x9a, 0xcf, 0xc3, 0xae, 0x47,
+	0xcf, 0x49, 0xc8, 0x16, 0x59, 0x96, 0x8a, 0x2d, 0xd2, 0x82, 0x45, 0x11, 0xfa, 0xc2, 0x24, 0x09,
+	0x88, 0x3e, 0x86, 0x1b, 0xa7, 0x43, 0x57, 0xcd, 0x70, 0xdc, 0x32, 0x39, 0x6c, 0x4c, 0x77, 0x42,
+	0x5e, 0xa9, 0x74, 0xdc, 0x44, 0x39, 0x6c, 0xde, 0x8e, 0xf3, 0xe5, 0x59, 0xa5, 0x9a, 0xcb, 0x2a,
+	0x4f, 0x60, 0xc3, 0xa4, 0xc0, 0x74, 0x11, 0xf4, 0x85, 0x05, 0x2b, 0x8f, 0xfd, 0x81, 0x27, 0xef,
+	0xa1, 0x62, 0x2b, 0xdc, 0x04, 0x70, 0xc8, 0x65, 0x87, 0x50, 0xda, 0xed, 0x13, 0x61, 0x01, 0x05,
+	0x53, 0x96, 0x09, 0xaf, 0xd7, 0x18, 0xef, 0x43, 0x5d, 0x91, 0x63, 0x3a, 0x65, 0xfe, 0x1d, 0x87,
+	0x64, 0x2e, 0x1e, 0xe3, 0x05, 0xdf, 0xa3, 0x44, 0xe4, 0x7b, 0x55, 0x0a, 0xab, 0xdc, 0xee, 0x79,
+	0xef, 0x57, 0x2c, 0x53, 0xd1, 0x2c, 0xa3, 0xa4, 0x8a, 0xf9, 0x7c, 0xaa, 0x88, 0xd7, 0x8f, 0xbb,
+	0x9e, 0x3b, 0x24, 0x6e, 0x1c, 0xf4, 0xfc, 0x3c, 0x15, 0x0c, 0xc2, 0xb0, 0xc2, 0x21, 0x87, 0xd0,
+	0xf1, 0x30, 0x6a, 0x2d, 0xb0, 0x7c, 0x91, 0xc1, 0xe1, 0x67, 0xb0, 0x5d, 0xac, 0xda, 0x74, 0xe6,
+	0x3a, 0x87, 0x95, 0x67, 0xe3, 0x41, 0x34, 0xc1, 0xd1, 0xcf, 0x76, 0x0d, 0xee, 0x43, 0x5d, 0xe1,
+	0x33, 0x9d, 0xac, 0x5f, 0x59, 0xd0, 0x4c, 0xb2, 0x6d, 0x5a, 0xf2, 0x94, 0x4b, 0x3d, 0x53, 0x2a,
+	0x8b, 0x13, 0xe4, 0xc3, 0xc1, 0x30, 0x22, 0x21, 0x3b, 0xd0, 0xaa, 0x23, 0xa0, 0x98, 0xdf, 0x09,
+	0xf9, 0x69, 0x74, 0x46, 0x2e, 0xd9, 0x49, 0x56, 0x9d, 0x04, 0xc4, 0x7f, 0xb5, 0x60, 0xc3, 0x24,
+	0xe3, 0x54, 0x97, 0xc1, 0x43, 0x80, 0x51, 0x5a, 0x0b, 0xf2, 0x6b, 0xe0, 0xe3, 0xa2, 0x74, 0xc7,
+	0xb9, 0x3d, 0x1c, 0x0f, 0x87, 0xec, 0x36, 0x55, 0x76, 0xc6, 0x9c, 0x3d, 0x21, 0x2e, 0xd7, 0x23,
+	0x01, 0xf1, 0x6f, 0x34, 0x71, 0x65, 0x61, 0x54, 0x9a, 0x04, 0x14, 0xb1, 0xe6, 0x58, 0xc5, 0xa4,
+	0xb2, 0x9b, 0x2d, 0x09, 0xfc, 0xce, 0x82, 0x4d, 0xa3, 0x48, 0xef, 0xd2, 0x84, 0xf8, 0x6f, 0x16,
+	0xa0, 0x27, 0x83, 0xde, 0x85, 0x42, 0x57, 0x6e, 0xa4, 0xaf, 0xc3, 0x6a, 0x4c, 0x4f, 0x5c, 0xae,
+	0xb8, 0x62, 0x2a, 0x0d, 0x1f, 0x0b, 0xef, 0x90, 0x2e, 0xf5, 0x3d, 0x61, 0x2e, 0x01, 0xe5, 0x8d,
+	0x55, 0x2d, 0x0f, 0xb9, 0x85, 0x5c, 0xc8, 0x7d, 0x0a, 0xb5, 0xb6, 0x7b, 0x97, 0xa7, 0x8e, 0xc2,
+	0xab, 0x9e, 0xb1, 0x66, 0x09, 0x87, 0x37, 0x28, 0x02, 0xc2, 0x9f, 0xc3, 0xba, 0xa6, 0xee, 0x54,
+	0x07, 0x70, 0x0f, 0xea, 0x52, 0x0a, 0xe5, 0x0c, 0x56, 0x45, 0xa8, 0xcb, 0x35, 0x27, 0x4b, 0x86,
+	0xc7, 0x2c, 0xd6, 0xe3, 0xeb, 0x80, 0xb8, 0x4c, 0x8a, 0x24, 0xd6, 0xb3, 0x89, 0xd6, 0xd2, 0x12,
+	0xed, 0x0e, 0x2c, 0xfb, 0x7a, 0x9e, 0xf2, 0x27, 0xcc, 0x53, 0x5f, 0xf0, 0x80, 0xd0, 0xf8, 0xce,
+	0xd4, 0xab, 0x4c, 0x5c, 0xaf, 0xa7, 0xe4, 0xf8, 0xef, 0x16, 0xbc, 0xd7, 0xf6, 0xae, 0x06, 0x11,
+	0x89, 0x25, 0x7b, 0xee, 0xcb, 0x0c, 0x7d, 0x7d, 0x1e, 0x2e, 0xbe, 0xa4, 0x52, 0x47, 0x9b, 0xcf,
+	0x38, 0xda, 0x37, 0x61, 0x8d, 0xf3, 0x52, 0xbd, 0xb5, 0xca, 0xbc, 0x55, 0x5f, 0x28, 0x75, 0xba,
+	0x5f, 0x58, 0xd0, 0x34, 0x88, 0xfd, 0x7f, 0x75, 0x1d, 0x0f, 0xde, 0x93, 0x45, 0xf9, 0x70, 0x38,
+	0x49, 0xb0, 0xce, 0x56, 0xf0, 0xfe, 0x56, 0xb9, 0x97, 0x14, 0x86, 0xef, 0x34, 0x5f, 0xfd, 0xde,
+	0x82, 0xa5, 0x83, 0xce, 0x19, 0x23, 0x9b, 0xa9, 0xc7, 0xbb, 0x03, 0x0d, 0xce, 0xab, 0x4b, 0x23,
+	0x12, 0x9e, 0x74, 0x47, 0x49, 0xd9, 0x97, 0x47, 0xa3, 0xdb, 0xa2, 0x43, 0xe5, 0xa8, 0xb6, 0x2b,
+	0x4c, 0x95, 0x45, 0xc6, 0xe9, 0x7d, 0x39, 0x31, 0x56, 0x7c, 0x28, 0xdb, 0x42, 0x36, 0xf6, 0x65,
+	0x7e, 0x2c, 0x29, 0x02, 0x1d, 0x02, 0xfc, 0xa0, 0xdb, 0x1f, 0x78, 0xcc, 0xd4, 0x62, 0x9e, 0x71,
+	0xdb, 0x20, 0xba, 0xa8, 0xee, 0x53, 0x5a, 0x47, 0xd9, 0x37, 0xc1, 0x11, 0x7e, 0x65, 0xc1, 0x4a,
+	0x2a, 0x15, 0x0d, 0xd0, 0xb7, 0xa0, 0x96, 0x98, 0x8f, 0x8a, 0x29, 0x4c, 0x23, 0xa9, 0x4e, 0x04,
+	0xde, 0x49, 0x29, 0xde, 0x90, 0x9c, 0xd2, 0x16, 0xe3, 0x11, 0x65, 0x52, 0x56, 0x9d, 0x14, 0x81,
+	0xaf, 0x52, 0x11, 0x69, 0x6c, 0xb9, 0x2c, 0x4f, 0xeb, 0xcd, 0xd8, 0x46, 0x4f, 0x27, 0xf8, 0x4f,
+	0x16, 0xd4, 0x15, 0xc6, 0xef, 0xca, 0x38, 0x36, 0x2c, 0x25, 0xb6, 0x10, 0xb6, 0x91, 0x30, 0x3e,
+	0x4d, 0x67, 0x2c, 0x86, 0x70, 0x77, 0xb3, 0xe1, 0xee, 0x4e, 0xa0, 0xf3, 0x05, 0x34, 0x39, 0xc8,
+	0x67, 0x55, 0x67, 0x51, 0x37, 0x1a, 0xd3, 0xf2, 0x8f, 0x6e, 0xc0, 0x02, 0x27, 0x4b, 0x6e, 0x52,
+	0x0e, 0x4d, 0xe0, 0x7c, 0x2d, 0xd8, 0x30, 0x31, 0xe3, 0x9d, 0x19, 0x12, 0x4b, 0xac, 0x9d, 0xf6,
+	0x87, 0xe4, 0x5a, 0x21, 0x58, 0xda, 0x72, 0x93, 0xb4, 0xc2, 0xa1, 0xec, 0x28, 0xb2, 0x92, 0x1b,
+	0x45, 0x4e, 0x50, 0x94, 0x35, 0x61, 0x5d, 0x93, 0x83, 0x06, 0xf8, 0x29, 0xdc, 0x38, 0x24, 0x43,
+	0xa2, 0x8c, 0x30, 0x67, 0x31, 0xfa, 0x1a, 0x34, 0x32, 0x5f, 0xa3, 0x01, 0xee, 0x40, 0x23, 0x39,
+	0xd8, 0xfd, 0x9f, 0xb5, 0xdd, 0x59, 0x39, 0xdc, 0x4f, 0x07, 0x80, 0xfc, 0x73, 0x34, 0x40, 0xdf,
+	0x48, 0x13, 0xa5, 0x08, 0x22, 0xcd, 0x97, 0x25, 0x01, 0xfe, 0x87, 0xd6, 0x82, 0xd0, 0x83, 0xce,
+	0x59, 0xb9, 0x58, 0x36, 0x2c, 0xc5, 0x46, 0x53, 0x52, 0xa7, 0x84, 0x73, 0xa1, 0x51, 0x79, 0x33,
+	0x31, 0x6c, 0x38, 0xbf, 0x7f, 0xe9, 0x75, 0x3e, 0x93, 0x9b, 0x06, 0xe8, 0xfb, 0xb0, 0xc8, 0xef,
+	0x8d, 0x24, 0x94, 0x27, 0xbd, 0x6e, 0x92, 0x6d, 0xe8, 0xc8, 0x10, 0xdf, 0x5f, 0x33, 0x2a, 0xc1,
+	0x7b, 0xd5, 0x02, 0x2d, 0x6e, 0x02, 0x70, 0x0e, 0x4a, 0xfa, 0x53, 0x30, 0xf8, 0xd7, 0x16, 0xb4,
+	0x1c, 0x32, 0xf2, 0xaf, 0xc8, 0x6b, 0x99, 0xbf, 0x05, 0x8b, 0x3c, 0x08, 0xa8, 0xa8, 0xbf, 0x13,
+	0xf0, 0xb5, 0xe6, 0xdd, 0x6e, 0x6e, 0xde, 0xed, 0xe2, 0x0e, 0x6c, 0x15, 0x48, 0xc3, 0x2f, 0x7e,
+	0x3a, 0xee, 0xf5, 0x08, 0xa5, 0x62, 0xa2, 0x9c, 0x80, 0x71, 0x84, 0x9e, 0x77, 0x07, 0x43, 0xe2,
+	0x0a, 0x69, 0x04, 0x84, 0xbf, 0xb4, 0xa0, 0xf9, 0xc0, 0x75, 0xdf, 0x86, 0x6a, 0xae, 0xae, 0x9a,
+	0x5b, 0xaa, 0xda, 0x63, 0xd8, 0x30, 0x89, 0x32, 0x95, 0x5e, 0x03, 0x68, 0x1c, 0x0e, 0xe8, 0x68,
+	0x40, 0xa9, 0xcc, 0x11, 0x36, 0x2c, 0xf9, 0xb9, 0x99, 0xac, 0x1f, 0x4c, 0x5c, 0xbd, 0xb7, 0x60,
+	0xb1, 0x9f, 0xad, 0x6e, 0x05, 0x88, 0x8f, 0x60, 0x35, 0xcb, 0x8a, 0x8f, 0x19, 0x7a, 0x93, 0x8c,
+	0x19, 0x52, 0x22, 0xfc, 0x17, 0x0b, 0x50, 0x67, 0x1c, 0x91, 0xdc, 0x75, 0xf2, 0x96, 0xa4, 0x8e,
+	0x0d, 0x37, 0x56, 0x87, 0x46, 0x02, 0x42, 0x18, 0x56, 0x46, 0xe3, 0x88, 0xb8, 0x67, 0xa4, 0xe7,
+	0x7b, 0x2e, 0x65, 0xdd, 0x5f, 0xdd, 0xc9, 0xe0, 0xf0, 0x31, 0xac, 0x6b, 0x92, 0x4e, 0xa7, 0xf4,
+	0x2f, 0x2d, 0x68, 0x1d, 0x74, 0xbd, 0x1e, 0x19, 0xbe, 0x7b, 0xd5, 0xf1, 0x09, 0x6c, 0x15, 0xc8,
+	0x32, 0x9d, 0x72, 0xe7, 0xb0, 0x22, 0xbf, 0xf4, 0x36, 0x1d, 0x70, 0x1f, 0xea, 0x0a, 0x9f, 0xe9,
+	0x64, 0x1d, 0x02, 0xca, 0xe9, 0xfe, 0x36, 0x25, 0x3e, 0x86, 0x75, 0x8d, 0xdb, 0x74, 0x72, 0xff,
+	0xd9, 0x82, 0xad, 0xb3, 0xcc, 0x0d, 0x73, 0x32, 0xe8, 0x5d, 0x78, 0xdd, 0x51, 0x52, 0xb1, 0xf4,
+	0xb3, 0xad, 0x57, 0x3f, 0x6d, 0xbd, 0x3c, 0x41, 0x98, 0xdc, 0x8e, 0x09, 0x9c, 0xd1, 0xba, 0x52,
+	0xae, 0xf5, 0xbc, 0xae, 0x75, 0xea, 0x5d, 0xd5, 0x8c, 0x77, 0x9d, 0x82, 0x5d, 0x24, 0xe8, 0x54,
+	0x73, 0xc9, 0xbb, 0xff, 0x5d, 0x03, 0xfe, 0x04, 0x8d, 0xbe, 0x0b, 0xcb, 0xbd, 0xf4, 0x85, 0x13,
+	0x35, 0x93, 0x7d, 0x99, 0x67, 0x5e, 0x7b, 0xc3, 0x84, 0xa6, 0x01, 0xba, 0x07, 0xb5, 0x9f, 0x24,
+	0xe3, 0x6f, 0xb4, 0x2e, 0x88, 0xd4, 0xc1, 0xbc, 0xfd, 0x9e, 0x8e, 0xe4, 0xfb, 0x2e, 0x93, 0xd9,
+	0xaa, 0xdc, 0xa7, 0x4e, 0x75, 0xe5, 0xbe, 0xec, 0x08, 0x76, 0x1f, 0xea, 0x7d, 0xf5, 0x65, 0x12,
+	0x6d, 0x26, 0xef, 0xcc, 0xb9, 0x47, 0x52, 0xbb, 0x65, 0x5e, 0xa0, 0x01, 0xba, 0x0f, 0x2b, 0x54,
+	0x79, 0xc4, 0x43, 0x89, 0x6e, 0xb9, 0x67, 0x46, 0x7b, 0xd3, 0x88, 0xa7, 0x01, 0xfa, 0x31, 0x6c,
+	0xf6, 0xcd, 0x2f, 0x68, 0xe8, 0x56, 0x8e, 0xab, 0xfe, 0x82, 0x65, 0xe3, 0xeb, 0x48, 0x68, 0x80,
+	0xce, 0x61, 0xab, 0x5f, 0xf4, 0x1c, 0x85, 0x3e, 0x4a, 0x3f, 0x50, 0xf8, 0x4e, 0x66, 0xdf, 0xbe,
+	0x9e, 0x88, 0x06, 0xe8, 0x19, 0xa0, 0x48, 0x7b, 0x93, 0x41, 0xdb, 0x62, 0xaf, 0xf1, 0xbd, 0xc9,
+	0xfe, 0xa0, 0x64, 0x95, 0x06, 0xa8, 0x07, 0xad, 0x7e, 0xc1, 0xc0, 0x1f, 0xe1, 0xcc, 0x9f, 0x02,
+	0x8c, 0x8f, 0x1d, 0xf6, 0x47, 0xd7, 0xd2, 0x70, 0xb9, 0xfb, 0xda, 0xc4, 0x5a, 0xca, 0x6d, 0x1c,
+	0xb8, 0x4b, 0xb9, 0x0b, 0x46, 0xdd, 0xcf, 0x61, 0xbd, 0xaf, 0x8f, 0x70, 0x91, 0x79, 0x97, 0xf4,
+	0xb2, 0x9b, 0x65, 0xcb, 0x34, 0x40, 0xc7, 0xd0, 0xb8, 0xc8, 0xce, 0x24, 0x51, 0xf2, 0xcf, 0x08,
+	0x7d, 0x34, 0x6b, 0xdb, 0x45, 0x4b, 0x52, 0xe5, 0xdc, 0x90, 0x4f, 0x55, 0x59, 0x9f, 0x3b, 0xaa,
+	0x2a, 0x9b, 0xa6, 0x83, 0x27, 0xb0, 0x36, 0xc8, 0xcf, 0xbd, 0xd0, 0xfb, 0xc9, 0xa8, 0xca, 0x30,
+	0xc8, 0xb3, 0xb7, 0x8b, 0x17, 0xf9, 0xf7, 0xfa, 0xf9, 0x99, 0x92, 0xfc, 0x9e, 0x69, 0xbc, 0x65,
+	0x6f, 0x17, 0x2f, 0xf2, 0x40, 0x55, 0x5b, 0x1f, 0x19, 0xa8, 0xb9, 0xf6, 0xca, 0xde, 0x34, 0xe2,
+	0x69, 0x80, 0x3e, 0x81, 0xa5, 0x04, 0x87, 0x50, 0x8e, 0x28, 0xde, 0xb8, 0xae, 0xe1, 0x78, 0x6a,
+	0x92, 0x39, 0x03, 0xe5, 0x29, 0xa8, 0x9a, 0x9a, 0xb2, 0x13, 0x86, 0x67, 0xb2, 0xef, 0x55, 0x5a,
+	0x62, 0x79, 0x40, 0xc6, 0xd6, 0x5c, 0x1e, 0x90, 0xb9, 0x97, 0x8e, 0xbd, 0x27, 0xd7, 0xc2, 0x4a,
+	0xef, 0xd1, 0x5b, 0x6c, 0xe9, 0x3d, 0x86, 0xae, 0x37, 0xce, 0xf2, 0x4a, 0x9f, 0x2a, 0xb3, 0x7c,
+	0xb6, 0x13, 0x96, 0x59, 0x3e, 0xd7, 0xd2, 0xc6, 0xaa, 0xe9, 0x9d, 0x58, 0x41, 0xb8, 0x89, 0x16,
+	0xa0, 0x20, 0xdc, 0x64, 0x55, 0xfe, 0x02, 0x9a, 0xc6, 0x56, 0x04, 0x7d, 0x28, 0xf6, 0x15, 0xb5,
+	0x4d, 0xf6, 0x4e, 0x39, 0x01, 0x17, 0x57, 0xef, 0x05, 0xa4, 0xb8, 0xc6, 0x8e, 0x45, 0x8a, 0x5b,
+	0xd0, 0x44, 0xdc, 0x87, 0x15, 0xb5, 0x4e, 0x97, 0xae, 0x98, 0xeb, 0x13, 0xa4, 0x2b, 0x6a, 0x45,
+	0xfd, 0x31, 0x34, 0x72, 0x95, 0xa1, 0x3c, 0x4a, 0xbd, 0x7a, 0x95, 0x47, 0x69, 0x2a, 0x26, 0x5f,
+	0x40, 0xd3, 0x58, 0x69, 0x4a, 0xcb, 0x15, 0xd5, 0xc4, 0xd2, 0x72, 0xc5, 0x85, 0xea, 0x3d, 0xa8,
+	0x49, 0xb4, 0xf4, 0x7d, 0xb5, 0xaa, 0x93, 0xbe, 0x9f, 0x2d, 0xbe, 0x8e, 0xa1, 0x91, 0xfb, 0xa8,
+	0xd4, 0x4e, 0xaf, 0x0c, 0xa5, 0x76, 0xa6, 0x32, 0xee, 0x47, 0xb0, 0x61, 0xae, 0x74, 0xd0, 0x4e,
+	0xee, 0x3a, 0xd6, 0x2a, 0x36, 0xfb, 0xd6, 0x35, 0x14, 0x34, 0xd8, 0x6f, 0xbc, 0xa8, 0xef, 0xf2,
+	0x3f, 0xe2, 0x7d, 0xca, 0x7e, 0x3f, 0x5b, 0x60, 0xff, 0xb2, 0xfb, 0xe4, 0x7f, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0x14, 0x45, 0xba, 0x3b, 0xa4, 0x27, 0x00, 0x00,
 }

pkg/proto/group/group.proto

@@ -380,6 +380,19 @@ message CancelMuteGroupResp{
 
 
 
+message SetGroupMemberNicknameReq{
+  string groupID = 1;
+  string nickname = 2;
+  string opUserID = 3;
+  string operationID = 4;
+  string userID = 5;
+}
+message SetGroupMemberNicknameResp{
+  CommonResp CommonResp = 1;
+}
+
+
+
 
 service group{
   rpc createGroup(CreateGroupReq) returns(CreateGroupResp);
@@ -413,6 +426,9 @@ service group{
   rpc CancelMuteGroupMember(CancelMuteGroupMemberReq) returns(CancelMuteGroupMemberResp);
   rpc MuteGroup(MuteGroupReq) returns(MuteGroupResp);
   rpc CancelMuteGroup(CancelMuteGroupReq) returns(CancelMuteGroupResp);
+
+  rpc SetGroupMemberNickname(SetGroupMemberNicknameReq) returns (SetGroupMemberNicknameResp);
+
 }
 
 

pkg/proto/office/office.proto

@@ -106,6 +106,167 @@ message GetUserTagByIDResp {
   Tag tag = 2;
 }
 
+/// WorkMoment
+
+message LikeUser {
+  string userID = 1;
+  string userName = 2;
+}
+
+message NotificationUser {
+  string userID = 1;
+  string userName = 2;
+}
+
+message Comment {
+  string userID = 1;
+  string userName = 2;
+  string faceURL = 3;
+  string replyUserID = 4;
+  string replyUserName = 5;
+  string contentID = 6;
+  string content = 7;
+  int32  createTime = 8;
+}
+
+message PermissionGroup {
+  string groupName = 1;
+  string groupID = 2;
+}
+
+message WorkMomentUser {
+   string userID = 1;
+   string userName = 2;
+}
+
+message WorkMoment {
+  string workMomentID = 1;
+  string userID = 2;
+  string userName = 3;
+  string faceURL = 4;
+  string content = 5;
+  repeated WorkMomentUser likeUserList = 6;
+  repeated Comment comments = 7;
+  int32 permission = 8;
+  repeated WorkMomentUser permissionUserList = 9;
+  repeated PermissionGroup permissionGroupList = 10;
+  repeated WorkMomentUser atUserList = 11;
+  int32 createTime = 12;
+}
+
+message CreateOneWorkMomentReq {
+  WorkMoment workMoment = 1;
+  string operationID = 2;
+}
+
+message CreateOneWorkMomentResp {
+  CommonResp commonResp = 1;
+}
+
+message DeleteOneWorkMomentReq {
+  string workMomentID = 1;
+  string userID = 2;
+  string operationID = 3;
+}
+
+message DeleteOneWorkMomentResp {
+  CommonResp commonResp = 1;
+}
+
+message LikeOneWorkMomentReq {
+  string userID = 1;
+  string WorkMomentID = 2;
+  string operationID = 3;
+}
+
+message LikeOneWorkMomentResp {
+  CommonResp commonResp = 1;
+}
+
+message CommentOneWorkMomentReq {
+  string userID = 1;
+  string workMomentID = 2;
+  string replyUserID = 3;
+  string content = 4;
+  string operationID = 5;
+}
+
+message CommentOneWorkMomentResp {
+  CommonResp commonResp = 1;
+}
+
+message GetWorkMomentByIDReq {
+  string workMomentID = 1;
+  string opUserID = 2;
+  string operationID = 3;
+}
+
+message GetWorkMomentByIDResp {
+  CommonResp commonResp = 1;
+  WorkMoment workMoment = 2;
+}
+
+message ChangeWorkMomentPermissionReq {
+  string workMomentID = 1;
+  string opUserID = 2;
+  int32 permission = 3;
+  repeated string permissionUserIDList = 4;
+  string operationID = 5;
+}
+
+message ChangeWorkMomentPermissionResp {
+  CommonResp commonResp = 1;
+}
+
+message GetUserWorkMomentsReq {
+  string userID = 1;
+  string opUserID = 2;
+  server_api_params.RequestPagination Pagination = 3;
+  string operationID = 4;
+}
+
+message GetUserWorkMomentsResp {
+  CommonResp commonResp = 1;
+  repeated WorkMoment workMoments = 2;
+  server_api_params.ResponsePagination Pagination = 3;
+}
+
+message GetUserFriendWorkMomentsReq {
+  string userID = 1;
+  server_api_params.RequestPagination Pagination = 2;
+  string operationID = 3;
+}
+
+message GetUserFriendWorkMomentsResp {
+  CommonResp commonResp = 1;
+  repeated WorkMoment workMoments = 2;
+  server_api_params.ResponsePagination Pagination = 3;
+}
+
+message WorkMomentNotificationMsg {
+  int32 notificationMsgType = 1;
+  string replyUserName = 2;
+  string replyUserID = 3;
+  string content = 4;
+  string contentID = 5;
+  string workMomentID = 6;
+  string userID = 7;
+  string userName = 8;
+  string faceURL = 9;
+  string workMomentContent = 10;
+  int32 createTime = 11;
+}
+
+message SetUserWorkMomentsLevelReq {
+  string userID = 1;
+  int32 level = 2;
+  string operationID = 3;
+}
+
+message SetUserWorkMomentsLevelResp {
+  CommonResp commonResp = 1;
+}
+
 service OfficeService {
   rpc GetUserTags(GetUserTagsReq) returns(GetUserTagsResp);
   rpc CreateTag(CreateTagReq) returns(CreateTagResp);
@@ -114,5 +275,17 @@ service OfficeService {
   rpc SendMsg2Tag(SendMsg2TagReq) returns(SendMsg2TagResp);
   rpc GetTagSendLogs(GetTagSendLogsReq) returns(GetTagSendLogsResp);
   rpc GetUserTagByID(GetUserTagByIDReq) returns(GetUserTagByIDResp);
+
+  rpc CreateOneWorkMoment(CreateOneWorkMomentReq) returns(CreateOneWorkMomentResp);
+  rpc DeleteOneWorkMoment(DeleteOneWorkMomentReq) returns(DeleteOneWorkMomentResp);
+  rpc LikeOneWorkMoment(LikeOneWorkMomentReq) returns(LikeOneWorkMomentResp);
+  rpc CommentOneWorkMoment(CommentOneWorkMomentReq) returns(CommentOneWorkMomentResp);
+  rpc GetWorkMomentByID(GetWorkMomentByIDReq) returns(GetWorkMomentByIDResp);
+  rpc ChangeWorkMomentPermission(ChangeWorkMomentPermissionReq) returns(ChangeWorkMomentPermissionResp);
+  /// user self
+  rpc GetUserWorkMoments(GetUserWorkMomentsReq) returns(GetUserWorkMomentsResp);
+  /// users friend
+  rpc GetUserFriendWorkMoments(GetUserFriendWorkMomentsReq) returns(GetUserFriendWorkMomentsResp);
+  rpc SetUserWorkMomentsLevel(SetUserWorkMomentsLevelReq) returns(SetUserWorkMomentsLevelResp);
 }
 

pkg/proto/organization/organization.proto

@@ -0,0 +1,172 @@
+syntax = "proto3";
+import "Open_IM/pkg/proto/sdk_ws/ws.proto";
+option go_package = "./organization;organization";
+package organization;
+
+
+message CreateDepartmentReq{
+  server_api_params.Department departmentInfo = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+
+message CreateDepartmentResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+  server_api_params.Department departmentInfo = 3;
+}
+
+message UpdateDepartmentReq{
+  server_api_params.Department departmentInfo = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+
+message UpdateDepartmentResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+
+message GetSubDepartmentReq{
+  string departmentID = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+
+message GetSubDepartmentResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+  repeated server_api_params.Department departmentList = 3;
+}
+
+message DeleteDepartmentReq{
+  string departmentID = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+
+message DeleteDepartmentResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+
+message CreateOrganizationUserReq{
+  server_api_params.OrganizationUser organizationUser = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+
+
+message CreateOrganizationUserResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+
+message UpdateOrganizationUserReq{
+  server_api_params.OrganizationUser organizationUser = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+
+
+message UpdateOrganizationUserResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+
+
+
+message CreateDepartmentMemberReq{
+  server_api_params.DepartmentMember departmentMember = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+message CreateDepartmentMemberResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+
+message GetUserInDepartmentReq{
+  string userID = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+message GetUserInDepartmentResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+  server_api_params.UserInDepartment userInDepartment = 3;
+}
+
+
+message UpdateUserInDepartmentReq{
+  server_api_params.DepartmentMember departmentMember = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+message UpdateUserInDepartmentResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+
+message DeleteUserInDepartmentReq{
+  string userID = 1;
+  string operationID = 2;
+  string opUserID = 3;
+  string departmentID = 4;
+}
+message DeleteUserInDepartmentResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+message DeleteOrganizationUserReq{
+  string userID = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+message DeleteOrganizationUserResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+
+message GetDepartmentMemberReq{
+  string departmentID = 1;
+  string operationID = 2;
+  string opUserID = 3;
+}
+
+message GetDepartmentMemberResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+  repeated  server_api_params.UserDepartmentMember userDepartmentMemberList = 3;
+}
+
+
+service organization{
+  rpc CreateDepartment(CreateDepartmentReq) returns(CreateDepartmentResp);
+  rpc UpdateDepartment(UpdateDepartmentReq) returns(UpdateDepartmentResp);
+  rpc GetSubDepartment(GetSubDepartmentReq) returns(GetSubDepartmentResp);
+  rpc DeleteDepartment(DeleteDepartmentReq) returns(DeleteDepartmentResp);
+
+  rpc CreateOrganizationUser(CreateOrganizationUserReq) returns(CreateOrganizationUserResp);
+  rpc UpdateOrganizationUser(UpdateOrganizationUserReq) returns(UpdateOrganizationUserResp);
+  rpc DeleteOrganizationUser(DeleteOrganizationUserReq) returns(DeleteOrganizationUserResp);
+
+
+  rpc CreateDepartmentMember(CreateDepartmentMemberReq) returns(CreateDepartmentMemberResp);
+  rpc GetUserInDepartment(GetUserInDepartmentReq) returns(GetUserInDepartmentResp);
+  rpc DeleteUserInDepartment(DeleteUserInDepartmentReq) returns(DeleteUserInDepartmentResp);
+  rpc UpdateUserInDepartment(UpdateUserInDepartmentReq) returns(UpdateUserInDepartmentResp);
+  rpc GetDepartmentMember(GetDepartmentMemberReq) returns(GetDepartmentMemberResp);
+}
+
+
+
+

pkg/proto/proto_dir.cfg

@@ -12,4 +12,5 @@ all_proto=(
             push/push.proto
             relay/relay.proto
             sdk_ws/ws.proto
+            conversation/conversation.proto
 )

pkg/proto/sdk_ws/ws.proto

@@ -105,8 +105,71 @@ message FriendRequest{
   string ex = 15;
 }
 
-///////////////////////////////////base end/////////////////////////////////////
+///////////////////////////////////organization/////////////////////////////////////
 
+message Department {
+  string departmentID = 1;
+  string faceURL = 2;
+  string name = 3;
+  string parentID = 4;
+  int32 order = 5;
+  int32 departmentType = 6;
+  uint32 createTime = 7;
+  uint32 subDepartmentNum = 8;
+  uint32 memberNum = 9;
+  string ex        = 10;
+}
+
+
+
+message OrganizationUser  {
+    string userID      = 1;
+    string  nickname    = 2;
+    string   englishName = 3;
+    string  faceURL    = 4;
+    int32   gender     = 5;
+    string   mobile      = 6;
+    string telephone   = 7;
+    uint32 birth     = 8;
+    string  email    = 9;
+    uint32   createTime = 10;
+    string ex      = 11;
+}
+
+message DepartmentMember {
+      string userID = 1;
+      string departmentID = 2;
+      int32 order = 3;
+      string position = 4;
+      int32 leader = 5;
+      int32 status = 6;
+      string ex     = 7;
+}
+
+
+message  UserDepartmentMember {
+  OrganizationUser organizationUser = 1;
+  DepartmentMember departmentMember = 2;
+}
+
+
+message  UserInDepartment {
+  OrganizationUser organizationUser = 1;
+  repeated DepartmentMember departmentMemberList = 2;
+}
+
+
+
+
+
+///////////////////////////////////organization end//////////////////////////////////
+
+
+
+
+
+
+///////////////////////////////////base end/////////////////////////////////////
 
 message PullMessageBySeqListResp {
   int32 errCode = 1;
@@ -150,8 +213,9 @@ message MsgData {
   int32 status = 17;
   map<string, bool> options = 18;
   OfflinePushInfo offlinePushInfo = 19;
-}
+  repeated string atUserIDList = 20;
 
+}
 message OfflinePushInfo{
   string title = 1;
   string desc = 2;
@@ -288,6 +352,19 @@ message GroupCancelMutedTips{
   int64 operationTime = 3;
 }
 
+message GroupMemberInfoSetTips{
+  GroupInfo group = 1;
+  GroupMemberFullInfo opUser = 2;
+  int64 operationTime = 3;
+  GroupMemberFullInfo changedUser = 4;
+}
+
+
+message OrganizationChangedTips{
+  UserInfo opUser = 2;
+  int64 operationTime = 3;
+}
+
 
 //////////////////////friend/////////////////////
 //message FriendInfo{

pkg/proto/user/user.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_user_6133bd34462fbb1a, []int{0}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{0}
 }
 func (m *CommonResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@@ -83,7 +83,7 @@ func (m *DeleteUsersReq) Reset()         { *m = DeleteUsersReq{} }
 func (m *DeleteUsersReq) String() string { return proto.CompactTextString(m) }
 func (*DeleteUsersReq) ProtoMessage()    {}
 func (*DeleteUsersReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{1}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{1}
 }
 func (m *DeleteUsersReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteUsersReq.Unmarshal(m, b)
@@ -136,7 +136,7 @@ func (m *DeleteUsersResp) Reset()         { *m = DeleteUsersResp{} }
 func (m *DeleteUsersResp) String() string { return proto.CompactTextString(m) }
 func (*DeleteUsersResp) ProtoMessage()    {}
 func (*DeleteUsersResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{2}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{2}
 }
 func (m *DeleteUsersResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteUsersResp.Unmarshal(m, b)
@@ -182,7 +182,7 @@ func (m *GetAllUserIDReq) Reset()         { *m = GetAllUserIDReq{} }
 func (m *GetAllUserIDReq) String() string { return proto.CompactTextString(m) }
 func (*GetAllUserIDReq) ProtoMessage()    {}
 func (*GetAllUserIDReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{3}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{3}
 }
 func (m *GetAllUserIDReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetAllUserIDReq.Unmarshal(m, b)
@@ -228,7 +228,7 @@ func (m *GetAllUserIDResp) Reset()         { *m = GetAllUserIDResp{} }
 func (m *GetAllUserIDResp) String() string { return proto.CompactTextString(m) }
 func (*GetAllUserIDResp) ProtoMessage()    {}
 func (*GetAllUserIDResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{4}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{4}
 }
 func (m *GetAllUserIDResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetAllUserIDResp.Unmarshal(m, b)
@@ -275,7 +275,7 @@ func (m *AccountCheckReq) Reset()         { *m = AccountCheckReq{} }
 func (m *AccountCheckReq) String() string { return proto.CompactTextString(m) }
 func (*AccountCheckReq) ProtoMessage()    {}
 func (*AccountCheckReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{5}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{5}
 }
 func (m *AccountCheckReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AccountCheckReq.Unmarshal(m, b)
@@ -328,7 +328,7 @@ func (m *AccountCheckResp) Reset()         { *m = AccountCheckResp{} }
 func (m *AccountCheckResp) String() string { return proto.CompactTextString(m) }
 func (*AccountCheckResp) ProtoMessage()    {}
 func (*AccountCheckResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{6}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{6}
 }
 func (m *AccountCheckResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AccountCheckResp.Unmarshal(m, b)
@@ -374,7 +374,7 @@ func (m *AccountCheckResp_SingleUserStatus) Reset()         { *m = AccountCheckR
 func (m *AccountCheckResp_SingleUserStatus) String() string { return proto.CompactTextString(m) }
 func (*AccountCheckResp_SingleUserStatus) ProtoMessage()    {}
 func (*AccountCheckResp_SingleUserStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{6, 0}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{6, 0}
 }
 func (m *AccountCheckResp_SingleUserStatus) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AccountCheckResp_SingleUserStatus.Unmarshal(m, b)
@@ -421,7 +421,7 @@ 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_user_6133bd34462fbb1a, []int{7}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{7}
 }
 func (m *GetUserInfoReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserInfoReq.Unmarshal(m, b)
@@ -474,7 +474,7 @@ 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_user_6133bd34462fbb1a, []int{8}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{8}
 }
 func (m *GetUserInfoResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserInfoResp.Unmarshal(m, b)
@@ -521,7 +521,7 @@ 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_user_6133bd34462fbb1a, []int{9}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{9}
 }
 func (m *UpdateUserInfoReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UpdateUserInfoReq.Unmarshal(m, b)
@@ -573,7 +573,7 @@ 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_user_6133bd34462fbb1a, []int{10}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{10}
 }
 func (m *UpdateUserInfoResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UpdateUserInfoResp.Unmarshal(m, b)
@@ -612,7 +612,9 @@ type Conversation struct {
 	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"`
-	Ex                   string   `protobuf:"bytes,12,opt,name=Ex" json:"Ex,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:"-"`
@@ -622,7 +624,7 @@ 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_user_6133bd34462fbb1a, []int{11}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{11}
 }
 func (m *Conversation) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Conversation.Unmarshal(m, b)
@@ -719,6 +721,20 @@ func (m *Conversation) GetIsPrivateChat() bool {
 	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
@@ -739,7 +755,7 @@ func (m *SetConversationReq) Reset()         { *m = SetConversationReq{} }
 func (m *SetConversationReq) String() string { return proto.CompactTextString(m) }
 func (*SetConversationReq) ProtoMessage()    {}
 func (*SetConversationReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{12}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{12}
 }
 func (m *SetConversationReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetConversationReq.Unmarshal(m, b)
@@ -791,7 +807,7 @@ func (m *SetConversationResp) Reset()         { *m = SetConversationResp{} }
 func (m *SetConversationResp) String() string { return proto.CompactTextString(m) }
 func (*SetConversationResp) ProtoMessage()    {}
 func (*SetConversationResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{13}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{13}
 }
 func (m *SetConversationResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetConversationResp.Unmarshal(m, b)
@@ -833,7 +849,7 @@ func (m *SetRecvMsgOptReq) Reset()         { *m = SetRecvMsgOptReq{} }
 func (m *SetRecvMsgOptReq) String() string { return proto.CompactTextString(m) }
 func (*SetRecvMsgOptReq) ProtoMessage()    {}
 func (*SetRecvMsgOptReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{14}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{14}
 }
 func (m *SetRecvMsgOptReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetRecvMsgOptReq.Unmarshal(m, b)
@@ -899,7 +915,7 @@ func (m *SetRecvMsgOptResp) Reset()         { *m = SetRecvMsgOptResp{} }
 func (m *SetRecvMsgOptResp) String() string { return proto.CompactTextString(m) }
 func (*SetRecvMsgOptResp) ProtoMessage()    {}
 func (*SetRecvMsgOptResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{15}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{15}
 }
 func (m *SetRecvMsgOptResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetRecvMsgOptResp.Unmarshal(m, b)
@@ -939,7 +955,7 @@ func (m *GetConversationReq) Reset()         { *m = GetConversationReq{} }
 func (m *GetConversationReq) String() string { return proto.CompactTextString(m) }
 func (*GetConversationReq) ProtoMessage()    {}
 func (*GetConversationReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{16}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{16}
 }
 func (m *GetConversationReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetConversationReq.Unmarshal(m, b)
@@ -992,7 +1008,7 @@ func (m *GetConversationResp) Reset()         { *m = GetConversationResp{} }
 func (m *GetConversationResp) String() string { return proto.CompactTextString(m) }
 func (*GetConversationResp) ProtoMessage()    {}
 func (*GetConversationResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{17}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{17}
 }
 func (m *GetConversationResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetConversationResp.Unmarshal(m, b)
@@ -1039,7 +1055,7 @@ func (m *GetConversationsReq) Reset()         { *m = GetConversationsReq{} }
 func (m *GetConversationsReq) String() string { return proto.CompactTextString(m) }
 func (*GetConversationsReq) ProtoMessage()    {}
 func (*GetConversationsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{18}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{18}
 }
 func (m *GetConversationsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetConversationsReq.Unmarshal(m, b)
@@ -1092,7 +1108,7 @@ func (m *GetConversationsResp) Reset()         { *m = GetConversationsResp{} }
 func (m *GetConversationsResp) String() string { return proto.CompactTextString(m) }
 func (*GetConversationsResp) ProtoMessage()    {}
 func (*GetConversationsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{19}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{19}
 }
 func (m *GetConversationsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetConversationsResp.Unmarshal(m, b)
@@ -1138,7 +1154,7 @@ func (m *GetAllConversationsReq) Reset()         { *m = GetAllConversationsReq{}
 func (m *GetAllConversationsReq) String() string { return proto.CompactTextString(m) }
 func (*GetAllConversationsReq) ProtoMessage()    {}
 func (*GetAllConversationsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{20}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{20}
 }
 func (m *GetAllConversationsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetAllConversationsReq.Unmarshal(m, b)
@@ -1184,7 +1200,7 @@ func (m *GetAllConversationsResp) Reset()         { *m = GetAllConversationsResp
 func (m *GetAllConversationsResp) String() string { return proto.CompactTextString(m) }
 func (*GetAllConversationsResp) ProtoMessage()    {}
 func (*GetAllConversationsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{21}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{21}
 }
 func (m *GetAllConversationsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetAllConversationsResp.Unmarshal(m, b)
@@ -1232,7 +1248,7 @@ func (m *BatchSetConversationsReq) Reset()         { *m = BatchSetConversationsR
 func (m *BatchSetConversationsReq) String() string { return proto.CompactTextString(m) }
 func (*BatchSetConversationsReq) ProtoMessage()    {}
 func (*BatchSetConversationsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{22}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{22}
 }
 func (m *BatchSetConversationsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BatchSetConversationsReq.Unmarshal(m, b)
@@ -1293,7 +1309,7 @@ func (m *BatchSetConversationsResp) Reset()         { *m = BatchSetConversations
 func (m *BatchSetConversationsResp) String() string { return proto.CompactTextString(m) }
 func (*BatchSetConversationsResp) ProtoMessage()    {}
 func (*BatchSetConversationsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{23}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{23}
 }
 func (m *BatchSetConversationsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BatchSetConversationsResp.Unmarshal(m, b)
@@ -1346,7 +1362,7 @@ func (m *ResignUserReq) Reset()         { *m = ResignUserReq{} }
 func (m *ResignUserReq) String() string { return proto.CompactTextString(m) }
 func (*ResignUserReq) ProtoMessage()    {}
 func (*ResignUserReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{24}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{24}
 }
 func (m *ResignUserReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResignUserReq.Unmarshal(m, b)
@@ -1391,7 +1407,7 @@ func (m *ResignUserResp) Reset()         { *m = ResignUserResp{} }
 func (m *ResignUserResp) String() string { return proto.CompactTextString(m) }
 func (*ResignUserResp) ProtoMessage()    {}
 func (*ResignUserResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{25}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{25}
 }
 func (m *ResignUserResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResignUserResp.Unmarshal(m, b)
@@ -1430,7 +1446,7 @@ func (m *GetUserByIdReq) Reset()         { *m = GetUserByIdReq{} }
 func (m *GetUserByIdReq) String() string { return proto.CompactTextString(m) }
 func (*GetUserByIdReq) ProtoMessage()    {}
 func (*GetUserByIdReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{26}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{26}
 }
 func (m *GetUserByIdReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserByIdReq.Unmarshal(m, b)
@@ -1479,7 +1495,7 @@ func (m *User) Reset()         { *m = User{} }
 func (m *User) String() string { return proto.CompactTextString(m) }
 func (*User) ProtoMessage()    {}
 func (*User) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{27}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{27}
 }
 func (m *User) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_User.Unmarshal(m, b)
@@ -1546,7 +1562,7 @@ func (m *GetUserByIdResp) Reset()         { *m = GetUserByIdResp{} }
 func (m *GetUserByIdResp) String() string { return proto.CompactTextString(m) }
 func (*GetUserByIdResp) ProtoMessage()    {}
 func (*GetUserByIdResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{28}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{28}
 }
 func (m *GetUserByIdResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserByIdResp.Unmarshal(m, b)
@@ -1593,7 +1609,7 @@ func (m *GetUsersByNameReq) Reset()         { *m = GetUsersByNameReq{} }
 func (m *GetUsersByNameReq) String() string { return proto.CompactTextString(m) }
 func (*GetUsersByNameReq) ProtoMessage()    {}
 func (*GetUsersByNameReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{29}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{29}
 }
 func (m *GetUsersByNameReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUsersByNameReq.Unmarshal(m, b)
@@ -1647,7 +1663,7 @@ func (m *GetUsersByNameResp) Reset()         { *m = GetUsersByNameResp{} }
 func (m *GetUsersByNameResp) String() string { return proto.CompactTextString(m) }
 func (*GetUsersByNameResp) ProtoMessage()    {}
 func (*GetUsersByNameResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{30}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{30}
 }
 func (m *GetUsersByNameResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUsersByNameResp.Unmarshal(m, b)
@@ -1704,7 +1720,7 @@ func (m *AlterUserReq) Reset()         { *m = AlterUserReq{} }
 func (m *AlterUserReq) String() string { return proto.CompactTextString(m) }
 func (*AlterUserReq) ProtoMessage()    {}
 func (*AlterUserReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{31}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{31}
 }
 func (m *AlterUserReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AlterUserReq.Unmarshal(m, b)
@@ -1777,7 +1793,7 @@ func (m *AlterUserResp) Reset()         { *m = AlterUserResp{} }
 func (m *AlterUserResp) String() string { return proto.CompactTextString(m) }
 func (*AlterUserResp) ProtoMessage()    {}
 func (*AlterUserResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{32}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{32}
 }
 func (m *AlterUserResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AlterUserResp.Unmarshal(m, b)
@@ -1817,7 +1833,7 @@ func (m *GetUsersReq) Reset()         { *m = GetUsersReq{} }
 func (m *GetUsersReq) String() string { return proto.CompactTextString(m) }
 func (*GetUsersReq) ProtoMessage()    {}
 func (*GetUsersReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{33}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{33}
 }
 func (m *GetUsersReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUsersReq.Unmarshal(m, b)
@@ -1872,7 +1888,7 @@ func (m *GetUsersResp) Reset()         { *m = GetUsersResp{} }
 func (m *GetUsersResp) String() string { return proto.CompactTextString(m) }
 func (*GetUsersResp) ProtoMessage()    {}
 func (*GetUsersResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{34}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{34}
 }
 func (m *GetUsersResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUsersResp.Unmarshal(m, b)
@@ -1935,7 +1951,7 @@ func (m *AddUserReq) Reset()         { *m = AddUserReq{} }
 func (m *AddUserReq) String() string { return proto.CompactTextString(m) }
 func (*AddUserReq) ProtoMessage()    {}
 func (*AddUserReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{35}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{35}
 }
 func (m *AddUserReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddUserReq.Unmarshal(m, b)
@@ -2001,7 +2017,7 @@ func (m *AddUserResp) Reset()         { *m = AddUserResp{} }
 func (m *AddUserResp) String() string { return proto.CompactTextString(m) }
 func (*AddUserResp) ProtoMessage()    {}
 func (*AddUserResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{36}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{36}
 }
 func (m *AddUserResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddUserResp.Unmarshal(m, b)
@@ -2042,7 +2058,7 @@ func (m *BlockUserReq) Reset()         { *m = BlockUserReq{} }
 func (m *BlockUserReq) String() string { return proto.CompactTextString(m) }
 func (*BlockUserReq) ProtoMessage()    {}
 func (*BlockUserReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{37}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{37}
 }
 func (m *BlockUserReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlockUserReq.Unmarshal(m, b)
@@ -2101,7 +2117,7 @@ func (m *BlockUserResp) Reset()         { *m = BlockUserResp{} }
 func (m *BlockUserResp) String() string { return proto.CompactTextString(m) }
 func (*BlockUserResp) ProtoMessage()    {}
 func (*BlockUserResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{38}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{38}
 }
 func (m *BlockUserResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlockUserResp.Unmarshal(m, b)
@@ -2141,7 +2157,7 @@ func (m *UnBlockUserReq) Reset()         { *m = UnBlockUserReq{} }
 func (m *UnBlockUserReq) String() string { return proto.CompactTextString(m) }
 func (*UnBlockUserReq) ProtoMessage()    {}
 func (*UnBlockUserReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{39}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{39}
 }
 func (m *UnBlockUserReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UnBlockUserReq.Unmarshal(m, b)
@@ -2193,7 +2209,7 @@ func (m *UnBlockUserResp) Reset()         { *m = UnBlockUserResp{} }
 func (m *UnBlockUserResp) String() string { return proto.CompactTextString(m) }
 func (*UnBlockUserResp) ProtoMessage()    {}
 func (*UnBlockUserResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{40}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{40}
 }
 func (m *UnBlockUserResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UnBlockUserResp.Unmarshal(m, b)
@@ -2233,7 +2249,7 @@ func (m *GetBlockUsersReq) Reset()         { *m = GetBlockUsersReq{} }
 func (m *GetBlockUsersReq) String() string { return proto.CompactTextString(m) }
 func (*GetBlockUsersReq) ProtoMessage()    {}
 func (*GetBlockUsersReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{41}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{41}
 }
 func (m *GetBlockUsersReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlockUsersReq.Unmarshal(m, b)
@@ -2287,7 +2303,7 @@ func (m *BlockUser) Reset()         { *m = BlockUser{} }
 func (m *BlockUser) String() string { return proto.CompactTextString(m) }
 func (*BlockUser) ProtoMessage()    {}
 func (*BlockUser) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{42}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{42}
 }
 func (m *BlockUser) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BlockUser.Unmarshal(m, b)
@@ -2342,7 +2358,7 @@ func (m *GetBlockUsersResp) Reset()         { *m = GetBlockUsersResp{} }
 func (m *GetBlockUsersResp) String() string { return proto.CompactTextString(m) }
 func (*GetBlockUsersResp) ProtoMessage()    {}
 func (*GetBlockUsersResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{43}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{43}
 }
 func (m *GetBlockUsersResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlockUsersResp.Unmarshal(m, b)
@@ -2402,7 +2418,7 @@ func (m *GetBlockUserByIdReq) Reset()         { *m = GetBlockUserByIdReq{} }
 func (m *GetBlockUserByIdReq) String() string { return proto.CompactTextString(m) }
 func (*GetBlockUserByIdReq) ProtoMessage()    {}
 func (*GetBlockUserByIdReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{44}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{44}
 }
 func (m *GetBlockUserByIdReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlockUserByIdReq.Unmarshal(m, b)
@@ -2447,7 +2463,7 @@ func (m *GetBlockUserByIdResp) Reset()         { *m = GetBlockUserByIdResp{} }
 func (m *GetBlockUserByIdResp) String() string { return proto.CompactTextString(m) }
 func (*GetBlockUserByIdResp) ProtoMessage()    {}
 func (*GetBlockUserByIdResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{45}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{45}
 }
 func (m *GetBlockUserByIdResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetBlockUserByIdResp.Unmarshal(m, b)
@@ -2487,7 +2503,7 @@ func (m *DeleteUserReq) Reset()         { *m = DeleteUserReq{} }
 func (m *DeleteUserReq) String() string { return proto.CompactTextString(m) }
 func (*DeleteUserReq) ProtoMessage()    {}
 func (*DeleteUserReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{46}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{46}
 }
 func (m *DeleteUserReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteUserReq.Unmarshal(m, b)
@@ -2539,7 +2555,7 @@ func (m *DeleteUserResp) Reset()         { *m = DeleteUserResp{} }
 func (m *DeleteUserResp) String() string { return proto.CompactTextString(m) }
 func (*DeleteUserResp) ProtoMessage()    {}
 func (*DeleteUserResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_user_6133bd34462fbb1a, []int{47}
+	return fileDescriptor_user_e11c6a5241e13fcd, []int{47}
 }
 func (m *DeleteUserResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteUserResp.Unmarshal(m, b)
@@ -3383,123 +3399,125 @@ var _User_serviceDesc = grpc.ServiceDesc{
 	Metadata: "user/user.proto",
 }
 
-func init() { proto.RegisterFile("user/user.proto", fileDescriptor_user_6133bd34462fbb1a) }
+func init() { proto.RegisterFile("user/user.proto", fileDescriptor_user_e11c6a5241e13fcd) }
 
-var fileDescriptor_user_6133bd34462fbb1a = []byte{
-	// 1835 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x59, 0x5f, 0x6f, 0xdc, 0xc6,
-	0x11, 0x07, 0xef, 0x8f, 0x25, 0xcd, 0xe9, 0x4e, 0xa7, 0x95, 0x2c, 0xd1, 0x6c, 0xab, 0xaa, 0x84,
-	0xeb, 0x0a, 0x02, 0x2a, 0xb5, 0x6e, 0x51, 0x17, 0x2e, 0x5a, 0x5b, 0x77, 0x92, 0x85, 0x2b, 0x62,
-	0xe9, 0xc0, 0xb3, 0x80, 0x20, 0x08, 0x20, 0xd0, 0x77, 0x2b, 0x89, 0xd0, 0x1d, 0x49, 0x73, 0x79,
-	0xb2, 0x95, 0x17, 0x07, 0xf9, 0xf3, 0x12, 0xe4, 0x25, 0x40, 0x00, 0x3b, 0x79, 0xc8, 0xe7, 0xc8,
-	0x7b, 0xf2, 0x94, 0x6f, 0x90, 0xa7, 0x7c, 0x95, 0x60, 0x97, 0x4b, 0x72, 0x77, 0x49, 0x49, 0x17,
-	0x4a, 0xf0, 0x8b, 0xad, 0x9d, 0xdd, 0x1d, 0xfe, 0x66, 0xe6, 0x37, 0xb3, 0xb3, 0x7b, 0x30, 0x37,
-	0x26, 0x38, 0xd8, 0xa4, 0xff, 0x6c, 0xf8, 0x81, 0x17, 0x7a, 0xa8, 0x42, 0xff, 0x36, 0xfe, 0xb4,
-	0xef, 0x63, 0xf7, 0xb0, 0xf3, 0x74, 0xd3, 0x3f, 0x3d, 0xde, 0x64, 0x13, 0x9b, 0x64, 0x70, 0x7a,
-	0xf8, 0x92, 0x6c, 0xbe, 0x24, 0xd1, 0x42, 0xf3, 0x7f, 0x00, 0x6d, 0x6f, 0x34, 0xf2, 0x5c, 0x0b,
-	0x13, 0x1f, 0xe9, 0x30, 0x85, 0x83, 0xa0, 0xed, 0x0d, 0xb0, 0xae, 0xad, 0x6a, 0x6b, 0x55, 0x2b,
-	0x1e, 0xa2, 0x25, 0xb8, 0x85, 0x83, 0xe0, 0x29, 0x39, 0xd6, 0x4b, 0xab, 0xda, 0xda, 0x8c, 0xc5,
-	0x47, 0xe6, 0x47, 0xd0, 0xd8, 0xc6, 0x43, 0x1c, 0xe2, 0x03, 0x82, 0x03, 0x62, 0xe1, 0x17, 0x68,
-	0x1d, 0x9a, 0xa9, 0xa4, 0xb3, 0xfd, 0x9e, 0x43, 0x42, 0xbd, 0xb4, 0x5a, 0x5e, 0x9b, 0xb1, 0x32,
-	0x72, 0x64, 0xc0, 0xf4, 0xbe, 0x1f, 0x8d, 0xf5, 0x32, 0xd3, 0x9b, 0x8c, 0xd1, 0x2a, 0xd4, 0xf6,
-	0x7d, 0x1c, 0xd8, 0xa1, 0xe3, 0xb9, 0x9d, 0x6d, 0xbd, 0xc2, 0xa6, 0x45, 0x91, 0xe9, 0xc1, 0x9c,
-	0xf4, 0x6d, 0xe2, 0xa3, 0xbf, 0x89, 0xe6, 0x30, 0x1b, 0x6a, 0xf7, 0x9b, 0x1b, 0xcc, 0x31, 0xa9,
-	0xdc, 0x12, 0x4d, 0x5e, 0x87, 0xe6, 0x13, 0xdb, 0x19, 0xe2, 0x41, 0x16, 0xae, 0x2a, 0x37, 0xf7,
-	0x61, 0x6e, 0x17, 0x87, 0x5b, 0xc3, 0x61, 0x24, 0xa3, 0xd6, 0x1a, 0x30, 0xed, 0xc5, 0x16, 0x68,
-	0x91, 0x05, 0x9e, 0x60, 0x81, 0x27, 0x58, 0x10, 0x39, 0x4e, 0x14, 0x99, 0x03, 0x68, 0xca, 0x0a,
-	0x0b, 0x99, 0xb0, 0x02, 0x90, 0x01, 0x2f, 0x48, 0xcc, 0x73, 0x98, 0xdb, 0xea, 0xf7, 0xbd, 0xb1,
-	0x1b, 0xb6, 0x4f, 0x70, 0xff, 0x94, 0xc2, 0x5e, 0x83, 0x39, 0xf6, 0xb7, 0xb0, 0x4f, 0x63, 0xfb,
-	0x54, 0xb1, 0x14, 0xa2, 0xd2, 0xe5, 0x21, 0x2a, 0x67, 0x43, 0xf4, 0x8b, 0x06, 0x4d, 0xf9, 0xdb,
-	0x91, 0x85, 0xfd, 0x09, 0x2c, 0x4c, 0xd7, 0xa0, 0x5d, 0x00, 0x0b, 0x93, 0xf1, 0x30, 0x4c, 0x2c,
-	0xac, 0xdd, 0xff, 0x4b, 0xb4, 0x43, 0xd5, 0xbe, 0xd1, 0x73, 0xdc, 0xe3, 0x21, 0xa3, 0x44, 0x2f,
-	0xb4, 0xc3, 0x31, 0xb1, 0x84, 0xad, 0x46, 0x17, 0x9a, 0xea, 0x3c, 0xa5, 0xf6, 0x58, 0x0c, 0x20,
-	0x1f, 0xa1, 0xbb, 0x50, 0xb7, 0x23, 0xe5, 0xd1, 0x42, 0x6e, 0xbe, 0x2c, 0x34, 0x5d, 0x68, 0xec,
-	0xe2, 0x90, 0x39, 0xc4, 0x3d, 0xf2, 0xa8, 0x6f, 0x57, 0x00, 0xc6, 0xaa, 0x5b, 0x05, 0xc9, 0x35,
-	0x3d, 0xfa, 0x99, 0xc6, 0x48, 0x98, 0x7e, 0xb0, 0x90, 0x43, 0x1f, 0xc1, 0x6c, 0xac, 0x81, 0xa1,
-	0x2c, 0x33, 0x97, 0xfe, 0x6e, 0x83, 0xe0, 0xe0, 0x0c, 0x07, 0x87, 0xb6, 0xef, 0x1c, 0xfa, 0x76,
-	0x60, 0x8f, 0xc8, 0x46, 0xf2, 0x21, 0x69, 0x83, 0xf9, 0x85, 0x06, 0xf3, 0x07, 0xfe, 0xc0, 0xe6,
-	0xe9, 0xcc, 0x4d, 0x7f, 0x00, 0xd3, 0xf1, 0x90, 0xc3, 0xb8, 0x54, 0x65, 0xb2, 0xf8, 0x2a, 0x9f,
-	0x78, 0x59, 0x9f, 0x88, 0x69, 0xf4, 0x04, 0x90, 0x8a, 0xa5, 0x88, 0x57, 0xcc, 0xaf, 0xcb, 0x30,
-	0xdb, 0xf6, 0xdc, 0x33, 0x1c, 0x10, 0xa6, 0x9a, 0x85, 0xe3, 0xa5, 0x8b, 0x03, 0x29, 0xc1, 0x45,
-	0x11, 0xba, 0x07, 0x0d, 0x71, 0x47, 0x02, 0x5f, 0x91, 0x52, 0x52, 0x58, 0xb8, 0x7f, 0xf6, 0x94,
-	0x1c, 0xef, 0xfb, 0x21, 0xb3, 0xa1, 0x6a, 0x09, 0x12, 0x5a, 0x86, 0xc4, 0x1d, 0xcf, 0xce, 0x7d,
-	0xcc, 0x4a, 0x5e, 0xd5, 0xca, 0xc8, 0x29, 0x61, 0x39, 0xa0, 0x6a, 0x44, 0x58, 0x8e, 0x45, 0x87,
-	0xa9, 0xdd, 0xc0, 0x1b, 0xfb, 0x9d, 0x6d, 0xfd, 0x16, 0x9b, 0x88, 0x87, 0xd4, 0x8e, 0x03, 0x37,
-	0xc0, 0xf6, 0xa0, 0x4d, 0x99, 0xab, 0x4f, 0x31, 0xc5, 0xa2, 0x88, 0x92, 0x7d, 0x3b, 0xb0, 0x8f,
-	0xc2, 0x67, 0xf8, 0x55, 0xf8, 0xcc, 0x19, 0x61, 0x7d, 0x7a, 0x55, 0x5b, 0x2b, 0x5b, 0xb2, 0x90,
-	0x86, 0xa9, 0x43, 0xba, 0x8e, 0xeb, 0xe2, 0x81, 0x3e, 0xb3, 0xaa, 0xad, 0x4d, 0x5b, 0xc9, 0x18,
-	0x99, 0x30, 0xbb, 0x15, 0x86, 0x76, 0xff, 0x04, 0x0f, 0x58, 0xfc, 0x81, 0x41, 0x90, 0x64, 0xf4,
-	0x2b, 0x1d, 0xd2, 0x0d, 0x9c, 0x33, 0x3b, 0xc4, 0xed, 0x13, 0x3b, 0xd4, 0x6b, 0x4c, 0x89, 0x2c,
-	0x44, 0x0d, 0x28, 0xed, 0xbc, 0xd2, 0x67, 0xd9, 0xfe, 0xd2, 0xce, 0x2b, 0xf3, 0x5b, 0x0d, 0x50,
-	0x0f, 0x87, 0xa2, 0x1f, 0x28, 0xd9, 0xfe, 0x25, 0x07, 0x8b, 0x47, 0x18, 0xc5, 0x11, 0x16, 0x16,
-	0xcb, 0x41, 0x5d, 0x87, 0xa6, 0xeb, 0x85, 0xce, 0x91, 0xd3, 0x4f, 0x5d, 0x5d, 0x8a, 0x5c, 0xad,
-	0xca, 0x27, 0xc8, 0xc7, 0x5d, 0x58, 0xc8, 0x60, 0x2b, 0x44, 0xbe, 0x9f, 0x34, 0x68, 0xf6, 0x70,
-	0x98, 0x72, 0x82, 0xda, 0xf8, 0x4e, 0x09, 0x98, 0xf1, 0x4a, 0x65, 0x32, 0xaf, 0x54, 0xb3, 0x5e,
-	0xd9, 0x81, 0x79, 0xc5, 0x96, 0x42, 0x3e, 0xf9, 0x58, 0x03, 0xb4, 0x9b, 0x8d, 0x7c, 0xd6, 0x66,
-	0x2d, 0xd7, 0x66, 0xc5, 0x7b, 0xa5, 0xac, 0xf7, 0xae, 0x8e, 0xef, 0x6b, 0x58, 0xd8, 0xbd, 0x89,
-	0xf8, 0x66, 0xe8, 0x5a, 0x9a, 0x8c, 0xae, 0xe6, 0xa7, 0x5a, 0x06, 0x01, 0x99, 0x8c, 0x1a, 0xf4,
-	0x90, 0x97, 0x1c, 0x42, 0x78, 0x73, 0xa0, 0x8a, 0x27, 0x70, 0xc3, 0x27, 0x1a, 0x2c, 0x66, 0x51,
-	0x14, 0x72, 0xc4, 0xbf, 0xa1, 0x2e, 0xa9, 0xe1, 0xe7, 0x79, 0x9e, 0x27, 0xe4, 0x85, 0xe6, 0x87,
-	0xb0, 0x14, 0xb5, 0x4b, 0x05, 0x9c, 0xa1, 0x98, 0x58, 0xca, 0x9a, 0xf8, 0xb9, 0x06, 0xcb, 0xb9,
-	0xea, 0xdf, 0xb1, 0x95, 0x3f, 0x6a, 0xa0, 0xb7, 0xec, 0xb0, 0x7f, 0xd2, 0xcb, 0x89, 0x7a, 0x46,
-	0xad, 0x36, 0xa1, 0xda, 0x09, 0x92, 0x21, 0xaf, 0x04, 0x94, 0x27, 0x2b, 0x01, 0x95, 0xbc, 0xc4,
-	0xb9, 0x73, 0x81, 0x15, 0x85, 0xfc, 0xa9, 0xc3, 0x54, 0x6f, 0xdc, 0xef, 0x63, 0x12, 0x93, 0x38,
-	0x1e, 0xd2, 0xe3, 0x30, 0xea, 0xd4, 0x59, 0x17, 0x33, 0x63, 0xf1, 0x91, 0xd9, 0x81, 0xba, 0x85,
-	0x89, 0x73, 0xec, 0x52, 0xf3, 0xa8, 0xef, 0xe2, 0x73, 0x73, 0x10, 0x37, 0x7a, 0xd1, 0x68, 0x02,
-	0x6a, 0xb4, 0xa0, 0x21, 0xaa, 0x2a, 0x54, 0xcb, 0xfe, 0x9f, 0x34, 0x8a, 0xad, 0xf3, 0xce, 0xe0,
-	0x7a, 0x78, 0xde, 0x6a, 0x50, 0xa1, 0x8b, 0xe9, 0xa1, 0xdb, 0x0d, 0xbc, 0x23, 0x67, 0x88, 0xbb,
-	0x27, 0x5e, 0xe8, 0x71, 0x45, 0x92, 0x8c, 0x1e, 0xda, 0x7b, 0x4e, 0xff, 0xd4, 0xb5, 0x47, 0x38,
-	0xee, 0xad, 0xe2, 0xb1, 0x00, 0xa1, 0x2c, 0x41, 0x58, 0x01, 0x68, 0x07, 0xd8, 0x0e, 0x31, 0xeb,
-	0x05, 0xa2, 0xe8, 0x0a, 0x12, 0x1a, 0x8d, 0x0e, 0x69, 0x0d, 0xbd, 0xfe, 0x29, 0xab, 0xfe, 0xd3,
-	0x56, 0x3c, 0x34, 0xfb, 0x49, 0x7b, 0x1a, 0x99, 0x59, 0xf0, 0x46, 0xc3, 0x2e, 0xb0, 0xbc, 0x46,
-	0x42, 0xb4, 0x96, 0xf9, 0x9e, 0xc9, 0xcd, 0x37, 0x1a, 0xcc, 0xf3, 0xaf, 0x90, 0xd6, 0xf9, 0x9e,
-	0x3d, 0xc2, 0xfc, 0x2e, 0x46, 0x25, 0x74, 0x18, 0xdf, 0xc5, 0xe2, 0x31, 0xda, 0x06, 0xe8, 0xda,
-	0xc7, 0x8e, 0x2b, 0xd6, 0xde, 0xbb, 0x39, 0xbd, 0xa9, 0x85, 0x5f, 0x8c, 0x31, 0x09, 0xd3, 0xb5,
-	0x96, 0xb0, 0x6f, 0x82, 0x3a, 0xf9, 0x4d, 0x74, 0x62, 0x49, 0xc8, 0x88, 0x8f, 0x56, 0xa1, 0x4a,
-	0x81, 0xc7, 0xe9, 0x2a, 0x5a, 0x14, 0x4d, 0xa0, 0x9d, 0x1c, 0x80, 0x7f, 0xce, 0x05, 0x48, 0x7c,
-	0xcf, 0x25, 0xf8, 0x02, 0x84, 0xb1, 0x0f, 0xc6, 0x23, 0xc2, 0x73, 0x37, 0x19, 0x9b, 0xdf, 0x6b,
-	0x30, 0xbb, 0x35, 0x0c, 0xa3, 0x7c, 0xbf, 0x16, 0x01, 0xe9, 0x8a, 0xee, 0x89, 0xe7, 0xe2, 0xbd,
-	0xf1, 0xe8, 0x39, 0x0e, 0xd8, 0x97, 0xca, 0x96, 0x28, 0x92, 0x58, 0x57, 0x51, 0x58, 0xb7, 0x08,
-	0xd5, 0x9d, 0x91, 0xed, 0x0c, 0x79, 0xe7, 0x10, 0x0d, 0x84, 0x3b, 0xc0, 0x80, 0xf7, 0xaf, 0xc9,
-	0xd8, 0xdc, 0x82, 0xba, 0x80, 0xbc, 0x08, 0xa7, 0xcc, 0xaf, 0x34, 0xa8, 0xc5, 0x91, 0x89, 0x8f,
-	0x0c, 0xc1, 0x48, 0x2d, 0x6b, 0xe4, 0xcd, 0x70, 0x46, 0x64, 0x65, 0x59, 0x66, 0xa5, 0xf9, 0x83,
-	0x06, 0xb3, 0x29, 0xa6, 0x6b, 0xa6, 0x4a, 0x39, 0x2f, 0x55, 0x14, 0x5e, 0x95, 0x6f, 0x82, 0x57,
-	0x15, 0x85, 0x57, 0x6f, 0x35, 0x80, 0xad, 0xc1, 0x20, 0x66, 0xd5, 0xd5, 0x8e, 0x55, 0xd8, 0xc3,
-	0xf9, 0x25, 0xb2, 0xe7, 0xa2, 0xba, 0x84, 0xa0, 0x22, 0x30, 0x8a, 0xfd, 0x2d, 0xf1, 0xa6, 0xaa,
-	0xf0, 0xe6, 0x11, 0xd4, 0x12, 0x64, 0x85, 0x58, 0xf3, 0xa5, 0x06, 0xb3, 0xac, 0xb0, 0x5d, 0x95,
-	0x33, 0xf7, 0xa0, 0xb1, 0xe3, 0x0e, 0xb6, 0x1d, 0x62, 0x3f, 0x1f, 0x46, 0x55, 0x93, 0xf7, 0xe1,
-	0xb2, 0xf4, 0xea, 0x12, 0x22, 0xd9, 0x53, 0xc9, 0xe6, 0x81, 0x80, 0xa6, 0x90, 0x45, 0x47, 0xd0,
-	0x38, 0x70, 0x27, 0x32, 0xe9, 0xea, 0x32, 0x20, 0x42, 0x2d, 0x2b, 0x50, 0xdb, 0x30, 0x27, 0x7d,
-	0xa7, 0x10, 0xd8, 0xef, 0x34, 0xf6, 0x42, 0x96, 0xa8, 0x61, 0x99, 0x2b, 0xe7, 0xa5, 0x76, 0x33,
-	0xb5, 0x3c, 0xc7, 0x3a, 0x53, 0x08, 0xfd, 0xde, 0x78, 0xc4, 0xeb, 0xa9, 0x24, 0x33, 0x5f, 0xc3,
-	0x4c, 0x32, 0xa6, 0xb9, 0x48, 0xff, 0xe7, 0x90, 0xa4, 0x5c, 0x64, 0xf3, 0xeb, 0xd0, 0x6c, 0xe1,
-	0x63, 0xc7, 0xcd, 0xb2, 0x24, 0x23, 0xcf, 0xe1, 0x53, 0x39, 0x8f, 0x4f, 0xe6, 0xcf, 0xd1, 0x51,
-	0x28, 0x7a, 0xa8, 0x50, 0x1d, 0xd9, 0x04, 0x48, 0x75, 0xf0, 0x6a, 0x32, 0x17, 0xed, 0x48, 0x83,
-	0x28, 0x2c, 0x79, 0x17, 0x85, 0xa5, 0xcb, 0x6e, 0x3e, 0xc9, 0x37, 0xe3, 0xbe, 0x69, 0x19, 0xa6,
-	0xe8, 0xf0, 0xd0, 0xf9, 0xed, 0x8d, 0xd3, 0x0e, 0xbb, 0xc5, 0x28, 0x1a, 0x89, 0x8f, 0xfe, 0x2a,
-	0x84, 0x91, 0x57, 0xfa, 0x8c, 0xf1, 0xe9, 0x0a, 0xf3, 0x08, 0xea, 0xe9, 0xcb, 0xf3, 0xf5, 0x20,
-	0x5d, 0x9a, 0x43, 0x2d, 0xf1, 0x75, 0xbd, 0x58, 0x60, 0xef, 0xbf, 0xa9, 0x45, 0x27, 0x04, 0x7a,
-	0x98, 0x9c, 0x7f, 0xec, 0x2d, 0x66, 0x31, 0xda, 0x25, 0x3f, 0x5e, 0x1a, 0xb7, 0x73, 0xa4, 0xc4,
-	0x47, 0x6d, 0x68, 0xc8, 0x2f, 0x6c, 0x68, 0x99, 0xb3, 0x5b, 0x7d, 0x03, 0x34, 0xf4, 0xfc, 0x09,
-	0xe2, 0x53, 0x00, 0xc2, 0x7b, 0x7d, 0x0c, 0x40, 0xfe, 0xf9, 0x20, 0x06, 0xa0, 0x3e, 0xec, 0xff,
-	0x97, 0x1d, 0x94, 0xc9, 0x4b, 0x39, 0x4a, 0x71, 0x8a, 0xcf, 0xf1, 0xc6, 0x52, 0x9e, 0x38, 0xda,
-	0x2e, 0x3e, 0x14, 0xc7, 0xdb, 0x95, 0x67, 0xf1, 0x78, 0x7b, 0xe6, 0xc5, 0xfa, 0x09, 0x6b, 0x6a,
-	0xa5, 0x57, 0x24, 0x3d, 0xf9, 0x92, 0xf2, 0x3a, 0x61, 0xdc, 0xb9, 0x60, 0x86, 0xf8, 0xc8, 0x62,
-	0x84, 0x56, 0x6f, 0x98, 0xe8, 0xf7, 0x22, 0x6a, 0xf5, 0xca, 0x67, 0xfc, 0xe1, 0x92, 0x59, 0xe2,
-	0xa3, 0x0e, 0xab, 0x90, 0xb2, 0xc2, 0x7c, 0x08, 0x4c, 0x9b, 0x71, 0xd1, 0x14, 0xf1, 0xd1, 0xfb,
-	0x70, 0x3b, 0xf7, 0xca, 0x86, 0x56, 0x78, 0x2e, 0x5c, 0x70, 0x2b, 0x35, 0xfe, 0x78, 0xe9, 0x7c,
-	0xe4, 0xc0, 0x5e, 0xbe, 0x03, 0x7b, 0x17, 0x3a, 0x30, 0xef, 0x59, 0xed, 0x31, 0xd4, 0xa5, 0x77,
-	0x25, 0xb4, 0x94, 0xac, 0x95, 0x1e, 0xce, 0x8c, 0xe5, 0x5c, 0x79, 0x44, 0x42, 0xe1, 0x7e, 0xa2,
-	0x64, 0x01, 0xaf, 0x30, 0x4a, 0x16, 0x24, 0x55, 0xa2, 0x9d, 0x5c, 0xe1, 0x78, 0x6f, 0x1f, 0x67,
-	0x41, 0xe6, 0x2e, 0x62, 0xe8, 0xf9, 0x13, 0xc4, 0x47, 0x0f, 0xd8, 0x6f, 0x19, 0xfc, 0x2e, 0x89,
-	0x16, 0xa2, 0x75, 0xd2, 0x45, 0xd5, 0x58, 0xcc, 0x0a, 0x89, 0x8f, 0xfe, 0x09, 0x33, 0x49, 0x0f,
-	0x8c, 0xf8, 0x85, 0x5f, 0x6c, 0xe7, 0x8d, 0x85, 0x8c, 0x8c, 0xf8, 0xe8, 0xef, 0x30, 0x1d, 0x83,
-	0x40, 0xf3, 0x32, 0x28, 0xba, 0x07, 0xa9, 0x22, 0xe2, 0xa3, 0x0d, 0x98, 0xe2, 0x4d, 0x13, 0xe2,
-	0xa5, 0x25, 0xed, 0xee, 0x8c, 0x79, 0x45, 0x12, 0x01, 0x4b, 0xcf, 0x40, 0xa4, 0x96, 0xcd, 0x14,
-	0x98, 0xdc, 0x0c, 0x3c, 0x84, 0x9a, 0xd0, 0x1f, 0xc4, 0x81, 0x90, 0x5b, 0x93, 0x38, 0x10, 0x6a,
-	0x23, 0xf1, 0x18, 0xea, 0xd2, 0x99, 0x87, 0xd2, 0xbc, 0x97, 0x5a, 0x05, 0x63, 0x39, 0x57, 0x9e,
-	0x64, 0x8d, 0x74, 0x10, 0x08, 0x59, 0xa3, 0x1e, 0x39, 0x42, 0xd6, 0x64, 0xcf, 0x8e, 0x07, 0x00,
-	0x69, 0xb5, 0x8a, 0x03, 0x2a, 0x1d, 0x0f, 0xc6, 0x62, 0x56, 0x48, 0xfc, 0x56, 0xfd, 0x83, 0xda,
-	0x06, 0xfb, 0xd1, 0xf6, 0x3f, 0xf4, 0x9f, 0xe7, 0xb7, 0xd8, 0x2f, 0xb2, 0xff, 0xf8, 0x35, 0x00,
-	0x00, 0xff, 0xff, 0x10, 0x04, 0x45, 0x5d, 0xcd, 0x1d, 0x00, 0x00,
+var fileDescriptor_user_e11c6a5241e13fcd = []byte{
+	// 1857 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x59, 0xdd, 0x4f, 0x24, 0x4b,
+	0x15, 0x4f, 0xcf, 0xc7, 0x02, 0x67, 0x98, 0x61, 0x28, 0xb8, 0xd0, 0xb7, 0x55, 0xc4, 0xce, 0xf5,
+	0x4a, 0x48, 0x04, 0x5d, 0x8d, 0x6b, 0xd6, 0xe8, 0x2e, 0x33, 0xb0, 0x64, 0x8c, 0x0b, 0x93, 0x9e,
+	0x25, 0x31, 0xc6, 0x84, 0xf4, 0xce, 0x14, 0xd0, 0x61, 0xa6, 0xbb, 0xb7, 0xab, 0x87, 0x5d, 0x7c,
+	0x59, 0xe3, 0xc7, 0x8b, 0xf1, 0xc5, 0xa7, 0x5d, 0x7d, 0xf0, 0xef, 0xf0, 0x5d, 0x9f, 0xfc, 0x0f,
+	0xf4, 0xc5, 0x7f, 0xc5, 0xd4, 0x47, 0x77, 0x57, 0x55, 0x37, 0x30, 0xb7, 0x21, 0xfb, 0x02, 0x53,
+	0xa7, 0xbe, 0x7e, 0xe7, 0x9c, 0xdf, 0x39, 0x75, 0xaa, 0x1a, 0x96, 0xa6, 0x04, 0x47, 0xbb, 0xf4,
+	0xcf, 0x4e, 0x18, 0x05, 0x71, 0x80, 0x6a, 0xf4, 0xb7, 0xf5, 0xad, 0xe3, 0x10, 0xfb, 0xa7, 0xbd,
+	0x97, 0xbb, 0xe1, 0xe5, 0xf9, 0x2e, 0xeb, 0xd8, 0x25, 0xa3, 0xcb, 0xd3, 0xb7, 0x64, 0xf7, 0x2d,
+	0xe1, 0x03, 0xed, 0x9f, 0x01, 0x74, 0x83, 0xc9, 0x24, 0xf0, 0x1d, 0x4c, 0x42, 0x64, 0xc2, 0x1c,
+	0x8e, 0xa2, 0x6e, 0x30, 0xc2, 0xa6, 0xb1, 0x69, 0x6c, 0xd5, 0x9d, 0xa4, 0x89, 0xd6, 0xe0, 0x11,
+	0x8e, 0xa2, 0x97, 0xe4, 0xdc, 0xac, 0x6c, 0x1a, 0x5b, 0x0b, 0x8e, 0x68, 0xd9, 0xbf, 0x81, 0xd6,
+	0x3e, 0x1e, 0xe3, 0x18, 0x9f, 0x10, 0x1c, 0x11, 0x07, 0xbf, 0x41, 0xdb, 0xd0, 0xce, 0x24, 0xbd,
+	0xfd, 0x5f, 0x78, 0x24, 0x36, 0x2b, 0x9b, 0xd5, 0xad, 0x05, 0x27, 0x27, 0x47, 0x16, 0xcc, 0x1f,
+	0x87, 0xbc, 0x6d, 0x56, 0xd9, 0xba, 0x69, 0x1b, 0x6d, 0x42, 0xe3, 0x38, 0xc4, 0x91, 0x1b, 0x7b,
+	0x81, 0xdf, 0xdb, 0x37, 0x6b, 0xac, 0x5b, 0x16, 0xd9, 0x01, 0x2c, 0x29, 0x7b, 0x93, 0x10, 0x7d,
+	0x4f, 0x56, 0x87, 0xe9, 0xd0, 0x78, 0xdc, 0xde, 0x61, 0x86, 0xc9, 0xe4, 0x8e, 0xac, 0xf2, 0x36,
+	0xb4, 0x5f, 0xb8, 0xde, 0x18, 0x8f, 0xf2, 0x70, 0x75, 0xb9, 0x7d, 0x0c, 0x4b, 0x87, 0x38, 0xde,
+	0x1b, 0x8f, 0xb9, 0x8c, 0x6a, 0x6b, 0xc1, 0x7c, 0x90, 0x68, 0x60, 0x70, 0x0d, 0x02, 0x49, 0x83,
+	0x40, 0xd2, 0x80, 0x1b, 0x4e, 0x16, 0xd9, 0x23, 0x68, 0xab, 0x0b, 0x96, 0x52, 0x61, 0x03, 0x20,
+	0x07, 0x5e, 0x92, 0xd8, 0xd7, 0xb0, 0xb4, 0x37, 0x1c, 0x06, 0x53, 0x3f, 0xee, 0x5e, 0xe0, 0xe1,
+	0x25, 0x85, 0xbd, 0x05, 0x4b, 0xec, 0xb7, 0x34, 0xcf, 0x60, 0xf3, 0x74, 0xb1, 0xe2, 0xa2, 0xca,
+	0xed, 0x2e, 0xaa, 0xe6, 0x5d, 0xf4, 0x3f, 0x03, 0xda, 0xea, 0xde, 0x5c, 0xc3, 0xe1, 0x0c, 0x1a,
+	0x66, 0x63, 0xd0, 0x21, 0x80, 0x83, 0xc9, 0x74, 0x1c, 0xa7, 0x1a, 0x36, 0x1e, 0x7f, 0x87, 0xcf,
+	0xd0, 0x57, 0xdf, 0x19, 0x78, 0xfe, 0xf9, 0x98, 0x51, 0x62, 0x10, 0xbb, 0xf1, 0x94, 0x38, 0xd2,
+	0x54, 0xab, 0x0f, 0x6d, 0xbd, 0x9f, 0x52, 0x7b, 0x2a, 0x3b, 0x50, 0xb4, 0xd0, 0x17, 0xd0, 0x74,
+	0xf9, 0xe2, 0x7c, 0xa0, 0x50, 0x5f, 0x15, 0xda, 0x3e, 0xb4, 0x0e, 0x71, 0xcc, 0x0c, 0xe2, 0x9f,
+	0x05, 0xd4, 0xb6, 0x1b, 0x00, 0x53, 0xdd, 0xac, 0x92, 0xe4, 0x9e, 0x16, 0xfd, 0x83, 0xc1, 0x48,
+	0x98, 0x6d, 0x58, 0xca, 0xa0, 0xcf, 0x60, 0x31, 0x59, 0x81, 0xa1, 0xac, 0x32, 0x93, 0x7e, 0x6d,
+	0x87, 0xe0, 0xe8, 0x0a, 0x47, 0xa7, 0x6e, 0xe8, 0x9d, 0x86, 0x6e, 0xe4, 0x4e, 0xc8, 0x4e, 0xba,
+	0x91, 0x32, 0xc1, 0xfe, 0x93, 0x01, 0xcb, 0x27, 0xe1, 0xc8, 0x15, 0xe1, 0x2c, 0x54, 0x7f, 0x02,
+	0xf3, 0x49, 0x53, 0xc0, 0xb8, 0x75, 0xc9, 0x74, 0xf0, 0x5d, 0x36, 0x09, 0xf2, 0x36, 0x91, 0xc3,
+	0xe8, 0x05, 0x20, 0x1d, 0x4b, 0x19, 0xab, 0xd8, 0xff, 0xad, 0xc2, 0x62, 0x37, 0xf0, 0xaf, 0x70,
+	0x44, 0xd8, 0xd2, 0xcc, 0x1d, 0x6f, 0x7d, 0x1c, 0x29, 0x01, 0x2e, 0x8b, 0xd0, 0x97, 0xd0, 0x92,
+	0x67, 0xa4, 0xf0, 0x35, 0x29, 0x25, 0x85, 0x83, 0x87, 0x57, 0x2f, 0xc9, 0xf9, 0x71, 0x18, 0x33,
+	0x1d, 0xea, 0x8e, 0x24, 0xa1, 0x69, 0x48, 0x9e, 0xf1, 0xea, 0x3a, 0xc4, 0x2c, 0xe5, 0xd5, 0x9d,
+	0x9c, 0x9c, 0x12, 0x56, 0x00, 0xaa, 0x73, 0xc2, 0x0a, 0x2c, 0x26, 0xcc, 0x1d, 0x46, 0xc1, 0x34,
+	0xec, 0xed, 0x9b, 0x8f, 0x58, 0x47, 0xd2, 0xa4, 0x7a, 0x9c, 0xf8, 0x11, 0x76, 0x47, 0x5d, 0xca,
+	0x5c, 0x73, 0x8e, 0x2d, 0x2c, 0x8b, 0x28, 0xd9, 0xf7, 0x23, 0xf7, 0x2c, 0x7e, 0x85, 0xdf, 0xc5,
+	0xaf, 0xbc, 0x09, 0x36, 0xe7, 0x37, 0x8d, 0xad, 0xaa, 0xa3, 0x0a, 0xa9, 0x9b, 0x7a, 0xa4, 0xef,
+	0xf9, 0x3e, 0x1e, 0x99, 0x0b, 0x9b, 0xc6, 0xd6, 0xbc, 0x93, 0xb6, 0x91, 0x0d, 0x8b, 0x7b, 0x71,
+	0xec, 0x0e, 0x2f, 0xf0, 0x88, 0xf9, 0x1f, 0x18, 0x04, 0x45, 0x46, 0x77, 0xe9, 0x91, 0x7e, 0xe4,
+	0x5d, 0xb9, 0x31, 0xee, 0x5e, 0xb8, 0xb1, 0xd9, 0x60, 0x8b, 0xa8, 0x42, 0x8a, 0x96, 0x01, 0xdf,
+	0x8b, 0x99, 0x19, 0x16, 0x39, 0x5a, 0x49, 0x44, 0xf7, 0xea, 0x91, 0xa3, 0x20, 0xee, 0xf9, 0x4c,
+	0x6a, 0x36, 0xd9, 0x32, 0x8a, 0x0c, 0xb5, 0xa0, 0x72, 0xf0, 0xce, 0x6c, 0x31, 0x14, 0x95, 0x83,
+	0x77, 0xf6, 0xdf, 0x0c, 0x40, 0x03, 0x1c, 0xcb, 0xd6, 0xa4, 0x94, 0xfd, 0x91, 0xea, 0x72, 0xc1,
+	0x13, 0x94, 0xf0, 0x44, 0x1a, 0xac, 0x52, 0x63, 0x1b, 0xda, 0x7e, 0x10, 0x7b, 0x67, 0xde, 0x30,
+	0x73, 0x58, 0x85, 0x3b, 0x4c, 0x97, 0xcf, 0x10, 0xd5, 0x87, 0xb0, 0x92, 0xc3, 0x56, 0x8a, 0xc2,
+	0xff, 0x36, 0xa0, 0x3d, 0xc0, 0x71, 0xc6, 0x2c, 0xaa, 0xe3, 0x27, 0xa5, 0x71, 0xce, 0x2a, 0xb5,
+	0xd9, 0xac, 0x52, 0xcf, 0x5b, 0xe5, 0x00, 0x96, 0x35, 0x5d, 0x4a, 0xd9, 0xe4, 0xb7, 0x06, 0xa0,
+	0xc3, 0xbc, 0xe7, 0xf3, 0x3a, 0x1b, 0x85, 0x3a, 0x6b, 0xd6, 0xab, 0xe4, 0xad, 0x77, 0xb7, 0x7f,
+	0xdf, 0xc3, 0xca, 0xe1, 0x43, 0xf8, 0x37, 0x47, 0xd7, 0xca, 0x6c, 0x74, 0xb5, 0x7f, 0x6f, 0xe4,
+	0x10, 0x90, 0xd9, 0xa8, 0x41, 0x4b, 0x05, 0xc5, 0x20, 0x44, 0x94, 0x18, 0xba, 0x78, 0x06, 0x33,
+	0xfc, 0xce, 0x80, 0xd5, 0x3c, 0x8a, 0x52, 0x86, 0xf8, 0x31, 0x34, 0x95, 0x65, 0x44, 0x55, 0x50,
+	0x64, 0x09, 0x75, 0xa0, 0xfd, 0x6b, 0x58, 0xe3, 0x45, 0x57, 0x09, 0x63, 0x68, 0x2a, 0x56, 0xf2,
+	0x2a, 0xfe, 0xd1, 0x80, 0xf5, 0xc2, 0xe5, 0x3f, 0xb1, 0x96, 0xff, 0x32, 0xc0, 0xec, 0xb8, 0xf1,
+	0xf0, 0x62, 0x50, 0xe0, 0xf5, 0xdc, 0xb2, 0xc6, 0x8c, 0xcb, 0xce, 0x10, 0x0c, 0x45, 0x29, 0xa0,
+	0x3a, 0x5b, 0x0a, 0xa8, 0x15, 0x05, 0xce, 0xe7, 0x37, 0x68, 0x51, 0xca, 0x9e, 0x26, 0xcc, 0x0d,
+	0xa6, 0xc3, 0x21, 0x26, 0x09, 0x89, 0x93, 0x26, 0x3d, 0x54, 0x79, 0xbd, 0xcf, 0x6a, 0xa1, 0x05,
+	0x47, 0xb4, 0xec, 0x1e, 0x34, 0x1d, 0x4c, 0xbc, 0x73, 0x9f, 0xaa, 0x47, 0x6d, 0x97, 0x9c, 0xbe,
+	0xa3, 0xa4, 0x5c, 0xe4, 0xad, 0x19, 0xa8, 0xd1, 0x81, 0x96, 0xbc, 0x54, 0xa9, 0x5c, 0xf6, 0xf3,
+	0xb4, 0xdc, 0xec, 0x5c, 0xf7, 0x46, 0xf7, 0xc3, 0xf3, 0xd1, 0x80, 0x1a, 0x1d, 0x4c, 0x8f, 0xd3,
+	0x7e, 0x14, 0x9c, 0x79, 0x63, 0xdc, 0xbf, 0x08, 0xe2, 0x40, 0x2c, 0xa4, 0xc8, 0xe8, 0xd1, 0x7f,
+	0xe4, 0x0d, 0x2f, 0x7d, 0x77, 0x82, 0x93, 0x0a, 0x2d, 0x69, 0x4b, 0x10, 0xaa, 0x0a, 0x84, 0x0d,
+	0x80, 0x6e, 0x84, 0xdd, 0x18, 0xb3, 0x8a, 0x82, 0x7b, 0x57, 0x92, 0x50, 0x6f, 0xf4, 0x48, 0x67,
+	0x1c, 0x0c, 0x2f, 0x59, 0xf6, 0x9f, 0x77, 0x92, 0xa6, 0x3d, 0x4c, 0x8b, 0x5c, 0xae, 0x66, 0xc9,
+	0x7b, 0x11, 0xbb, 0x06, 0x8b, 0x1c, 0x09, 0x7c, 0x2c, 0xb3, 0x3d, 0x93, 0xdb, 0x1f, 0x0c, 0x58,
+	0x16, 0xbb, 0x90, 0xce, 0xf5, 0x91, 0x3b, 0xc1, 0xe2, 0x46, 0x47, 0x25, 0xb4, 0x99, 0xdc, 0xe8,
+	0x92, 0x36, 0xda, 0x07, 0xe8, 0xbb, 0xe7, 0x9e, 0x2f, 0xe7, 0xde, 0x2f, 0x0a, 0x2a, 0x5c, 0x07,
+	0xbf, 0x99, 0x62, 0x12, 0x67, 0x63, 0x1d, 0x69, 0xde, 0x0c, 0x79, 0xf2, 0xaf, 0xfc, 0xc4, 0x52,
+	0x90, 0x91, 0x10, 0x6d, 0x42, 0x9d, 0x02, 0x4f, 0xc2, 0x55, 0xd6, 0x88, 0x77, 0xa0, 0x83, 0x02,
+	0x80, 0xdf, 0x2e, 0x04, 0x48, 0xc2, 0xc0, 0x27, 0xf8, 0x06, 0x84, 0x89, 0x0d, 0xa6, 0x13, 0x22,
+	0x62, 0x37, 0x6d, 0xdb, 0xff, 0x30, 0x60, 0x71, 0x6f, 0x1c, 0xf3, 0x78, 0xbf, 0x17, 0x01, 0xe9,
+	0x88, 0xfe, 0x45, 0xe0, 0xe3, 0xa3, 0xe9, 0xe4, 0x35, 0x8e, 0xd8, 0x4e, 0x55, 0x47, 0x16, 0x29,
+	0xac, 0xab, 0x69, 0xac, 0x5b, 0x85, 0xfa, 0xc1, 0xc4, 0xf5, 0xc6, 0xa2, 0x72, 0xe0, 0x0d, 0xe9,
+	0x26, 0x31, 0x12, 0x55, 0x70, 0xda, 0xb6, 0xf7, 0xa0, 0x29, 0x21, 0x2f, 0xc3, 0x29, 0xfb, 0x2f,
+	0x06, 0x34, 0x12, 0xcf, 0x24, 0x47, 0x86, 0xa4, 0xa4, 0x91, 0x57, 0xf2, 0x61, 0x38, 0x23, 0xb3,
+	0xb2, 0xaa, 0xb2, 0xd2, 0xfe, 0xa7, 0x01, 0x8b, 0x19, 0xa6, 0x7b, 0x86, 0x4a, 0xb5, 0x28, 0x54,
+	0x34, 0x5e, 0x55, 0x1f, 0x82, 0x57, 0x35, 0x8d, 0x57, 0x1f, 0x0d, 0x80, 0xbd, 0xd1, 0x28, 0x61,
+	0xd5, 0xdd, 0x86, 0xd5, 0xd8, 0x23, 0xf8, 0x25, 0xb3, 0xe7, 0xa6, 0xbc, 0x84, 0xa0, 0x26, 0x31,
+	0x8a, 0xfd, 0x56, 0x78, 0x53, 0xd7, 0x78, 0xf3, 0x0c, 0x1a, 0x29, 0xb2, 0x52, 0xac, 0xf9, 0xb3,
+	0x01, 0x8b, 0x2c, 0xb1, 0xdd, 0x15, 0x33, 0x5f, 0x42, 0xeb, 0xc0, 0x1f, 0xed, 0x7b, 0xc4, 0x7d,
+	0x3d, 0xe6, 0x59, 0x53, 0xd4, 0xe1, 0xaa, 0xf4, 0xee, 0x14, 0xa2, 0xe8, 0x53, 0xcb, 0xc7, 0x81,
+	0x84, 0xa6, 0x94, 0x46, 0x67, 0xd0, 0x3a, 0xf1, 0x67, 0x52, 0xe9, 0xee, 0x34, 0x20, 0x43, 0xad,
+	0x6a, 0x50, 0xbb, 0xb0, 0xa4, 0xec, 0x53, 0x0a, 0xec, 0xdf, 0x0d, 0xf6, 0xce, 0x96, 0x2e, 0xc3,
+	0x22, 0x57, 0x8d, 0x4b, 0xe3, 0x61, 0x72, 0x79, 0x81, 0x76, 0xb6, 0xe4, 0xfa, 0xa3, 0xe9, 0x44,
+	0xe4, 0x53, 0x45, 0x66, 0xbf, 0x87, 0x85, 0xb4, 0x4d, 0x63, 0x91, 0xfe, 0x17, 0x90, 0x94, 0x58,
+	0x64, 0xfd, 0xdb, 0xd0, 0xee, 0xe0, 0x73, 0xcf, 0xcf, 0xb3, 0x24, 0x27, 0x2f, 0xe0, 0x53, 0xb5,
+	0x88, 0x4f, 0xf6, 0x7f, 0xf8, 0x51, 0x28, 0x5b, 0xa8, 0x54, 0x1e, 0xd9, 0x05, 0xc8, 0xd6, 0x10,
+	0xd9, 0x64, 0x89, 0xcf, 0xc8, 0x9c, 0x28, 0x0d, 0xf9, 0x14, 0x89, 0xa5, 0xcf, 0x6e, 0x3e, 0xe9,
+	0x9e, 0x49, 0xdd, 0xb4, 0x0e, 0x73, 0xb4, 0x79, 0xea, 0x7d, 0xf5, 0xc2, 0xe9, 0x80, 0xdd, 0x62,
+	0xb4, 0x15, 0x49, 0x88, 0xbe, 0x2b, 0xb9, 0x51, 0x64, 0xfa, 0x9c, 0xf2, 0xd9, 0x08, 0xfb, 0x0c,
+	0x9a, 0xd9, 0xfb, 0xf5, 0xfd, 0x20, 0xdd, 0x1a, 0x43, 0x1d, 0xf9, 0x8d, 0xbe, 0x9c, 0x63, 0x1f,
+	0x7f, 0x68, 0xf0, 0x13, 0x02, 0x3d, 0x4d, 0xcf, 0x3f, 0xf6, 0xa2, 0xb3, 0xca, 0x67, 0xa9, 0x4f,
+	0xa0, 0xd6, 0x67, 0x05, 0x52, 0x12, 0xa2, 0x2e, 0xb4, 0xd4, 0x77, 0x3a, 0xb4, 0x2e, 0xd8, 0xad,
+	0xbf, 0x24, 0x5a, 0x66, 0x71, 0x07, 0x09, 0x29, 0x00, 0xe9, 0xd5, 0x3f, 0x01, 0xa0, 0x7e, 0x84,
+	0x48, 0x00, 0xe8, 0x9f, 0x07, 0x7e, 0xca, 0x0e, 0xca, 0xf4, 0xbd, 0x1d, 0x65, 0x38, 0xe5, 0x47,
+	0x7d, 0x6b, 0xad, 0x48, 0xcc, 0xa7, 0xcb, 0xcf, 0xcd, 0xc9, 0x74, 0xed, 0x71, 0x3d, 0x99, 0x9e,
+	0x7b, 0xf7, 0x7e, 0xc1, 0x8a, 0x5a, 0xe5, 0x15, 0xc9, 0x4c, 0x77, 0xd2, 0x5e, 0x27, 0xac, 0xcf,
+	0x6f, 0xe8, 0x21, 0x21, 0x72, 0x18, 0xa1, 0xf5, 0x1b, 0x26, 0xfa, 0xba, 0x8c, 0x5a, 0xbf, 0xf2,
+	0x59, 0xdf, 0xb8, 0xa5, 0x97, 0x84, 0xa8, 0xc7, 0x32, 0xa4, 0xba, 0x60, 0x31, 0x04, 0xb6, 0x9a,
+	0x75, 0x53, 0x17, 0x09, 0xd1, 0x2f, 0xe1, 0xb3, 0xc2, 0x2b, 0x1b, 0xda, 0x10, 0xb1, 0x70, 0xc3,
+	0xad, 0xd4, 0xfa, 0xe6, 0xad, 0xfd, 0xdc, 0x80, 0x83, 0x62, 0x03, 0x0e, 0x6e, 0x34, 0x60, 0xd1,
+	0xb3, 0xda, 0x73, 0x68, 0x2a, 0xef, 0x4a, 0x68, 0x2d, 0x1d, 0xab, 0x3c, 0x9c, 0x59, 0xeb, 0x85,
+	0x72, 0x4e, 0x42, 0xe9, 0x7e, 0xa2, 0x45, 0x81, 0xc8, 0x30, 0x5a, 0x14, 0xa4, 0x59, 0xa2, 0x9b,
+	0x5e, 0xe1, 0x44, 0x6d, 0x9f, 0x44, 0x41, 0xee, 0x2e, 0x62, 0x99, 0xc5, 0x1d, 0x24, 0x44, 0x4f,
+	0xd8, 0x17, 0x11, 0x71, 0x97, 0x44, 0x2b, 0x7c, 0x9c, 0x72, 0x51, 0xb5, 0x56, 0xf3, 0x42, 0x12,
+	0xa2, 0x1f, 0xc2, 0x42, 0x5a, 0x03, 0x23, 0x71, 0xe1, 0x97, 0xcb, 0x79, 0x6b, 0x25, 0x27, 0x23,
+	0x21, 0xfa, 0x3e, 0xcc, 0x27, 0x20, 0xd0, 0xb2, 0x0a, 0x8a, 0xce, 0x41, 0xba, 0x88, 0x84, 0x68,
+	0x07, 0xe6, 0x44, 0xd1, 0x84, 0x44, 0x6a, 0xc9, 0xaa, 0x3b, 0x6b, 0x59, 0x93, 0x70, 0x60, 0xd9,
+	0x19, 0x88, 0xf4, 0xb4, 0x99, 0x01, 0x53, 0x8b, 0x81, 0xa7, 0xd0, 0x90, 0xea, 0x83, 0xc4, 0x11,
+	0x6a, 0x69, 0x92, 0x38, 0x42, 0x2f, 0x24, 0x9e, 0x43, 0x53, 0x39, 0xf3, 0x50, 0x16, 0xf7, 0x4a,
+	0xa9, 0x60, 0xad, 0x17, 0xca, 0xd3, 0xa8, 0x51, 0x0e, 0x02, 0x29, 0x6a, 0xf4, 0x23, 0x47, 0x8a,
+	0x9a, 0xfc, 0xd9, 0xf1, 0x04, 0x20, 0xcb, 0x56, 0x89, 0x43, 0x95, 0xe3, 0xc1, 0x5a, 0xcd, 0x0b,
+	0x49, 0xd8, 0x69, 0xfe, 0xaa, 0xb1, 0xc3, 0x3e, 0xfd, 0xfe, 0x84, 0xfe, 0x79, 0xfd, 0x88, 0x7d,
+	0xd7, 0xfd, 0xc1, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x34, 0x9a, 0x78, 0xde, 0x13, 0x1e, 0x00,
+	0x00,
 }

pkg/proto/user/user.proto

@@ -79,7 +79,9 @@ message Conversation{
   bool IsPinned = 9;
   string AttachedInfo = 10;
   bool IsPrivateChat = 11;
-  string Ex = 12;
+  int32 GroupAtType = 12;
+  bool IsNotInGroup = 13;
+  string Ex = 14;
 }
 
 message SetConversationReq{
@@ -144,9 +146,9 @@ message BatchSetConversationsReq{
 }
 
 message BatchSetConversationsResp{
-   CommonResp  commonResp = 1;
-   repeated string Success = 2;
-   repeated string Failed = 3;
+  CommonResp  commonResp = 1;
+  repeated string Success = 2;
+  repeated string Failed = 3;
 }
 
 message ResignUserReq{
@@ -177,9 +179,9 @@ message GetUserByIdResp{
 }
 
 message GetUsersByNameReq {
- string UserName = 1;
- server_api_params.RequestPagination Pagination =2;
- string OperationID = 3;
+  string UserName = 1;
+  server_api_params.RequestPagination Pagination = 2;
+  string OperationID = 3;
 }
 
 message GetUsersByNameResp {
@@ -223,7 +225,7 @@ message AddUserReq{
 }
 
 message AddUserResp{
- CommonResp  CommonResp = 1;
+  CommonResp  CommonResp = 1;
 }
 
 
@@ -235,7 +237,7 @@ message BlockUserReq{
 }
 
 message BlockUserResp{
-   CommonResp  CommonResp = 1;
+  CommonResp  CommonResp = 1;
 }
 
 message UnBlockUserReq{
@@ -245,19 +247,19 @@ message UnBlockUserReq{
 }
 
 message UnBlockUserResp{
-   CommonResp  CommonResp = 1;
+  CommonResp  CommonResp = 1;
 }
 
 message GetBlockUsersReq{
-  server_api_params.RequestPagination Pagination =1;
+  server_api_params.RequestPagination Pagination = 1;
   string OperationID = 2;
   int32 BlockUserNum = 3;
 }
 
 message BlockUser {
-    User User = 1;
-    string BeginDisableTime = 2;
-    string EndDisableTime = 3;
+  User User = 1;
+  string BeginDisableTime = 2;
+  string EndDisableTime = 3;
 }
 
 message GetBlockUsersResp{
@@ -268,22 +270,22 @@ message GetBlockUsersResp{
 }
 
 message GetBlockUserByIdReq {
-    string User_id = 1;
-    string OperationID = 2;
+  string User_id = 1;
+  string OperationID = 2;
 }
 
 message GetBlockUserByIdResp {
-    BlockUser BlockUser = 2;
+  BlockUser BlockUser = 2;
 }
 
 message DeleteUserReq {
-    string User_id = 1;
-    string OperationID = 2;
-    string OpUserId = 3;
+  string User_id = 1;
+  string OperationID = 2;
+  string OpUserId = 3;
 }
 
 message DeleteUserResp {
-    CommonResp  CommonResp = 1;
+  CommonResp  CommonResp = 1;
 }
 
 
@@ -313,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);
+
 }

pkg/utils/strings.go

@@ -43,6 +43,14 @@ func IsContain(target string, List []string) bool {
 	}
 	return false
 }
+func IsContainInt32(target int32, List []int32) bool {
+	for _, element := range List {
+		if target == element {
+			return true
+		}
+	}
+	return false
+}
 
 func InterfaceArrayToStringArray(data []interface{}) (i []string) {
 	for _, param := range data {
@@ -77,6 +85,8 @@ func GetConversationIDBySessionType(sourceID string, sessionType int) string {
 		return "single_" + sourceID
 	case constant.GroupChatType:
 		return "group_" + sourceID
+	case constant.NotificationChatType:
+		return "notification_" + sourceID
 	}
 	return ""
 }

pkg/utils/utils.go

@@ -1,6 +1,10 @@
 package utils
 
 import (
+	"bytes"
+	"encoding/json"
+	"github.com/gogo/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
 	"github.com/jinzhu/copier"
 	"github.com/pkg/errors"
 	"math/rand"
@@ -77,6 +81,44 @@ func Difference(slice1, slice2 []uint32) []uint32 {
 	}
 	return n
 }
+
+//Get the intersection of two slices
+func IntersectString(slice1, slice2 []string) []string {
+	m := make(map[string]bool)
+	n := make([]string, 0)
+	for _, v := range slice1 {
+		m[v] = true
+	}
+	for _, v := range slice2 {
+		flag, _ := m[v]
+		if flag {
+			n = append(n, v)
+		}
+	}
+	return n
+}
+
+//Get the diff of two slices
+func DifferenceString(slice1, slice2 []string) []string {
+	m := make(map[string]bool)
+	n := make([]string, 0)
+	inter := IntersectString(slice1, slice2)
+	for _, v := range inter {
+		m[v] = true
+	}
+	for _, v := range slice1 {
+		if !m[v] {
+			n = append(n, v)
+		}
+	}
+
+	for _, v := range slice2 {
+		if !m[v] {
+			n = append(n, v)
+		}
+	}
+	return n
+}
 func OperationIDGenerator() string {
 	return strconv.FormatInt(time.Now().UnixNano()+int64(rand.Uint32()), 10)
 }
@@ -93,3 +135,18 @@ func RemoveRepeatedStringInList(slc []string) []string {
 	}
 	return result
 }
+
+func Pb2Map(pb proto.Message) (map[string]interface{}, error) {
+	_buffer := bytes.Buffer{}
+	jsonbMarshaller := &jsonpb.Marshaler{
+		OrigName:     true,
+		EnumsAsInts:  true,
+		EmitDefaults: true,
+	}
+	_ = jsonbMarshaller.Marshal(&_buffer, pb)
+	jsonCnt := _buffer.Bytes()
+	var out map[string]interface{}
+	err := json.Unmarshal(jsonCnt, &out)
+
+	return out, err
+}

script/check_all.sh

@@ -4,22 +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
-  openImOnlineRelayPort
+  openImMessagePort
+  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

@@ -48,7 +48,10 @@ service_source_root=(
   ../cmd/rpc/open_im_admin_cms/
   ../cmd/rpc/open_im_message_cms/
   ../cmd/rpc/open_im_statistics/
-  ../cmd/rpc/open_im_office/
+  ../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}
@@ -70,6 +73,9 @@ service_names=(
   open_im_message_cms
   open_im_statistics
   open_im_office
+  open_im_organization
+  open_im_conversation
+  open_im_cache
   ${msg_gateway_name}
   ${msg_transfer_name}
   ${msg_name}

script/sdk_svr_start.sh

@@ -3,6 +3,7 @@
 source ./style_info.cfg
 source ./path_info.cfg
 source ./function.sh
+ulimit -n 200000
 list1=$(cat $config_path | grep openImApiPort | awk -F '[:]' '{print $NF}')
 list2=$(cat $config_path | grep openImWsPort | awk -F '[:]' '{print $NF}')
 list3=$(cat $config_path | grep openImSdkWsPort | awk -F '[:]' '{print $NF}')

script/start_rpc_service.sh

@@ -19,6 +19,9 @@ service_filename=(
   open_im_statistics
   ${msg_name}
   open_im_office
+  open_im_organization
+  open_im_conversation
+  open_im_cache
 )
 
 #service config port name
@@ -34,8 +37,11 @@ service_port_name=(
   openImAdminCmsPort
   openImMessageCmsPort
   openImStatisticsPort
-  openImOfflineMessagePort
+  openImMessagePort
   openImOfficePort
+  openImOrganizationPort
+  openImConversationPort
+  openImCachePort
 )
 
 for ((i = 0; i < ${#service_filename[*]}; i++)); do
@@ -64,4 +70,4 @@ for ((i = 0; i < ${#service_filename[*]}; i++)); do
     pid="netstat -ntlp|grep $j |awk '{printf \$7}'|cut -d/ -f1"
     echo -e "${GREEN_PREFIX}${service_filename[$i]} start success,port number:$j pid:$(eval $pid)$COLOR_SUFFIX"
   done
-done
+done