cache

This reverts commit 766b6e9f

cmd/open_im_api/main.go

@@ -8,28 +8,43 @@ 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/constant"
+	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
 	"flag"
+	"fmt"
+	"io"
+	"os"
 	"strconv"
 
 	"github.com/gin-gonic/gin"
 	//"syscall"
+	"Open_IM/pkg/common/constant"
 )
 
 func main() {
+	log.NewPrivateLog(constant.LogFileName)
 	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)
 	// 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")
@@ -73,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")
@@ -114,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")
@@ -125,10 +144,44 @@ 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)
 	}
-	apiThird.MinioInit()
-	log.NewPrivateLog(constant.LogFileName)
-	ginPort := flag.Int("port", 10000, "get ginServerPort from cmd,default 10000 as port")
+
+	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", 10002, "get ginServerPort from cmd,default 10000 as port")
 	flag.Parse()
-	r.Run(":" + strconv.Itoa(*ginPort))
+	fmt.Println("start api server, port: ", *ginPort)
+	err := r.Run(":" + strconv.Itoa(*ginPort))
+	if err != nil {
+		log.Error("", "run failed ", *ginPort, err.Error())
+	}
 }

cmd/open_im_cms_api/main.go

@@ -3,6 +3,9 @@ package main
 import (
 	"Open_IM/internal/cms_api"
 	"Open_IM/pkg/utils"
+	"flag"
+	"fmt"
+	"strconv"
 
 	"github.com/gin-gonic/gin"
 )
@@ -11,5 +14,10 @@ func main() {
 	gin.SetMode(gin.ReleaseMode)
 	router := cms_api.NewGinRouter()
 	router.Use(utils.CorsHandler())
-	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

@@ -2,21 +2,28 @@ package main
 
 import (
 	"Open_IM/internal/demo/register"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
 	"flag"
+	"fmt"
+	"io"
+	"os"
 	"strconv"
 
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
 	"github.com/gin-gonic/gin"
 )
 
 func main() {
+	log.NewPrivateLog(constant.LogFileName)
+	gin.SetMode(gin.ReleaseMode)
+	f, _ := os.Create("../logs/api.log")
+	gin.DefaultWriter = io.MultiWriter(f)
 
 	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)
@@ -24,8 +31,12 @@ func main() {
 		authRouterGroup.POST("/login", register.Login)
 		authRouterGroup.POST("/reset_password", register.ResetPassword)
 	}
-	log.NewPrivateLog(constant.LogFileName)
+
 	ginPort := flag.Int("port", 42233, "get ginServerPort from cmd,default 42233 as port")
 	flag.Parse()
-	r.Run(":" + strconv.Itoa(*ginPort))
+	fmt.Println("start demo api server, port: ", *ginPort)
+	err := r.Run(":" + strconv.Itoa(*ginPort))
+	if err != nil {
+		log.Error("", "run failed ", *ginPort, err.Error())
+	}
 }

cmd/open_im_msg_gateway/main.go

@@ -2,16 +2,21 @@ package main
 
 import (
 	"Open_IM/internal/msg_gateway/gate"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
 	"flag"
+	"fmt"
 	"sync"
 )
 
 func main() {
+	log.NewPrivateLog(constant.LogFileName)
 	rpcPort := flag.Int("rpc_port", 10400, "rpc listening port")
 	wsPort := flag.Int("ws_port", 17778, "ws listening port")
 	flag.Parse()
 	var wg sync.WaitGroup
 	wg.Add(1)
+	fmt.Println("start rpc/msg_gateway server, port: ", *rpcPort, *wsPort)
 	gate.Init(*rpcPort, *wsPort)
 	gate.Run()
 	wg.Wait()

cmd/open_im_msg_transfer/main.go

@@ -2,13 +2,18 @@ package main
 
 import (
 	"Open_IM/internal/msg_transfer/logic"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
+	"fmt"
 	"sync"
 )
 
 func main() {
 	var wg sync.WaitGroup
 	wg.Add(1)
+	log.NewPrivateLog(constant.LogFileName)
 	logic.Init()
+	fmt.Println("start msg_transfer server")
 	logic.Run()
 	wg.Wait()
 }

cmd/open_im_push/main.go

@@ -2,7 +2,10 @@ package main
 
 import (
 	"Open_IM/internal/push/logic"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
 	"flag"
+	"fmt"
 	"sync"
 )
 
@@ -11,6 +14,8 @@ func main() {
 	flag.Parse()
 	var wg sync.WaitGroup
 	wg.Add(1)
+	log.NewPrivateLog(constant.LogFileName)
+	fmt.Println("start push rpc server, port: ", *rpcPort)
 	logic.Init(*rpcPort)
 	logic.Run()
 	wg.Wait()

cmd/open_im_timer_task/main.go

@@ -2,10 +2,7 @@ package main
 
 import (
 	"Open_IM/pkg/common/constant"
-	commonDB "Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	"Open_IM/pkg/common/log"
-	"time"
 )
 
 func main() {
@@ -40,27 +37,27 @@ func main() {
 	//		time.Sleep(time.Duration(sleepTime) * time.Second)
 	//	}
 	//}
-	for {
-		uidList, err := im_mysql_model.SelectAllUserID()
-		if err != nil {
-			//log.NewError("999999", err.Error())
-		} else {
-			for _, v := range uidList {
-				minSeq, err := commonDB.DB.GetMinSeqFromMongo(v)
-				if err != nil {
-					//log.NewError("999999", "get user minSeq err", err.Error(), v)
-					continue
-				} else {
-					err := commonDB.DB.SetUserMinSeq(v, minSeq)
-					if err != nil {
-						//log.NewError("999999", "set user minSeq err", err.Error(), v)
-					}
-				}
-				time.Sleep(time.Duration(100) * time.Millisecond)
-			}
-
-		}
-
-	}
+	//for {
+	//	uidList, err := im_mysql_model.SelectAllUserID()
+	//	if err != nil {
+	//		//log.NewError("999999", err.Error())
+	//	} else {
+	//		for _, v := range uidList {
+	//			minSeq, err := commonDB.DB.GetMinSeqFromMongo(v)
+	//			if err != nil {
+	//				//log.NewError("999999", "get user minSeq err", err.Error(), v)
+	//				continue
+	//			} else {
+	//				err := commonDB.DB.SetUserMinSeq(v, minSeq)
+	//				if err != nil {
+	//					//log.NewError("999999", "set user minSeq err", err.Error(), v)
+	//				}
+	//			}
+	//			time.Sleep(time.Duration(100) * time.Millisecond)
+	//		}
+	//
+	//	}
+	//
+	//}
 
 }

cmd/rpc/open_im_admin_cms/main.go

@@ -3,12 +3,13 @@ package main
 import (
 	rpcMessageCMS "Open_IM/internal/rpc/admin_cms"
 	"flag"
+	"fmt"
 )
 
 func main() {
 	rpcPort := flag.Int("port", 11000, "rpc listening port")
 	flag.Parse()
+	fmt.Println("start cms rpc server, port: ", *rpcPort)
 	rpcServer := rpcMessageCMS.NewAdminCMSServer(*rpcPort)
 	rpcServer.Run()
 }
-

cmd/rpc/open_im_auth/main.go

@@ -3,11 +3,13 @@ package main
 import (
 	rpcAuth "Open_IM/internal/rpc/auth"
 	"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 := rpcAuth.NewRpcAuthServer(*rpcPort)
 	rpcServer.Run()
 

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_friend/main.go

@@ -3,12 +3,14 @@ package main
 import (
 	"Open_IM/internal/rpc/friend"
 	"flag"
+	"fmt"
 )
 
 func main() {
 
 	rpcPort := flag.Int("port", 10200, "get RpcFriendPort from cmd,default 12000 as port")
 	flag.Parse()
+	fmt.Println("start friend rpc server, port: ", *rpcPort)
 	rpcServer := friend.NewFriendServer(*rpcPort)
 	rpcServer.Run()
 }

cmd/rpc/open_im_group/main.go

@@ -3,11 +3,13 @@ package main
 import (
 	"Open_IM/internal/rpc/group"
 	"flag"
+	"fmt"
 )
 
 func main() {
 	rpcPort := flag.Int("port", 10500, "get RpcGroupPort from cmd,default 16000 as port")
 	flag.Parse()
+	fmt.Println("start group rpc server, port: ", *rpcPort)
 	rpcServer := group.NewGroupServer(*rpcPort)
 	rpcServer.Run()
 }

cmd/rpc/open_im_message_cms/main.go

@@ -3,11 +3,13 @@ package main
 import (
 	rpcMessageCMS "Open_IM/internal/rpc/message_cms"
 	"flag"
+	"fmt"
 )
 
 func main() {
 	rpcPort := flag.Int("port", 10900, "rpc listening port")
 	flag.Parse()
+	fmt.Println("start msg cms rpc server, port: ", *rpcPort)
 	rpcServer := rpcMessageCMS.NewMessageCMSServer(*rpcPort)
 	rpcServer.Run()
 }

cmd/rpc/open_im_msg/main.go

@@ -3,11 +3,13 @@ package main
 import (
 	rpcChat "Open_IM/internal/rpc/msg"
 	"flag"
+	"fmt"
 )
 
 func main() {
 	rpcPort := flag.Int("port", 10300, "rpc listening port")
 	flag.Parse()
+	fmt.Println("start msg rpc server, port: ", *rpcPort)
 	rpcServer := rpcChat.NewRpcChatServer(*rpcPort)
 	rpcServer.Run()
 }

cmd/rpc/open_im_office/main.go

@@ -3,11 +3,13 @@ package main
 import (
 	rpc "Open_IM/internal/rpc/office"
 	"flag"
+	"fmt"
 )
 
 func main() {
 	rpcPort := flag.Int("port", 11100, "rpc listening port")
 	flag.Parse()
+	fmt.Println("start office rpc server, port: ", *rpcPort)
 	rpcServer := rpc.NewOfficeServer(*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()
+}

cmd/rpc/open_im_statistics/main.go

@@ -3,11 +3,13 @@ package main
 import (
 	"Open_IM/internal/rpc/statistics"
 	"flag"
+	"fmt"
 )
 
 func main() {
 	rpcPort := flag.Int("port", 10800, "rpc listening port")
 	flag.Parse()
+	fmt.Println("start statistics rpc server, port: ", *rpcPort)
 	rpcServer := statistics.NewStatisticsServer(*rpcPort)
 	rpcServer.Run()
 }

cmd/rpc/open_im_user/main.go

@@ -3,11 +3,13 @@ package main
 import (
 	"Open_IM/internal/rpc/user"
 	"flag"
+	"fmt"
 )
 
 func main() {
 	rpcPort := flag.Int("port", 10100, "rpc listening port")
 	flag.Parse()
+	fmt.Println("start user rpc server, port: ", *rpcPort)
 	rpcServer := user.NewUserServer(*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://127.0.0.1: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,11 +168,12 @@ modulename: #日志文件按模块命名，默认即可
   pushName: push
 
 longconnsvr:
-  openImWsPort: [ 17778 ] # ws服务端口，默认即可，要开放此端口或做nginx转发
+  openImWsPort: [ 10001 ] # ws服务端口，默认即可，要开放此端口或做nginx转发
   websocketMaxConnNum: 10000
   websocketMaxMsgLen: 4096
   websocketTimeOut: 10
 
+## 推送只能开启一个 enable代表开启
 push:
   tpns: #腾讯推送，暂未测试 暂不要使用
     ios:
@@ -173,11 +182,22 @@ push:
     android:
       accessID: 111
       secretKey: 111
+    enable: false
   jpns: #极光推送 在极光后台申请后，修改以下四项，必须修改
     appKey: cf47465a368f24c659608e7e
     masterSecret: 02204efe3f3832947a236ee5
     pushUrl: "https://api.jpush.cn/v3/push"
     pushIntent: "intent:#Intent;component=io.openim.app.enterprisechat/io.openim.app.enterprisechat.MainActivity;end"
+    enable: true
+  getui:  #个推推送，暂未测试 暂不要使用
+    pushUrl: "https://restapi.getui.com/v2/$appId"
+    masterSecret: ""
+    appKey: ""
+    intent: ""
+    enable: false
+
+
+
 manager:
   #app管理员userID和对应的secret  建议修改。 用于管理后台登录，也可以用户管理后台对应的api
   appManagerUid: [ "openIM123456","openIM654321", "openIM333", "openIMAdmin"]
@@ -188,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生成相关，默认即可
@@ -416,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:
@@ -553,7 +604,7 @@ notification:
 
   conversationSetPrivate:
     conversation:
-      reliabilityLevel: 2
+      reliabilityLevel: 3
       unreadCount: true
     offlinePush:
       switch: true
@@ -564,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---------------------#
@@ -572,7 +636,7 @@ notification:
 demoswitch: true
 demo:
   #demo对外服务端口，默认即可，需要开放此端口或做nginx转发
-  openImDemoPort: [ 42233 ]
+  openImDemoPort: [ 10004 ]
   alismsverify: #阿里云短信配置，在阿里云申请成功后修改以下四项，必须修改
     accessKeyId: LTAI5tJPkn4HuuePdiLdGqe7
     accessKeySecret: 4n9OJ7ZCVN1U6KeHDAtOyNeVZcjOuV
@@ -588,5 +652,6 @@ demo:
     smtpAddr: "smtp.qq.com"
     smtpPort: 25   #需开放此端口 出口方向
 
-
-
+rtc:
+  port: 11300
+  address: 127.0.0.1

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.5
+    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{}}
@@ -35,17 +37,25 @@ func UserRegister(c *gin.Context) {
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
 	client := rpc.NewAuthClient(etcdConn)
 	reply, err := client.UserRegister(context.Background(), req)
-	if err != nil || reply.CommonResp.ErrCode != 0 {
-		log.NewError(req.OperationID, "UserRegister failed ", err, reply.CommonResp.ErrCode)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": reply.CommonResp.ErrMsg})
+	if err != nil {
+		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 {
+		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},
@@ -58,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}
@@ -74,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"
 )
 
@@ -15,18 +16,28 @@ var (
 )
 
 func MinioInit() {
-	log.NewInfo("", utils.GetSelfFuncName())
-	minioUrl, err := url2.Parse(config.Config.Credential.Minio.Endpoint)
+	operationID := utils.OperationIDGenerator()
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "minio config: ", config.Config.Credential.Minio)
+	var initUrl string
+	if config.Config.Credential.Minio.EndpointInnerEnable {
+		initUrl = config.Config.Credential.Minio.EndpointInner
+	} else {
+		initUrl = config.Config.Credential.Minio.Endpoint
+	}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "use initUrl: ", initUrl)
+	minioUrl, err := url2.Parse(initUrl)
 	if err != nil {
-		log.NewError("", utils.GetSelfFuncName(), "parse failed, please check config/config.yaml", err.Error())
+		log.NewError(operationID, utils.GetSelfFuncName(), "parse failed, please check config/config.yaml", err.Error())
 		return
 	}
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "Parse ok ", config.Config.Credential.Minio)
 	minioClient, err = minio.New(minioUrl.Host, &minio.Options{
 		Creds:  credentials.NewStaticV4(config.Config.Credential.Minio.AccessKeyID, config.Config.Credential.Minio.SecretAccessKey, ""),
 		Secure: false,
 	})
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "new ok ", config.Config.Credential.Minio)
 	if err != nil {
-		log.NewError("", utils.GetSelfFuncName(), "init minio client failed", err.Error())
+		log.NewError(operationID, utils.GetSelfFuncName(), "init minio client failed", err.Error())
 		return
 	}
 	opt := minio.MakeBucketOptions{
@@ -35,23 +46,23 @@ func MinioInit() {
 	}
 	err = minioClient.MakeBucket(context.Background(), config.Config.Credential.Minio.Bucket, opt)
 	if err != nil {
-		log.NewInfo("", utils.GetSelfFuncName(), err.Error())
+		log.NewError(operationID, utils.GetSelfFuncName(), "MakeBucket failed ", err.Error())
 		exists, err := minioClient.BucketExists(context.Background(), config.Config.Credential.Minio.Bucket)
 		if err == nil && exists {
-			log.NewInfo("", utils.GetSelfFuncName(), "We already own %s\n", config.Config.Credential.Minio.Bucket)
+			log.NewWarn(operationID, utils.GetSelfFuncName(), "We already own ", config.Config.Credential.Minio.Bucket)
 		} else {
 			if err != nil {
-				log.NewError("", utils.GetSelfFuncName(), err.Error())
+				log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
 			}
-			log.NewError("", utils.GetSelfFuncName(), "create bucket failed and bucket not exists")
+			log.NewError(operationID, utils.GetSelfFuncName(), "create bucket failed and bucket not exists")
 			return
 		}
 	}
 	// 自动化桶public的代码
-	//err = minioClient.SetBucketPolicy(context.Background(), config.Config.Credential.Minio.Bucket, policy.BucketPolicyReadWrite)
-	//if err != nil {
-	//	log.NewError("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
-	//	return
-	//}
-	log.NewInfo("", utils.GetSelfFuncName(), "minio create and set policy success")
+	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/group/group.go

@@ -43,6 +43,7 @@ func GetGroupById(c *gin.Context) {
 	resp.ProfilePhoto = respPb.CMSGroup.GroupInfo.FaceURL
 	resp.GroupMasterName = respPb.CMSGroup.GroupMasterName
 	resp.GroupMasterId = respPb.CMSGroup.GroupMasterId
+	resp.IsBanChat = constant.GroupIsBanChat(respPb.CMSGroup.GroupInfo.Status)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -74,7 +75,7 @@ func GetGroups(c *gin.Context) {
 			GroupMasterName:  v.GroupMasterName,
 			GroupMasterId:    v.GroupMasterId,
 			CreateTime:       (utils.UnixSecondToTime(int64(v.GroupInfo.CreateTime))).String(),
-			IsBanChat:        false,
+			IsBanChat:        constant.GroupIsBanChat(v.GroupInfo.Status),
 			IsBanPrivateChat: false,
 			ProfilePhoto:     v.GroupInfo.FaceURL,
 		})
@@ -114,7 +115,7 @@ func GetGroupByName(c *gin.Context) {
 			GroupMasterName:  v.GroupMasterName,
 			GroupMasterId:    v.GroupMasterId,
 			CreateTime:       (utils.UnixSecondToTime(int64(v.GroupInfo.CreateTime))).String(),
-			IsBanChat:        false,
+			IsBanChat:        constant.GroupIsBanChat(v.GroupInfo.Status),
 			IsBanPrivateChat: false,
 			ProfilePhoto:     v.GroupInfo.FaceURL,
 		})

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

@@ -2,8 +2,7 @@ package gate
 
 import (
 	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
+
 	"Open_IM/pkg/statistics"
 	"fmt"
 	"github.com/go-playground/validator/v10"
@@ -21,7 +20,7 @@ var (
 
 func Init(rpcPort, wsPort int) {
 	//log initialization
-	log.NewPrivateLog(constant.LogFileName)
+
 	rwLock = new(sync.RWMutex)
 	validate = validator.New()
 	statistics.NewStatistics(&sendMsgCount, config.Config.ModuleName.LongConnSvrName, fmt.Sprintf("%d second recv to msg_gateway sendMsgCount", sendMsgCount), 300)

internal/msg_gateway/gate/logic.go

@@ -6,13 +6,17 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbChat "Open_IM/pkg/proto/chat"
+	pbRtc "Open_IM/pkg/proto/rtc"
 	sdk_ws "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
 	"bytes"
 	"context"
 	"encoding/gob"
 	"github.com/golang/protobuf/proto"
 	"github.com/gorilla/websocket"
+	"google.golang.org/grpc"
 	"runtime"
+	"strconv"
 	"strings"
 )
 
@@ -200,38 +204,61 @@ func (ws *WServer) sendSignalMsgReq(conn *UserConn, m *Req) {
 	nReply := new(pbChat.SendMsgResp)
 	isPass, errCode, errMsg, pData := ws.argsValidate(m, constant.WSSendSignalMsg)
 	if isPass {
-		isPass2, errCode2, errMsg2, signalResp, msgData := ws.signalMessageAssemble(pData.(*sdk_ws.SignalReq), m.OperationID)
-		if isPass2 {
+		signalResp := pbRtc.SignalResp{}
+		//isPass2, errCode2, errMsg2, signalResp, msgData := ws.signalMessageAssemble(pData.(*sdk_ws.SignalReq), m.OperationID)
+		connGrpc, err := grpc.Dial(config.Config.Rtc.Address+":"+strconv.Itoa(config.Config.Rtc.Port), grpc.WithInsecure())
+		if err != nil {
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), "grpc.Dial failed", err.Error())
+			ws.sendSignalMsgResp(conn, 204, "create grpc failed"+err.Error(), m, nil)
+			return
+		}
+		rtcClient := pbRtc.NewRtcServiceClient(connGrpc)
+		req := &pbRtc.SignalMessageAssembleReq{
+			SignalReq:   pData.(*pbRtc.SignalReq),
+			OperationID: m.OperationID,
+		}
+		respPb, err := rtcClient.SignalMessageAssemble(context.Background(), req)
+		if err != nil {
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), "SignalMessageAssemble", err.Error(), config.Config.Rtc.Address+":"+strconv.Itoa(config.Config.Rtc.Port))
+			ws.sendSignalMsgResp(conn, 204, "grpc SignalMessageAssemble failed: "+err.Error(), m, &signalResp)
+			return
+		}
+		signalResp.Payload = respPb.SignalResp.Payload
+		msgData := sdk_ws.MsgData{}
+		utils.CopyStructFields(&msgData, respPb.MsgData)
+		log.NewInfo(m.OperationID, utils.GetSelfFuncName(), respPb.String())
+		if respPb.IsPass {
 			pbData := pbChat.SendMsgReq{
 				Token:       m.Token,
 				OperationID: m.OperationID,
-				MsgData:     msgData,
+				MsgData:     &msgData,
 			}
+			log.NewInfo(m.OperationID, utils.GetSelfFuncName(), "pbData: ", pbData)
 			log.NewInfo(m.OperationID, "Ws call success to sendSignalMsgReq middle", m.ReqIdentifier, m.SendID, m.MsgIncr, msgData)
 			etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
 			client := pbChat.NewChatClient(etcdConn)
 			reply, err := client.SendMsg(context.Background(), &pbData)
 			if err != nil {
-				log.NewError(pbData.OperationID, "rpc sendMsg err", err.Error())
+				log.NewError(pbData.OperationID, utils.GetSelfFuncName(), "rpc sendMsg err", err.Error())
 				nReply.ErrCode = 200
 				nReply.ErrMsg = err.Error()
-				ws.sendSignalMsgResp(conn, 200, err.Error(), m, signalResp)
+				ws.sendSignalMsgResp(conn, 200, err.Error(), m, &signalResp)
 			} else {
 				log.NewInfo(pbData.OperationID, "rpc call success to sendMsgReq", reply.String())
-				ws.sendSignalMsgResp(conn, 0, "", m, signalResp)
+				ws.sendSignalMsgResp(conn, 0, "", m, &signalResp)
 			}
 		} else {
-			log.NewError(m.OperationID, isPass2, errCode2, errMsg2)
-			ws.sendSignalMsgResp(conn, errCode2, errMsg2, m, signalResp)
+			log.NewError(m.OperationID, utils.GetSelfFuncName(), respPb.IsPass, respPb.CommonResp.ErrCode, respPb.CommonResp.ErrMsg)
+			ws.sendSignalMsgResp(conn, respPb.CommonResp.ErrCode, respPb.CommonResp.ErrMsg, m, &signalResp)
 		}
 	} else {
 		ws.sendSignalMsgResp(conn, errCode, errMsg, m, nil)
 	}
 
 }
-func (ws *WServer) sendSignalMsgResp(conn *UserConn, errCode int32, errMsg string, m *Req, pb *sdk_ws.SignalResp) {
+func (ws *WServer) sendSignalMsgResp(conn *UserConn, errCode int32, errMsg string, m *Req, pb *pbRtc.SignalResp) {
 	// := make(map[string]interface{})
-
+	log.Debug(m.OperationID, "SignalMsgResp is", pb.String())
 	b, _ := proto.Marshal(pb)
 	mReply := Resp{
 		ReqIdentifier: m.ReqIdentifier,

internal/msg_gateway/gate/open_im_media/room.go

@@ -1,14 +1,5 @@
 package open_im_media
 
-import (
-	pbRtc "Open_IM/pkg/proto/rtc"
-	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
-	"context"
-	"errors"
-	"github.com/jinzhu/copier"
-	"google.golang.org/grpc"
-)
-
 const (
 	// Address gRPC服务地址
 	Address = "127.0.0.1:11300"
@@ -23,35 +14,35 @@ func NewMedia() *Media {
 	return &Media{}
 }
 
-func (m *Media) GetJoinToken(room, identity string, operationID string, data *open_im_sdk.ParticipantMetaData) (string, string, error) {
-	var newData pbRtc.ParticipantMetaData
-	copier.Copy(&newData, data)
-	conn, err := grpc.Dial(Address, grpc.WithInsecure())
-	if err != nil {
-		return "", "", err
-	}
-	defer conn.Close()
-	c := pbRtc.NewRtcServiceClient(conn)
-	req := &pbRtc.GetJoinTokenReq{Room: room, OperationID: operationID, Identity: identity, MetaData: &newData}
-	resp, err := c.GetJoinToken(context.Background(), req)
-	if err != nil {
-		return "", "", err
-	}
-	if resp.CommonResp.ErrCode != 0 {
-		return "", "", errors.New(resp.CommonResp.ErrMsg)
-	}
-	return resp.Jwt, resp.LiveURL, nil
-	//at := auth.NewAccessToken(m.ApiKey, m.ApiSecret)
-	//grant := &auth.VideoGrant{
-	//	RoomJoin: true,
-	//	Room:     room,
-	//}
-	//at.AddGrant(grant).
-	//	SetIdentity(identity).
-	//	SetValidFor(time.Hour)
-	//
-	//return at.ToJWT()
-}
+//func (m *Media) GetJoinToken(room, identity string, operationID string, data *open_im_sdk.ParticipantMetaData) (string, string, error) {
+//	var newData pbRtc.ParticipantMetaData
+//	copier.Copy(&newData, data)
+//	conn, err := grpc.Dial(Address, grpc.WithInsecure())
+//	if err != nil {
+//		return "", "", err
+//	}
+//	defer conn.Close()
+//	c := pbRtc.NewRtcServiceClient(conn)
+//	req := &pbRtc.GetJoinTokenReq{Room: room, OperationID: operationID, Identity: identity, MetaData: &newData}
+//	resp, err := c.GetJoinToken(context.Background(), req)
+//	if err != nil {
+//		return "", "", err
+//	}
+//	if resp.CommonResp.ErrCode != 0 {
+//		return "", "", errors.New(resp.CommonResp.ErrMsg)
+//	}
+//	return resp.Jwt, resp.LiveURL, nil
+//	//at := auth.NewAccessToken(m.ApiKey, m.ApiSecret)
+//	//grant := &auth.VideoGrant{
+//	//	RoomJoin: true,
+//	//	Room:     room,
+//	//}
+//	//at.AddGrant(grant).
+//	//	SetIdentity(identity).
+//	//	SetValidFor(time.Hour)
+//	//
+//	//return at.ToJWT()
+//}
 
 func init() {
 	//roomClient = lksdk.NewRoomServiceClient(MediaAddress, ApiKey, ApiSecret)

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

@@ -7,12 +7,10 @@
 package gate
 
 import (
-	"Open_IM/internal/msg_gateway/gate/open_im_media"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
+	pbRtc "Open_IM/pkg/proto/rtc"
 	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
-	"Open_IM/pkg/utils"
-	"errors"
 	"github.com/golang/protobuf/proto"
 )
 
@@ -74,7 +72,7 @@ func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, er
 		}
 		return true, 0, "", data
 	case constant.WSSendSignalMsg:
-		data := open_im_sdk.SignalReq{}
+		data := pbRtc.SignalReq{}
 		if err := proto.Unmarshal(m.Data, &data); err != nil {
 			log.ErrorByKv("Decode Data struct  err", "", "err", err.Error(), "reqIdentifier", r)
 			return false, 203, err.Error(), nil
@@ -117,139 +115,139 @@ func (ws *WServer) argsValidate(m *Req, r int32) (isPass bool, errCode int32, er
 
 }
 
-func (ws *WServer) signalMessageAssemble(s *open_im_sdk.SignalReq, operationID string) (isPass bool, errCode int32, errMsg string, r *open_im_sdk.SignalResp, msgData *open_im_sdk.MsgData) {
-	var msg open_im_sdk.MsgData
-	var resp open_im_sdk.SignalResp
-	media := open_im_media.NewMedia()
-	msg.MsgFrom = constant.UserMsgType
-	msg.ContentType = constant.SignalingNotification
-	reqData, e := proto.Marshal(s)
-	if e != nil {
-		return false, 201, e.Error(), nil, nil
-	}
-	msg.Content = reqData
-	msg.CreateTime = utils.GetCurrentTimestampByMill()
-	options := make(map[string]bool, 6)
-	utils.SetSwitchFromOptions(options, constant.IsHistory, false)
-	utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
-	utils.SetSwitchFromOptions(options, constant.IsSenderSync, true)
-	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
-	utils.SetSwitchFromOptions(options, constant.IsSenderConversationUpdate, false)
-	utils.SetSwitchFromOptions(options, constant.IsUnreadCount, false)
-	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, true)
-	msg.Options = options
-	switch payload := s.Payload.(type) {
-	case *open_im_sdk.SignalReq_Invite:
-		token, liveURL, err2 := media.GetJoinToken(payload.Invite.Invitation.RoomID, payload.Invite.Invitation.InviterUserID, operationID, payload.Invite.Participant)
-		if err2 != nil {
-			return false, 202, err2.Error(), nil, nil
-		}
-		invite := open_im_sdk.SignalResp_Invite{&open_im_sdk.SignalInviteReply{
-			Token:   token,
-			RoomID:  payload.Invite.Invitation.RoomID,
-			LiveURL: liveURL,
-		}}
-		resp.Payload = &invite
-		msg.SenderPlatformID = payload.Invite.Invitation.PlatformID
-		msg.SessionType = payload.Invite.Invitation.SessionType
-		msg.OfflinePushInfo = payload.Invite.OfflinePushInfo
-		msg.SendID = payload.Invite.Invitation.InviterUserID
-		if len(payload.Invite.Invitation.InviteeUserIDList) > 0 {
-			msg.RecvID = payload.Invite.Invitation.InviteeUserIDList[0]
-		} else {
-			return false, 203, errors.New("InviteeUserIDList is null").Error(), nil, nil
-		}
-		msg.ClientMsgID = utils.GetMsgID(payload.Invite.Invitation.InviterUserID)
-		return true, 0, "", &resp, &msg
-	case *open_im_sdk.SignalReq_InviteInGroup:
-		token, liveURL, err2 := media.GetJoinToken(payload.InviteInGroup.Invitation.RoomID, payload.InviteInGroup.Invitation.InviterUserID, operationID, payload.InviteInGroup.Participant)
-		if err2 != nil {
-			return false, 204, err2.Error(), nil, nil
-		}
-		inviteGroup := open_im_sdk.SignalResp_InviteInGroup{&open_im_sdk.SignalInviteInGroupReply{
-			RoomID:  payload.InviteInGroup.Invitation.RoomID,
-			Token:   token,
-			LiveURL: liveURL,
-		}}
-		resp.Payload = &inviteGroup
-		msg.SenderPlatformID = payload.InviteInGroup.Invitation.PlatformID
-		msg.SessionType = payload.InviteInGroup.Invitation.SessionType
-		msg.OfflinePushInfo = payload.InviteInGroup.OfflinePushInfo
-		msg.SendID = payload.InviteInGroup.Invitation.InviterUserID
-		if len(payload.InviteInGroup.Invitation.InviteeUserIDList) > 0 {
-			msg.GroupID = payload.InviteInGroup.Invitation.GroupID
-		} else {
-			return false, 205, errors.New("InviteeUserIDList is null").Error(), nil, nil
-		}
-		msg.ClientMsgID = utils.GetMsgID(payload.InviteInGroup.Invitation.InviterUserID)
-
-		return true, 0, "", &resp, &msg
-	case *open_im_sdk.SignalReq_Cancel:
-		cancel := open_im_sdk.SignalResp_Cancel{&open_im_sdk.SignalCancelReply{}}
-		resp.Payload = &cancel
-		msg.OfflinePushInfo = payload.Cancel.OfflinePushInfo
-		msg.SendID = payload.Cancel.Invitation.InviterUserID
-		msg.SenderPlatformID = payload.Cancel.Invitation.PlatformID
-		msg.SessionType = payload.Cancel.Invitation.SessionType
-		if len(payload.Cancel.Invitation.InviteeUserIDList) > 0 {
-			switch payload.Cancel.Invitation.SessionType {
-			case constant.SingleChatType:
-				msg.RecvID = payload.Cancel.Invitation.InviteeUserIDList[0]
-			case constant.GroupChatType:
-				msg.GroupID = payload.Cancel.Invitation.GroupID
-			}
-		} else {
-			return false, 206, errors.New("InviteeUserIDList is null").Error(), nil, nil
-		}
-		msg.ClientMsgID = utils.GetMsgID(payload.Cancel.OpUserID)
-		return true, 0, "", &resp, &msg
-	case *open_im_sdk.SignalReq_Accept:
-		token, liveURL, err2 := media.GetJoinToken(payload.Accept.Invitation.RoomID, payload.Accept.OpUserID, operationID, payload.Accept.Participant)
-		if err2 != nil {
-			return false, 207, err2.Error(), nil, nil
-		}
-		accept := open_im_sdk.SignalResp_Accept{&open_im_sdk.SignalAcceptReply{
-			Token:   token,
-			LiveURL: liveURL,
-			RoomID:  payload.Accept.Invitation.RoomID,
-		}}
-		resp.Payload = &accept
-		msg.OfflinePushInfo = payload.Accept.OfflinePushInfo
-		msg.SendID = payload.Accept.OpUserID
-		msg.SenderPlatformID = payload.Accept.Invitation.PlatformID
-		msg.SessionType = payload.Accept.Invitation.SessionType
-		if len(payload.Accept.Invitation.InviteeUserIDList) > 0 {
-			switch payload.Accept.Invitation.SessionType {
-			case constant.SingleChatType:
-				msg.RecvID = payload.Accept.Invitation.InviterUserID
-			case constant.GroupChatType:
-				msg.GroupID = payload.Accept.Invitation.GroupID
-			}
-		} else {
-			return false, 208, errors.New("InviteeUserIDList is null").Error(), nil, nil
-		}
-		msg.ClientMsgID = utils.GetMsgID(payload.Accept.OpUserID)
-		return true, 0, "", &resp, &msg
-	case *open_im_sdk.SignalReq_HungUp:
-	case *open_im_sdk.SignalReq_Reject:
-		reject := open_im_sdk.SignalResp_Reject{&open_im_sdk.SignalRejectReply{}}
-		resp.Payload = &reject
-		msg.OfflinePushInfo = payload.Reject.OfflinePushInfo
-		msg.SendID = payload.Reject.OpUserID
-		msg.SenderPlatformID = payload.Reject.Invitation.PlatformID
-		msg.SessionType = payload.Reject.Invitation.SessionType
-		if len(payload.Reject.Invitation.InviteeUserIDList) > 0 {
-			switch payload.Reject.Invitation.SessionType {
-			case constant.SingleChatType:
-				msg.RecvID = payload.Reject.Invitation.InviterUserID
-			case constant.GroupChatType:
-				msg.GroupID = payload.Reject.Invitation.GroupID
-			}
-		} else {
-			return false, 209, errors.New("InviteeUserIDList is null").Error(), nil, nil
-		}
-		msg.ClientMsgID = utils.GetMsgID(payload.Reject.OpUserID)
-		return true, 0, "", &resp, &msg
-	}
-	return false, 210, errors.New("InviteeUserIDList is null").Error(), nil, nil
-}
+//func (ws *WServer) signalMessageAssemble(s *open_im_sdk.SignalReq, operationID string) (isPass bool, errCode int32, errMsg string, r *open_im_sdk.SignalResp, msgData *open_im_sdk.MsgData) {
+//	var msg open_im_sdk.MsgData
+//	var resp open_im_sdk.SignalResp
+//	media := open_im_media.NewMedia()
+//	msg.MsgFrom = constant.UserMsgType
+//	msg.ContentType = constant.SignalingNotification
+//	reqData, e := proto.Marshal(s)
+//	if e != nil {
+//		return false, 201, e.Error(), nil, nil
+//	}
+//	msg.Content = reqData
+//	msg.CreateTime = utils.GetCurrentTimestampByMill()
+//	options := make(map[string]bool, 6)
+//	utils.SetSwitchFromOptions(options, constant.IsHistory, false)
+//	utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
+//	utils.SetSwitchFromOptions(options, constant.IsSenderSync, true)
+//	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
+//	utils.SetSwitchFromOptions(options, constant.IsSenderConversationUpdate, false)
+//	utils.SetSwitchFromOptions(options, constant.IsUnreadCount, false)
+//	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, true)
+//	msg.Options = options
+//	switch payload := s.Payload.(type) {
+//	case *open_im_sdk.SignalReq_Invite:
+//		token, liveURL, err2 := media.GetJoinToken(payload.Invite.Invitation.RoomID, payload.Invite.Invitation.InviterUserID, operationID, payload.Invite.Participant)
+//		if err2 != nil {
+//			return false, 202, err2.Error(), nil, nil
+//		}
+//		invite := open_im_sdk.SignalResp_Invite{&open_im_sdk.SignalInviteReply{
+//			Token:   token,
+//			RoomID:  payload.Invite.Invitation.RoomID,
+//			LiveURL: liveURL,
+//		}}
+//		resp.Payload = &invite
+//		msg.SenderPlatformID = payload.Invite.Invitation.PlatformID
+//		msg.SessionType = payload.Invite.Invitation.SessionType
+//		msg.OfflinePushInfo = payload.Invite.OfflinePushInfo
+//		msg.SendID = payload.Invite.Invitation.InviterUserID
+//		if len(payload.Invite.Invitation.InviteeUserIDList) > 0 {
+//			msg.RecvID = payload.Invite.Invitation.InviteeUserIDList[0]
+//		} else {
+//			return false, 203, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Invite.Invitation.InviterUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_InviteInGroup:
+//		token, liveURL, err2 := media.GetJoinToken(payload.InviteInGroup.Invitation.RoomID, payload.InviteInGroup.Invitation.InviterUserID, operationID, payload.InviteInGroup.Participant)
+//		if err2 != nil {
+//			return false, 204, err2.Error(), nil, nil
+//		}
+//		inviteGroup := open_im_sdk.SignalResp_InviteInGroup{&open_im_sdk.SignalInviteInGroupReply{
+//			RoomID:  payload.InviteInGroup.Invitation.RoomID,
+//			Token:   token,
+//			LiveURL: liveURL,
+//		}}
+//		resp.Payload = &inviteGroup
+//		msg.SenderPlatformID = payload.InviteInGroup.Invitation.PlatformID
+//		msg.SessionType = payload.InviteInGroup.Invitation.SessionType
+//		msg.OfflinePushInfo = payload.InviteInGroup.OfflinePushInfo
+//		msg.SendID = payload.InviteInGroup.Invitation.InviterUserID
+//		if len(payload.InviteInGroup.Invitation.InviteeUserIDList) > 0 {
+//			msg.GroupID = payload.InviteInGroup.Invitation.GroupID
+//		} else {
+//			return false, 205, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.InviteInGroup.Invitation.InviterUserID)
+//
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_Cancel:
+//		cancel := open_im_sdk.SignalResp_Cancel{&open_im_sdk.SignalCancelReply{}}
+//		resp.Payload = &cancel
+//		msg.OfflinePushInfo = payload.Cancel.OfflinePushInfo
+//		msg.SendID = payload.Cancel.Invitation.InviterUserID
+//		msg.SenderPlatformID = payload.Cancel.Invitation.PlatformID
+//		msg.SessionType = payload.Cancel.Invitation.SessionType
+//		if len(payload.Cancel.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Cancel.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Cancel.Invitation.InviteeUserIDList[0]
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Cancel.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 206, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Cancel.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_Accept:
+//		token, liveURL, err2 := media.GetJoinToken(payload.Accept.Invitation.RoomID, payload.Accept.OpUserID, operationID, payload.Accept.Participant)
+//		if err2 != nil {
+//			return false, 207, err2.Error(), nil, nil
+//		}
+//		accept := open_im_sdk.SignalResp_Accept{&open_im_sdk.SignalAcceptReply{
+//			Token:   token,
+//			LiveURL: liveURL,
+//			RoomID:  payload.Accept.Invitation.RoomID,
+//		}}
+//		resp.Payload = &accept
+//		msg.OfflinePushInfo = payload.Accept.OfflinePushInfo
+//		msg.SendID = payload.Accept.OpUserID
+//		msg.SenderPlatformID = payload.Accept.Invitation.PlatformID
+//		msg.SessionType = payload.Accept.Invitation.SessionType
+//		if len(payload.Accept.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Accept.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Accept.Invitation.InviterUserID
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Accept.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 208, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Accept.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	case *open_im_sdk.SignalReq_HungUp:
+//	case *open_im_sdk.SignalReq_Reject:
+//		reject := open_im_sdk.SignalResp_Reject{&open_im_sdk.SignalRejectReply{}}
+//		resp.Payload = &reject
+//		msg.OfflinePushInfo = payload.Reject.OfflinePushInfo
+//		msg.SendID = payload.Reject.OpUserID
+//		msg.SenderPlatformID = payload.Reject.Invitation.PlatformID
+//		msg.SessionType = payload.Reject.Invitation.SessionType
+//		if len(payload.Reject.Invitation.InviteeUserIDList) > 0 {
+//			switch payload.Reject.Invitation.SessionType {
+//			case constant.SingleChatType:
+//				msg.RecvID = payload.Reject.Invitation.InviterUserID
+//			case constant.GroupChatType:
+//				msg.GroupID = payload.Reject.Invitation.GroupID
+//			}
+//		} else {
+//			return false, 209, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//		}
+//		msg.ClientMsgID = utils.GetMsgID(payload.Reject.OpUserID)
+//		return true, 0, "", &resp, &msg
+//	}
+//	return false, 210, errors.New("InviteeUserIDList is null").Error(), nil, nil
+//}

internal/msg_gateway/gate/ws_server.go

@@ -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,9 +2,8 @@ package logic
 
 import (
 	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/kafka"
-	"Open_IM/pkg/common/log"
+	"fmt"
 )
 
 var (
@@ -14,13 +13,17 @@ var (
 )
 
 func Init() {
-	log.NewPrivateLog(constant.LogFileName)
+
 	persistentCH.Init()
 	historyCH.Init()
 	producer = kafka.NewKafkaProducer(config.Config.Kafka.Ms2pschat.Addr, config.Config.Kafka.Ms2pschat.Topic)
 }
 func Run() {
 	//register mysqlConsumerHandler to
-	go persistentCH.persistentConsumerGroup.RegisterHandleAndConsumer(&persistentCH)
+	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

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

internal/push/jpush/push.go

@@ -10,17 +10,35 @@ import (
 	"net/http"
 )
 
-type JPushResp struct {
+var (
+	JPushClient *JPush
+)
+
+func init() {
+	JPushClient = newGetuiClient()
 }
 
-func JGAccountListPush(accounts []string, alert, detailContent, platform string) ([]byte, error) {
+type JPush struct{}
 
+func newGetuiClient() *JPush {
+	return &JPush{}
+}
+
+func (j *JPush) Auth(apiKey, secretKey string, timeStamp int64) (token string, err error) {
+	return token, nil
+}
+
+func (j *JPush) SetAlias(cid, alias string) (resp string, err error) {
+	return resp, nil
+}
+
+func (j *JPush) Push(accounts []string, alert, detailContent, operationID string) (string, error) {
 	var pf requestBody.Platform
-	_ = pf.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
@@ -34,25 +52,23 @@ func JGAccountListPush(accounts []string, alert, detailContent, platform string)
 
 	con, err := json.Marshal(po)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
-
 	client := &http.Client{}
-
 	req, err := http.NewRequest("POST", config.Config.Push.Jpns.PushUrl, bytes.NewBuffer(con))
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 	req.Header.Set("Authorization", common.GetAuthorization(config.Config.Push.Jpns.AppKey, config.Config.Push.Jpns.MasterSecret))
 
 	resp, err := client.Do(req)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 	defer resp.Body.Close()
 	result, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
-	return result, nil
+	return string(result), nil
 }

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

@@ -10,7 +10,6 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/kafka"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/statistics"
 	"fmt"
 )
@@ -24,7 +23,7 @@ var (
 )
 
 func Init(rpcPort int) {
-	log.NewPrivateLog(constant.LogFileName)
+
 	rpcServer.Init(rpcPort)
 	pushCh.Init()
 	pushTerminal = []int32{constant.IOSPlatformID, constant.AndroidPlatformID}

internal/push/logic/push_to_client.go

@@ -7,7 +7,9 @@
 package logic
 
 import (
-	push "Open_IM/internal/push/jpush"
+	pusher "Open_IM/internal/push"
+	"Open_IM/internal/push/getui"
+	jpush "Open_IM/internal/push/jpush"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
@@ -35,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())
@@ -43,72 +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]
-						}
-					}
-
-					pushResult, err := push.JGAccountListPush(UIDList, content, jsonCustomContent, constant.PlatformIDToName(t))
-					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 ", string(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

@@ -0,0 +1,5 @@
+package push
+
+type OfflinePusher interface {
+	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/callback.go

@@ -7,3 +7,7 @@ import (
 func callbackBeforeCreateGroup(req *pbGroup.CreateGroupReq) (bool, error) {
 	return true, nil
 }
+
+func callbackAfterCreateGroup(req *pbGroup.CreateGroupReq) {
+
+}

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{
@@ -668,6 +829,7 @@ func (s *groupServer) GetGroupById(_ context.Context, req *pbGroup.GetGroupByIdR
 		Status:        group.Status,
 		CreatorUserID: group.CreatorUserID,
 		GroupType:     group.GroupType,
+		CreateTime:    uint32(group.CreateTime.Unix()),
 	}
 	groupMember, err := imdb.GetGroupMaster(group.GroupID)
 	if err != nil {
@@ -677,6 +839,7 @@ func (s *groupServer) GetGroupById(_ context.Context, req *pbGroup.GetGroupByIdR
 	resp.CMSGroup.GroupMasterName = groupMember.Nickname
 	resp.CMSGroup.GroupMasterId = groupMember.UserID
 	resp.CMSGroup.GroupInfo.CreatorUserID = group.CreatorUserID
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
 }
 
@@ -704,6 +867,7 @@ func (s *groupServer) GetGroup(_ context.Context, req *pbGroup.GetGroupReq) (*pb
 		groupMember, err := imdb.GetGroupMaster(v.GroupID)
 		if err != nil {
 			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster error", err.Error())
+			continue
 		}
 		resp.CMSGroups = append(resp.CMSGroups, &pbGroup.CMSGroup{
 			GroupInfo: &open_im_sdk.GroupInfo{
@@ -713,11 +877,13 @@ func (s *groupServer) GetGroup(_ context.Context, req *pbGroup.GetGroupReq) (*pb
 				OwnerUserID:   v.CreatorUserID,
 				Status:        v.Status,
 				CreatorUserID: v.CreatorUserID,
+				CreateTime:    uint32(v.CreateTime.Unix()),
 			},
 			GroupMasterName: groupMember.Nickname,
 			GroupMasterId:   groupMember.UserID,
 		})
 	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
 }
 
@@ -862,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)
@@ -943,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
 	}
@@ -953,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
 }
@@ -972,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
 	}
@@ -991,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
 	}
@@ -1009,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
 	}
@@ -1025,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
 	}
@@ -1039,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/rpcChat.go

@@ -43,7 +43,7 @@ func (rpc *rpcChat) Run() {
 		log.Error("", "", "listen network failed, err = %s, address = %s", err.Error(), address)
 		return
 	}
-	log.Info("", "", "listen network success, address = %s", address)
+	log.Info("", "", "listen network success, address = ", address)
 
 	//grpc server
 	srv := grpc.NewServer()

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

@@ -3,6 +3,7 @@ package msg
 import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbChat "Open_IM/pkg/proto/chat"
@@ -10,23 +11,24 @@ import (
 	"Open_IM/pkg/utils"
 	"context"
 	"strings"
-	"time"
 )
 
-func TagSendMessage(operationID, sendID, recvID, content string, senderPlatformID int32) {
-	log.NewInfo(operationID, utils.GetSelfFuncName(), "args: ", sendID, recvID, content)
+func TagSendMessage(operationID string, user *db.User, recvID, content string, senderPlatformID int32) {
+	log.NewInfo(operationID, utils.GetSelfFuncName(), "args: ", user.UserID, recvID, content)
 	var req pbChat.SendMsgReq
 	var msgData pbCommon.MsgData
-	msgData.SendID = sendID
+	msgData.SendID = user.UserID
 	msgData.RecvID = recvID
 	msgData.ContentType = constant.Custom
 	msgData.SessionType = constant.SingleChatType
 	msgData.MsgFrom = constant.UserMsgType
 	msgData.Content = []byte(content)
+	msgData.SenderFaceURL = user.FaceURL
+	msgData.SenderNickname = user.Nickname
 	msgData.Options = map[string]bool{}
 	msgData.Options[constant.IsSenderConversationUpdate] = false
-	msgData.SendTime = time.Now().Unix()
-	msgData.CreateTime = time.Now().Unix()
+	msgData.CreateTime = utils.GetCurrentTimestampByMill()
+	msgData.ClientMsgID = utils.GetMsgID(user.UserID)
 	msgData.SenderPlatformID = senderPlatformID
 	req.MsgData = &msgData
 	req.OperationID = operationID

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

@@ -6,6 +6,7 @@ import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbOffice "Open_IM/pkg/proto/office"
@@ -164,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)
@@ -179,8 +180,12 @@ func (s *officeServer) SendMsg2Tag(_ context.Context, req *pbOffice.SendMsg2TagR
 		}
 	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "total userIDList result: ", userIDList)
+	us, err := imdb.GetUserByUserID(req.SendID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.SendID)
+	}
 	for _, userID := range userIDList {
-		msg.TagSendMessage(req.OperationID, req.SendID, userID, req.Content, req.SenderPlatformID)
+		msg.TagSendMessage(req.OperationID, us, userID, req.Content, req.SenderPlatformID)
 	}
 	var tagSendLogs db.TagSendLog
 	for _, userID := range userIDList {
@@ -261,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/cms_api_struct/group.go

@@ -8,7 +8,7 @@ type GroupResponse struct {
 	CreateTime       string `json:"create_time"`
 	IsBanChat        bool   `json:"is_ban_chat"`
 	IsBanPrivateChat bool   `json:"is_ban_private_chat"`
-	ProfilePhoto string `json:"profile_photo"`
+	ProfilePhoto     string `json:"profile_photo"`
 }
 
 type GetGroupByIdRequest struct {
@@ -63,7 +63,6 @@ type SetGroupMemberRequest struct {
 }
 
 type SetGroupMemberRespones struct {
-
 }
 
 type BanGroupChatRequest struct {
@@ -88,7 +87,7 @@ type DeleteGroupResponse struct {
 }
 
 type GetGroupMembersRequest struct {
-	GroupId string `form:"group_id" binding:"required"`
+	GroupId  string `form:"group_id" binding:"required"`
 	UserName string `form:"user_name"`
 	RequestPagination
 }
@@ -96,24 +95,24 @@ type GetGroupMembersRequest struct {
 type GroupMemberResponse struct {
 	MemberPosition int    `json:"member_position"`
 	MemberNickName string `json:"member_nick_name"`
-	MemberId       string    `json:"member_id"`
+	MemberId       string `json:"member_id"`
 	JoinTime       string `json:"join_time"`
 }
 
 type GetGroupMembersResponse struct {
-	GroupMembers []GroupMemberResponse    `json:"group_members"`
+	GroupMembers []GroupMemberResponse `json:"group_members"`
 	ResponsePagination
 	MemberNums int `json:"member_nums"`
 }
 
 type GroupMemberRequest struct {
-	GroupId string `json:"group_id" binding:"required"`
+	GroupId string   `json:"group_id" binding:"required"`
 	Members []string `json:"members" binding:"required"`
 }
 
 type GroupMemberOperateResponse struct {
 	Success []string `json:"success"`
-	Failed []string `json:"failed"`
+	Failed  []string `json:"failed"`
 }
 
 type AddGroupMembersRequest struct {
@@ -128,19 +127,18 @@ type RemoveGroupMembersRequest struct {
 	GroupMemberRequest
 }
 
-type RemoveGroupMembersResponse struct{
+type RemoveGroupMembersResponse struct {
 	GroupMemberOperateResponse
 }
 
 type AlterGroupInfoRequest struct {
-	GroupID       string `json:"group_id"`
-	GroupName     string `json:"group_name"`
-	Notification  string `json:"notification"`
-		Introduction  string `json:"introduction"`
-	ProfilePhoto  string `json:"profile_photo"`
-	GroupType     int `json:"group_type"`
+	GroupID      string `json:"group_id"`
+	GroupName    string `json:"group_name"`
+	Notification string `json:"notification"`
+	Introduction string `json:"introduction"`
+	ProfilePhoto string `json:"profile_photo"`
+	GroupType    int    `json:"group_type"`
 }
 
 type AlterGroupInfoResponse struct {
-
 }

pkg/common/config/config.go

@@ -1,7 +1,6 @@
 package config
 
 import (
-	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -57,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"`
 	}
 
@@ -116,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"`
@@ -153,18 +157,28 @@ type config struct {
 				AccessID  string `yaml:"accessID"`
 				SecretKey string `yaml:"secretKey"`
 			}
+			Enable bool `yaml:"enable"`
 		}
 		Jpns struct {
 			AppKey       string `yaml:"appKey"`
 			MasterSecret string `yaml:"masterSecret"`
 			PushUrl      string `yaml:"pushUrl"`
 			PushIntent   string `yaml:"pushIntent"`
+			Enable       bool   `yaml:"enable"`
+		}
+		Getui struct {
+			PushUrl      string `yaml:"pushUrl"`
+			AppKey       string `yaml:"appKey"`
+			Enable       bool   `yaml:"enable"`
+			Intent       string `yaml:"intent"`
+			MasterSecret string `yaml:"masterSecret"`
 		}
 	}
 	Manager struct {
 		AppManagerUid []string `yaml:"appManagerUid"`
 		Secrets       []string `yaml:"secrets"`
 	}
+
 	Kafka struct {
 		Ws2mschat struct {
 			Addr  []string `yaml:"addr"`
@@ -180,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"`
 	}
@@ -293,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 {
@@ -358,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"`
@@ -377,6 +408,10 @@ type config struct {
 			SmtpPort                int    `yaml:"smtpPort"`
 		}
 	}
+	Rtc struct {
+		Port    int    `yaml:"port"`
+		Address string `yaml:"address"`
+	} `yaml:"rtc"`
 }
 type PConversation struct {
 	ReliabilityLevel int  `yaml:"reliabilityLevel"`
@@ -416,5 +451,4 @@ func init() {
 	if err = yaml.Unmarshal(bytes, &Config); err != nil {
 		panic(err.Error())
 	}
-	fmt.Println("load config: ", Config)
 }

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
@@ -217,7 +251,7 @@ const (
 const FriendAcceptTip = "You have successfully become friends, so start chatting"
 
 func GroupIsBanChat(status int32) bool {
-	if status != GroupBanChat {
+	if status != GroupStatusMuted {
 		return false
 	}
 	return true

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,8 +2,9 @@ package db
 
 import (
 	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
+	"go.mongodb.org/mongo-driver/bson"
+
+	//"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
 	"fmt"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -34,8 +35,7 @@ func key(dbAddress, dbName string) string {
 }
 
 func init() {
-	log.NewPrivateLog(constant.LogFileName)
-	//var mgoSession *mgo.Session
+	//log.NewPrivateLog(constant.LogFileName)
 	var mongoClient *mongo.Client
 	var err1 error
 	//mysql init
@@ -47,54 +47,77 @@ 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 {
-		log.NewError(" mongo.Connect  failed, try ", utils.GetSelfFuncName(), err.Error(), uri)
+		fmt.Println(" mongo.Connect  failed, try ", utils.GetSelfFuncName(), err.Error(), uri)
 		time.Sleep(time.Duration(30) * time.Second)
 		mongoClient, err1 = mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
 		if err1 != nil {
-			log.NewError(" mongo.Connect retry failed, panic", err.Error(), uri)
+			fmt.Println(" mongo.Connect retry failed, panic", err.Error(), uri)
 			panic(err1.Error())
 		}
 	}
-	log.NewInfo("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

@@ -2,7 +2,7 @@ package db
 
 import (
 	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
+
 	"fmt"
 	"sync"
 	"time"
@@ -24,13 +24,13 @@ func initMysqlDB() {
 	var err1 error
 	db, err := gorm.Open("mysql", dsn)
 	if err != nil {
-		log.NewError("0", "Open failed ", err.Error(), dsn)
+		fmt.Println("0", "Open failed ", err.Error(), dsn)
 	}
 	if err != nil {
 		time.Sleep(time.Duration(30) * time.Second)
 		db, err1 = gorm.Open("mysql", dsn)
 		if err1 != nil {
-			log.NewError("0", "Open failed ", err1.Error(), dsn)
+			fmt.Println("0", "Open failed ", err1.Error(), dsn)
 			panic(err1.Error())
 		}
 	}
@@ -39,7 +39,7 @@ func initMysqlDB() {
 	sql := fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s default charset utf8 COLLATE utf8_general_ci;", config.Config.Mysql.DBDatabaseName)
 	err = db.Exec(sql).Error
 	if err != nil {
-		log.NewError("0", "Exec failed ", err.Error(), sql)
+		fmt.Println("0", "Exec failed ", err.Error(), sql)
 		panic(err.Error())
 	}
 	db.Close()
@@ -48,11 +48,11 @@ func initMysqlDB() {
 		config.Config.Mysql.DBUserName, config.Config.Mysql.DBPassword, config.Config.Mysql.DBAddress[0], config.Config.Mysql.DBDatabaseName)
 	db, err = gorm.Open("mysql", dsn)
 	if err != nil {
-		log.NewError("0", "Open failed ", err.Error(), dsn)
+		fmt.Println("0", "Open failed ", err.Error(), dsn)
 		panic(err.Error())
 	}
 
-	log.NewInfo("open db ok ", dsn)
+	fmt.Println("open db ok ", dsn)
 	db.AutoMigrate(&Friend{},
 		&FriendRequest{},
 		&Group{},
@@ -64,187 +64,63 @@ func initMysqlDB() {
 	db.Set("gorm:table_options", "collation=utf8_unicode_ci")
 
 	if !db.HasTable(&Friend{}) {
-		log.NewInfo("CreateTable Friend")
+		fmt.Println("CreateTable Friend")
 		db.CreateTable(&Friend{})
 	}
 
 	if !db.HasTable(&FriendRequest{}) {
-		log.NewInfo("CreateTable FriendRequest")
+		fmt.Println("CreateTable FriendRequest")
 		db.CreateTable(&FriendRequest{})
 	}
 
 	if !db.HasTable(&Group{}) {
-		log.NewInfo("CreateTable Group")
+		fmt.Println("CreateTable Group")
 		db.CreateTable(&Group{})
 	}
 
 	if !db.HasTable(&GroupMember{}) {
-		log.NewInfo("CreateTable GroupMember")
+		fmt.Println("CreateTable GroupMember")
 		db.CreateTable(&GroupMember{})
 	}
-
 	if !db.HasTable(&GroupRequest{}) {
-		log.NewInfo("CreateTable GroupRequest")
+		fmt.Println("CreateTable GroupRequest")
 		db.CreateTable(&GroupRequest{})
 	}
-
 	if !db.HasTable(&User{}) {
-		log.NewInfo("CreateTable User")
+		fmt.Println("CreateTable User")
 		db.CreateTable(&User{})
 	}
-
 	if !db.HasTable(&Black{}) {
-		log.NewInfo("CreateTable Black")
+		fmt.Println("CreateTable Black")
 		db.CreateTable(&Black{})
 	}
 	if !db.HasTable(&ChatLog{}) {
-		log.NewInfo("CreateTable Black")
+		fmt.Println("CreateTable ChatLog")
 		db.CreateTable(&ChatLog{})
 	}
 	if !db.HasTable(&Register{}) {
-		log.NewInfo("CreateTable Black")
+		fmt.Println("CreateTable Register")
 		db.CreateTable(&Register{})
 	}
 	if !db.HasTable(&Conversation{}) {
-		log.NewInfo("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/demo_model.go

@@ -33,7 +33,7 @@ func ResetPassword(account, password string) error {
 		Password: password,
 	}
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	if err != nil {
 		return err
 	}

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

@@ -71,16 +71,12 @@ func GetGroupMemberIDListByGroupID(groupID string) ([]string, error) {
 	if err != nil {
 		return nil, err
 	}
-	dbConn.LogMode(true)
-	var groupMembers []db.GroupMember
-	err = dbConn.Table("group_members").Select("user_id").Where("group_id=?", groupID).Find(&groupMembers).Error
+	dbConn.LogMode(false)
+	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
 }
 
@@ -279,7 +275,7 @@ func GetGroupMembersCount(groupId, userName string) (int32, error) {
 	if err != nil {
 		return count, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	if err := dbConn.Table("group_members").Where("group_id=?", groupId).Where(fmt.Sprintf(" nickname like '%%%s%%' ", userName)).Count(&count).Error; err != nil {
 		return count, err
 	}

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

@@ -123,7 +123,7 @@ func GetUserReqGroupByUserID(userID string) ([]db.GroupRequest, error) {
 	if err != nil {
 		return nil, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	err = dbConn.Table("group_requests").Where("user_id=?", userID).Find(&groupRequestList).Error
 	return groupRequestList, err
 }

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

@@ -13,7 +13,7 @@ func GetChatLog(chatLog db.ChatLog, pageNumber, showNumber int32) ([]db.ChatLog,
 	if err != nil {
 		return chatLogs, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	db := dbConn.Table("chat_logs").
 		Where(fmt.Sprintf(" content like '%%%s%%'", chatLog.Content)).
 		Limit(showNumber).Offset(showNumber * (pageNumber - 1))
@@ -43,7 +43,7 @@ func GetChatLogCount(chatLog db.ChatLog) (int64, error) {
 	if err != nil {
 		return count, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	db := dbConn.Table("chat_logs").
 		Where(fmt.Sprintf(" content like '%%%s%%'", chatLog.Content))
 	if chatLog.SessionType != 0 {
@@ -65,4 +65,4 @@ func GetChatLogCount(chatLog db.ChatLog) (int64, error) {
 
 	err = db.Find(&chatLogs).Count(&count).Error
 	return count, 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/statistics_model.go

@@ -10,7 +10,7 @@ func GetActiveUserNum(from, to time.Time) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("chat_logs").Select("count(distinct(send_id))").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
 	return num, err
@@ -21,7 +21,7 @@ func GetIncreaseUserNum(from, to time.Time) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("users").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
 	return num, err
@@ -32,7 +32,7 @@ func GetTotalUserNum() (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("users").Count(&num).Error
 	return num, err
@@ -43,7 +43,7 @@ func GetTotalUserNumByDate(to time.Time) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("users").Where("create_time <= ?", to).Count(&num).Error
 	return num, err
@@ -54,7 +54,7 @@ func GetPrivateMessageNum(from, to time.Time) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("chat_logs").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 1).Count(&num).Error
 	return num, err
@@ -65,7 +65,7 @@ func GetGroupMessageNum(from, to time.Time) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("chat_logs").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 2).Count(&num).Error
 	return num, err
@@ -76,7 +76,7 @@ func GetIncreaseGroupNum(from, to time.Time) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("groups").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
 	return num, err
@@ -87,7 +87,7 @@ func GetTotalGroupNum() (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("groups").Count(&num).Error
 	return num, err
@@ -98,7 +98,7 @@ func GetGroupNum(to time.Time) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var num int32
 	err = dbConn.Table("groups").Where("create_time <= ?", to).Count(&num).Error
 	return num, err
@@ -116,7 +116,7 @@ func GetActiveGroups(from, to time.Time, limit int) ([]*activeGroup, error) {
 	if err != nil {
 		return activeGroups, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	err = dbConn.Table("chat_logs").Select("recv_id, count(*) as message_num").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 2).Group("recv_id").Limit(limit).Order("message_num DESC").Find(&activeGroups).Error
 	for _, activeGroup := range activeGroups {
 		group := db.Group{
@@ -140,7 +140,7 @@ func GetActiveUsers(from, to time.Time, limit int) ([]*activeUser, error) {
 	if err != nil {
 		return activeUsers, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	err = dbConn.Table("chat_logs").Select("send_id, count(*) as message_num").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 1).Group("send_id").Limit(limit).Order("message_num DESC").Find(&activeUsers).Error
 	for _, activeUser := range activeUsers {
 		user := db.User{

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 {
@@ -92,7 +101,7 @@ func UpdateUserInfo(user db.User) error {
 	if err != nil {
 		return err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	err = dbConn.Table("users").Where("user_id=?", user.UserID).Update(&user).Error
 	return err
 }
@@ -112,7 +121,7 @@ func SelectAllUserID() ([]string, error) {
 
 func SelectSomeUserID(userIDList []string) ([]string, error) {
 	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	if err != nil {
 		return nil, err
 	}
@@ -131,7 +140,7 @@ func GetUsers(showNumber, pageNumber int32) ([]db.User, error) {
 	if err != nil {
 		return users, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	err = dbConn.Table("users").Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&users).Error
 	if err != nil {
 		return users, err
@@ -204,7 +213,7 @@ func UnBlockUser(userId string) error {
 	if err != nil {
 		return err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	result := dbConn.Where("uid=?", userId).Delete(&db.BlackList{})
 	return result.Error
 }
@@ -248,7 +257,7 @@ func GetBlockUsers(showNumber, pageNumber int32) ([]BlockUserInfo, error) {
 	if err != nil {
 		return blockUserInfos, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	if err = dbConn.Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&blockUsers).Error; err != nil {
 		return blockUserInfos, err
 	}
@@ -275,7 +284,7 @@ func GetUserByName(userName string, showNumber, pageNumber int32) ([]db.User, er
 	if err != nil {
 		return users, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	err = dbConn.Table("users").Where(fmt.Sprintf(" name like '%%%s%%' ", userName)).Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&users).Error
 	return users, err
 }
@@ -285,7 +294,7 @@ func GetUsersCount(user db.User) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var count int32
 	if err := dbConn.Table("users").Where(fmt.Sprintf(" name like '%%%s%%' ", user.Nickname)).Count(&count).Error; err != nil {
 		return 0, err
@@ -298,101 +307,10 @@ func GetBlockUsersNumCount() (int32, error) {
 	if err != nil {
 		return 0, err
 	}
-	dbConn.LogMode(true)
+	dbConn.LogMode(false)
 	var count int32
 	if err := dbConn.Model(&db.BlackList{}).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
 }
-
-func SetConversation(conversation db.Conversation) error {
-	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
-	if err != nil {
-		return err
-	}
-	dbConn.LogMode(true)
-	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(true)
-	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(true)
-	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(true)
-	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,17 +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"
+	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) {
@@ -36,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))
 }
 
@@ -144,3 +151,102 @@ func (d *DataBases) GetMultiConversationMsgOpt(userID string, conversationIDs []
 	return m, nil
 
 }
+
+func (d *DataBases) SetGetuiToken(token string, expireTime int64) error {
+	_, err := d.Exec("SET", getuiToken, token, "ex", expireTime)
+	return err
+}
+
+func (d *DataBases) GetGetuiToken() (string, error) {
+	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/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);
 }