group dismissed

2. Handle exception : etcd keepalive failed

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '23 2 * * 2'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.gitignore

@@ -1,2 +1,21 @@
+bin
+logs
+.devcontainer
 components
-logs
+logs
+out-test
+.github
+.idea
+
+deploy/open_im_demo
+deploy/open_im_api
+deploy/open_im_msg_gateway
+deploy/open_im_msg_transfer
+deploy/open_im_push
+deploy/open_im_timer_task
+deploy/open_im_rpc_user
+deploy/open_im_rpc_friend
+deploy/open_im_rpc_group
+deploy/open_im_rpc_msg
+deploy/open_im_rpc_auth
+deploy/Open-IM-SDK-Core

.gitmodules

@@ -1,4 +1,4 @@
 
-[submodule "src/Open-IM-SDK-Core"]
-	path = src/Open-IM-SDK-Core
+[submodule "cmd/Open-IM-SDK-Core"]
+	path = cmd/Open-IM-SDK-Core
 	url = https://github.com/OpenIMSDK/Open-IM-SDK-Core.git

README.md

@@ -1,4 +1,4 @@
-# Open-IM-Server
+# Open-IM-Server 
 
 ![avatar](https://github.com/OpenIMSDK/Open-IM-Server/blob/main/docs/open-im-logo.png)
 
@@ -154,4 +154,4 @@ All images are available at https://hub.docker.com/r/lyt1123/open_im_server
 
 ## License
 
-Open-IM-Server is under the Apache 2.0 license. See the [LICENSE](https://github.com/OpenIMSDK/Open-IM-Server/blob/main/LICENSE) file for details.
+Open-IM-Server is under the Apache 2.0 license. See the [LICENSE](https://github.com/OpenIMSDK/Open-IM-Server/blob/main/LICENSE) file for details

cmd/open_im_api/Makefile

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

@@ -0,0 +1,119 @@
+package main
+
+import (
+	apiAuth "Open_IM/internal/api/auth"
+	apiChat "Open_IM/internal/api/chat"
+	"Open_IM/internal/api/conversation"
+	"Open_IM/internal/api/friend"
+	"Open_IM/internal/api/group"
+	"Open_IM/internal/api/manage"
+	apiThird "Open_IM/internal/api/third"
+	"Open_IM/internal/api/user"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"flag"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	//"syscall"
+)
+
+func main() {
+	gin.SetMode(gin.ReleaseMode)
+	r := gin.Default()
+	r.Use(utils.CorsHandler())
+	// 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
+	}
+	//friend routing group
+	friendRouterGroup := r.Group("/friend")
+	{
+		//	friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo)
+		friendRouterGroup.POST("/add_friend", friend.AddFriend)                              //1
+		friendRouterGroup.POST("/delete_friend", friend.DeleteFriend)                        //1
+		friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList)          //1
+		friendRouterGroup.POST("/get_self_friend_apply_list", friend.GetSelfFriendApplyList) //1
+		friendRouterGroup.POST("/get_friend_list", friend.GetFriendList)                     //1
+		friendRouterGroup.POST("/add_friend_response", friend.AddFriendResponse)             //1
+		friendRouterGroup.POST("/set_friend_remark", friend.SetFriendRemark)                 //1
+
+		friendRouterGroup.POST("/add_black", friend.AddBlack)          //1
+		friendRouterGroup.POST("/get_black_list", friend.GetBlacklist) //1
+		friendRouterGroup.POST("/remove_black", friend.RemoveBlack)    //1
+
+		friendRouterGroup.POST("/import_friend", friend.ImportFriend) //1
+		friendRouterGroup.POST("/is_friend", friend.IsFriend)         //1
+	}
+	//group related routing group
+	groupRouterGroup := r.Group("/group")
+	{
+		groupRouterGroup.POST("/create_group", group.CreateGroup)                                   //1
+		groupRouterGroup.POST("/set_group_info", group.SetGroupInfo)                                //1
+		groupRouterGroup.POST("join_group", group.JoinGroup)                                        //1
+		groupRouterGroup.POST("/quit_group", group.QuitGroup)                                       //1
+		groupRouterGroup.POST("/group_application_response", group.ApplicationGroupResponse)        //1
+		groupRouterGroup.POST("/transfer_group", group.TransferGroupOwner)                          //1
+		groupRouterGroup.POST("/get_recv_group_applicationList", group.GetRecvGroupApplicationList) //1
+		groupRouterGroup.POST("/get_user_req_group_applicationList", group.GetUserReqGroupApplicationList)
+		groupRouterGroup.POST("/get_groups_info", group.GetGroupsInfo)                   //1
+		groupRouterGroup.POST("/kick_group", group.KickGroupMember)                      //1
+		groupRouterGroup.POST("/get_group_member_list", group.GetGroupMemberList)        //no use
+		groupRouterGroup.POST("/get_group_all_member_list", group.GetGroupAllMemberList) //1
+		groupRouterGroup.POST("/get_group_members_info", group.GetGroupMembersInfo)      //1
+		groupRouterGroup.POST("/invite_user_to_group", group.InviteUserToGroup)          //1
+		groupRouterGroup.POST("/get_joined_group_list", group.GetJoinedGroupList)        //1
+		groupRouterGroup.POST("/dismiss_group", group.DismissGroup)
+	}
+	//certificate
+	authRouterGroup := r.Group("/auth")
+	{
+		authRouterGroup.POST("/user_register", apiAuth.UserRegister) //1
+		authRouterGroup.POST("/user_token", apiAuth.UserToken)       //1
+	}
+	//Third service
+	thirdGroup := r.Group("/third")
+	{
+		thirdGroup.POST("/tencent_cloud_storage_credential", apiThird.TencentCloudStorageCredential)
+		thirdGroup.POST("/minio_storage_credential", apiThird.MinioStorageCredential)
+		thirdGroup.POST("/minio_upload", apiThird.MinioUploadFile)
+	}
+	//Message
+	chatGroup := r.Group("/msg")
+	{
+		chatGroup.POST("/newest_seq", apiChat.GetSeq)
+		chatGroup.POST("/send_msg", apiChat.SendMsg)
+		chatGroup.POST("/pull_msg_by_seq", apiChat.PullMsgBySeqList)
+		chatGroup.POST("/del_msg", apiChat.DelMsg)
+	}
+	//Manager
+	managementGroup := r.Group("/manager")
+	{
+		managementGroup.POST("/delete_user", manage.DeleteUser) //1
+		managementGroup.POST("/send_msg", manage.ManagementSendMsg)
+		managementGroup.POST("/get_all_users_uid", manage.GetAllUsersUid)             //1
+		managementGroup.POST("/account_check", manage.AccountCheck)                   //1
+		managementGroup.POST("/get_users_online_status", manage.GetUsersOnlineStatus) //1
+	}
+	//Conversation
+	conversationGroup := r.Group("/conversation")
+	{ //1
+		conversationGroup.POST("/get_all_conversations", conversation.GetAllConversations)
+		conversationGroup.POST("/get_conversation", conversation.GetConversation)
+		conversationGroup.POST("/get_conversations", conversation.GetConversations)
+		conversationGroup.POST("/set_conversation", conversation.SetConversation)
+		conversationGroup.POST("/batch_set_conversation", conversation.BatchSetConversations)
+		conversationGroup.POST("/set_recv_msg_opt", conversation.SetRecvMsgOpt)
+	}
+	apiThird.MinioInit()
+	log.NewPrivateLog("api")
+	ginPort := flag.Int("port", 10000, "get ginServerPort from cmd,default 10000 as port")
+	flag.Parse()
+	err := r.Run(":" + strconv.Itoa(*ginPort))
+	if err != nil {
+		log.NewError("", utils.GetSelfFuncName(), "start gin failed", err.Error())
+	}
+}

cmd/open_im_cms_api/Makefile

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

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"Open_IM/internal/cms_api"
+	"Open_IM/pkg/utils"
+
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+	gin.SetMode(gin.ReleaseMode)
+	router := cms_api.NewGinRouter()
+	router.Use(utils.CorsHandler())
+	router.Run(":" + "8000")
+}

cmd/open_im_demo/Makefile

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

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"Open_IM/internal/demo/register"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"flag"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+
+	r := gin.Default()
+	r.Use(utils.CorsHandler())
+
+	authRouterGroup := r.Group("/auth")
+	{
+		authRouterGroup.POST("/code", register.SendVerificationCode)
+		authRouterGroup.POST("/verify", register.Verify)
+		authRouterGroup.POST("/password", register.SetPassword)
+		authRouterGroup.POST("/login", register.Login)
+		authRouterGroup.POST("/reset_password", register.ResetPassword)
+	}
+	log.NewPrivateLog("demo")
+	ginPort := flag.Int("port", 42233, "get ginServerPort from cmd,default 42233 as port")
+	flag.Parse()
+	r.Run(":" + strconv.Itoa(*ginPort))
+}

cmd/open_im_msg_gateway/Makefile

@@ -2,13 +2,11 @@
 
 BINARY_NAME=open_im_msg_gateway
 BIN_DIR=../../bin/
-LAN_FILE=.go
-GO_FILE:=${BINARY_NAME}${LAN_FILE}
 
 all: gotool build
 
 build:
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o  ${BINARY_NAME}  ${GO_FILE}
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s"
 
 run:
 	@go run ./

cmd/open_im_msg_gateway/main.go

@@ -1,14 +1,14 @@
 package main
 
 import (
-	"Open_IM/src/msg_gateway/gate"
+	"Open_IM/internal/msg_gateway/gate"
 	"flag"
 	"sync"
 )
 
 func main() {
-	rpcPort := flag.Int("rpc_port", 10500, "rpc listening port")
-	wsPort := flag.Int("ws_port", 10800, "ws listening port")
+	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)

cmd/open_im_msg_transfer/Makefile

@@ -2,13 +2,12 @@
 
 BINARY_NAME=open_im_msg_transfer
 BIN_DIR=../../bin/
-LAN_FILE=.go
-GO_FILE:=${BINARY_NAME}${LAN_FILE}
+
 
 all: gotool build
 
 build:
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o  ${BINARY_NAME}  ${GO_FILE}
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s"
 
 run:
 	@go run ./

cmd/open_im_msg_transfer/main.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"Open_IM/src/msg_transfer/logic"
+	"Open_IM/internal/msg_transfer/logic"
 	"sync"
 )
 

cmd/open_im_push/Makefile

@@ -2,13 +2,11 @@
 
 BINARY_NAME=open_im_push
 BIN_DIR=../../bin/
-LAN_FILE=.go
-GO_FILE:=${BINARY_NAME}${LAN_FILE}
 
 all: gotool build
 
 build:
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o  ${BINARY_NAME}  ${GO_FILE}
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s"
 
 run:
 	@go run ./

cmd/open_im_push/main.go

@@ -1,13 +1,13 @@
 package main
 
 import (
-	"Open_IM/src/push/logic"
+	"Open_IM/internal/push/logic"
 	"flag"
 	"sync"
 )
 
 func main() {
-	rpcPort := flag.Int("port", -1, "rpc listening port")
+	rpcPort := flag.Int("port", 10700, "rpc listening port")
 	flag.Parse()
 	var wg sync.WaitGroup
 	wg.Add(1)

cmd/open_im_timer_task/Makefile

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

@@ -0,0 +1,65 @@
+package main
+
+import (
+	commonDB "Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	"Open_IM/pkg/common/log"
+	"time"
+)
+
+func main() {
+	log.NewPrivateLog("timer")
+	//for {
+	//	fmt.Println("start delete mongodb expired record")
+	//	timeUnixBegin := time.Now().Unix()
+	//	count, _ := db.DB.MgoUserCount()
+	//	fmt.Println("mongodb record count: ", count)
+	//	for i := 0; i < count; i++ {
+	//		time.Sleep(1 * time.Millisecond)
+	//		uid, _ := db.DB.MgoSkipUID(i)
+	//		fmt.Println("operate uid: ", uid)
+	//		err := db.DB.DelUserChat(uid)
+	//		if err != nil {
+	//			fmt.Println("operate uid failed: ", uid, err.Error())
+	//		}
+	//	}
+	//
+	//	timeUnixEnd := time.Now().Unix()
+	//	costTime := timeUnixEnd - timeUnixBegin
+	//	if costTime > int64(config.Config.Mongo.DBRetainChatRecords*24*3600) {
+	//		continue
+	//	} else {
+	//		sleepTime := 0
+	//		if int64(config.Config.Mongo.DBRetainChatRecords*24*3600)-costTime > 24*3600 {
+	//			sleepTime = 24 * 3600
+	//		} else {
+	//			sleepTime = config.Config.Mongo.DBRetainChatRecords*24*3600 - int(costTime)
+	//		}
+	//		fmt.Println("sleep: ", sleepTime)
+	//		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)
+			}
+
+		}
+
+	}
+
+}

cmd/rpc/open_im_admin_cms/Makefile

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

@@ -0,0 +1,14 @@
+package main
+
+import (
+	rpcMessageCMS "Open_IM/internal/rpc/admin_cms"
+	"flag"
+)
+
+func main() {
+	rpcPort := flag.Int("port", 11000, "rpc listening port")
+	flag.Parse()
+	rpcServer := rpcMessageCMS.NewAdminCMSServer(*rpcPort)
+	rpcServer.Run()
+}
+

cmd/rpc/open_im_auth/Makefile

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

@@ -1,7 +1,7 @@
 package main
 
 import (
-	rpcAuth "Open_IM/src/rpc/auth/auth"
+	rpcAuth "Open_IM/internal/rpc/auth"
 	"flag"
 )
 
@@ -10,4 +10,5 @@ func main() {
 	flag.Parse()
 	rpcServer := rpcAuth.NewRpcAuthServer(*rpcPort)
 	rpcServer.Run()
+
 }

cmd/rpc/open_im_friend/Makefile

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

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"Open_IM/src/rpc/friend/friend"
+	"Open_IM/internal/rpc/friend"
 	"flag"
 )
 

cmd/rpc/open_im_group/Makefile

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

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"Open_IM/src/rpc/group/group"
+	"Open_IM/internal/rpc/group"
 	"flag"
 )
 

cmd/rpc/open_im_message_cms/Makefile

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

@@ -0,0 +1,13 @@
+package main
+
+import (
+	rpcMessageCMS "Open_IM/internal/rpc/message_cms"
+	"flag"
+)
+
+func main() {
+	rpcPort := flag.Int("port", 10900, "rpc listening port")
+	flag.Parse()
+	rpcServer := rpcMessageCMS.NewMessageCMSServer(*rpcPort)
+	rpcServer.Run()
+}

cmd/rpc/open_im_msg/Makefile

@@ -2,13 +2,11 @@
 
 BINARY_NAME=open_im_msg
 BIN_DIR=../../../bin/
-LAN_FILE=.go
-GO_FILE:=${BINARY_NAME}${LAN_FILE}
 
 all: gotool build
 
 build:
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s" -o  ${BINARY_NAME}  ${GO_FILE}
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s"
 
 run:
 	@go run ./

cmd/rpc/open_im_msg/main.go

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

cmd/rpc/open_im_statistics/Makefile

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

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

cmd/rpc/open_im_user/Makefile

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

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"Open_IM/src/rpc/user/user"
+	"Open_IM/internal/rpc/user"
 	"flag"
 )
 

cmd/test/main.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"Open_IM/pkg/utils"
+	"context"
+	"fmt"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"time"
+)
+
+type MongoMsg struct {
+	UID string
+	Msg []string
+}
+
+
+func main()  {
+	//"mongodb://%s:%s@%s/%s/?maxPoolSize=%d"
+	uri := "mongodb://user:pass@sample.host:27017/?maxPoolSize=20&w=majority"
+	DBAddress := "127.0.0.1:37017"
+	DBDatabase := "new-test-db"
+	Collection := "new-test-collection"
+	DBMaxPoolSize := 100
+	uri = fmt.Sprintf("mongodb://%s/%s/?maxPoolSize=%d",
+		DBAddress,DBDatabase,
+		DBMaxPoolSize)
+
+	mongoClient, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
+	if err != nil {
+		panic(err)
+	}
+	filter := bson.M{"uid":"my_uid"}
+	ctx, _ := context.WithTimeout(context.Background(), 30*time.Second)
+	for i:=0; i < 2; i++{
+
+		if err = mongoClient.Database(DBDatabase).Collection(Collection).FindOneAndUpdate(ctx, filter,
+			bson.M{"$push": bson.M{"msg": utils.Int32ToString(int32(i))}}).Err(); err != nil{
+			fmt.Println("FindOneAndUpdate failed ", i, )
+			var mmsg MongoMsg
+			mmsg.UID = "my_uid"
+			mmsg.Msg = append(mmsg.Msg, utils.Int32ToString(int32(i)))
+			_, err := mongoClient.Database(DBDatabase).Collection(Collection).InsertOne(ctx, &mmsg)
+			if err != nil {
+				fmt.Println("insertone failed ", err.Error(), i)
+			} else{
+				fmt.Println("insertone ok ", i)
+			}
+
+		}else {
+			fmt.Println("FindOneAndUpdate ok ", i)
+		}
+
+	}
+
+	var mmsg MongoMsg
+
+	if  err = mongoClient.Database(DBDatabase).Collection(Collection).FindOne(ctx, filter).Decode(&mmsg); err != nil {
+		fmt.Println("findone failed ", err.Error())
+	}else{
+		fmt.Println("findone ok ", mmsg.UID)
+		for i, v:=range mmsg.Msg{
+			fmt.Println("find value: ", i, v)
+		}
+	}
+
+
+}

config/config.yaml

@@ -1,47 +1,47 @@
 # The class cannot be named by Pascal or camel case.
 # If it is not used, the corresponding structure will not be set,
 # and it will not be read naturally.
-serverversion: 1.0.0
+serverversion: 2.0.0
 #---------------Infrastructure configuration---------------------#
 etcd:
-  etcdSchema: openIM
-  etcdAddr: [ 127.0.0.1:2379 ]
+  etcdSchema: openIM  #默认即可
+  etcdAddr: [ 127.0.0.1:2379 ] #单机部署时，默认即可
 
 mysql:
-  dbMysqlAddress: [ 127.0.0.1:3306 ]
-  dbMysqlUserName: root
-  dbMysqlPassword: openIM
-  dbMysqlDatabaseName: openIM
-  dbTableName: eMsg
+  dbMysqlAddress: [ 127.0.0.1:13306 ] #mysql地址 目前仅支持单机，默认即可
+  dbMysqlUserName: root #mysql用户名，建议修改
+  dbMysqlPassword: openIM # mysql密码，建议修改
+  dbMysqlDatabaseName: openIM_v2 #默认即可
+  dbTableName: eMsg #默认即可
   dbMsgTableNum: 1
   dbMaxOpenConns: 20
   dbMaxIdleConns: 10
   dbMaxLifeTime: 120
 
 mongo:
-  dbAddress: [ 127.0.0.1:27017 ]
+  dbAddress: [ 127.0.0.1:37017 ] #redis地址 目前仅支持单机，默认即可
   dbDirect: false
   dbTimeout: 10
-  dbDatabase: openIM
+  dbDatabase: openIM  #mongo db 默认即可
   dbSource: admin
-  dbUserName:
-  dbPassword:
+  dbUserName: #mongo用户名，建议先不设置
+  dbPassword: #mongo密码，建议先不设置
   dbMaxPoolSize: 20
-  dbRetainChatRecords: 7
+  dbRetainChatRecords: 3650 #mongo保存离线消息时间（天），根据需求修改
 
 redis:
-  dbAddress: 127.0.0.1:6379
+  dbAddress: 127.0.0.1:16379 #redis地址 目前仅支持单机，默认即可
   dbMaxIdle: 128
   dbMaxActive: 0
   dbIdleTimeout: 120
-  dbPassWord: openIM
+  dbPassWord: openIM #redis密码 建议修改
 
 kafka:
   ws2mschat:
-    addr: [ 127.0.0.1:9092 ]
+    addr: [ 127.0.0.1:9092 ] #kafka配置，默认即可
     topic: "ws2ms_chat"
   ms2pschat:
-    addr: [ 127.0.0.1:9092 ]
+    addr: [ 127.0.0.1:9092 ] #kafka配置，默认即可
     topic: "ms2ps_chat"
   consumergroupid:
     msgToMongo: mongo
@@ -55,33 +55,68 @@ kafka:
 # The service ip default is empty,
 # automatically obtain the machine's valid network card ip as the service ip,
 # otherwise the configuration ip is preferred
-serverip:
+#如果是单机模式，用0.0.0.0或者不填，默认即可
+serverip: 0.0.0.0
+
+# endpoints 内部组件间访问的端点host名称，访问时，可以内部直接访问 host:port 来访问
+endpoints:
+  api: openim_api
+  cmsapi: openim_cms_api
+  push: openim_push
+  msg_gateway: openim_msg_gateway
+  rpc_auth: openim_rpc_auth
+  rpc_friend: openim_rpc_friend
+  rpc_group: openim_rpc_group
+  rpc_msg: openim_rpc_msg
+  rpc_user: openim_rpc_user
+  rpc_statistic: openim_rpc_statistic
+  rpc_admin_cms: openim_rpc_admin_cms
+  rpc_message_cms: openim_rpc_admin_cms
 
 api:
-  openImApiPort: [ 10000 ]
+  openImApiPort: [ 10000 ] #api服务端口，默认即可，需要开放此端口或做nginx转发
+cmsapi:
+  openImCmsApiPort: [ 8000 ] #管理后台api服务端口，默认即可，需要开放此端口或做nginx转发
 sdk:
-  openImSdkWsPort: [ 30000 ]
-
-credential:
+  openImSdkWsPort: [ 30000 ] #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
+  minio: #MinIO 发送图片、视频、文件时需要，请自行申请后替换，必须修改。 客户端初始化InitSDK，中 object_storage参数为minio
+    bucket: openim
+    location: us-east-1
+    endpoint: http://43.128.5.63:9000
+    accessKeyID: user12345
+    secretAccessKey: key12345
 
 
-rpcport:
+rpcport: #rpc服务端口 默认即可
   openImUserPort: [ 10100 ]
   openImFriendPort: [ 10200 ]
-  openImOfflineMessagePort: [ 10300]
+  openImOfflineMessagePort: [ 10300 ]
   openImOnlineRelayPort: [ 10400 ]
-  openImGroupPort: [ 10500  ]
+  openImGroupPort: [ 10500 ]
   openImAuthPort: [ 10600 ]
   openImPushPort: [ 10700 ]
+  openImStatisticsPort: [ 10800 ]
+  openImMessageCmsPort: [ 10900 ]
+  openImAdminCmsPort: [ 11000 ]
+  c2c:
+    callbackBeforeSendMsg:
+      switch: false
+      timeoutStrategy: 1 #1:send
+    callbackAfterSendMsg:
+      switch: false
+  state:
+    stateChange:
+      switch: false
 
-
-rpcregistername:
+rpcregistername: #rpc注册服务名，默认即可
   openImUserName: User
   openImFriendName: Friend
   openImOfflineMessageName: OfflineMessage
@@ -89,58 +124,391 @@ rpcregistername:
   openImOnlineMessageRelayName: OnlineMessageRelay
   openImGroupName: Group
   openImAuthName: Auth
+  OpenImStatisticsName: Statistics
+  OpenImMessageCMSName: MessageCMS
+  openImAdminCMSName: AdminCMS
 
 log:
   storageLocation: ../logs/
   rotationTime: 24
-  remainRotationCount: 5
+  remainRotationCount: 3 #日志数量
+  #日志级别 6表示全都打印，测试阶段建议设置为6
   remainLogLevel: 6
   elasticSearchSwitch: false
   elasticSearchAddr: [ 127.0.0.1:9201 ]
   elasticSearchUser: ""
   elasticSearchPassword: ""
 
-modulename:
+modulename: #日志文件按模块命名，默认即可
   longConnSvrName: msg_gateway
   msgTransferName: msg_transfer
   pushName: push
 
 longconnsvr:
-  openImWsPort: [ 17778 ]
+  openImWsPort: [ 17778 ] # ws服务端口，默认即可，要开放此端口或做nginx转发
   websocketMaxConnNum: 10000
   websocketMaxMsgLen: 4096
   websocketTimeOut: 10
 
 push:
-  tpns:
+  tpns: #腾讯推送，暂未测试 暂不要使用
     ios:
       accessID: 1600018281
       secretKey: 3cd68a77a95b89e5089a1aca523f318f
     android:
       accessID: 111
       secretKey: 111
-  jpns:
+  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"
 manager:
-  appManagerUid: ["openIM123456","openIM654321"]
-  secrets: ["openIM1","openIM2"]
+  #app管理员userID和对应的secret  建议修改。 用于管理后台登录，也可以用户管理后台对应的api
+  appManagerUid: [ "openIM123456","openIM654321", "openIM333", "openIMAdmin"]
+  secrets: [ "openIM1","openIM2", "openIM333", "openIMAdmin"]
 
 secret: tuoyun
-
-multiloginpolicy:
-  onlyOneTerminalAccess: false
-  mobileAndPCTerminalAccessButOtherTerminalKickEachOther: true
-  allTerminalAccess: false
+# 多端互踢策略
+# 1：多平台登录：Android、iOS、Windows、Mac 每种平台只能一个在线，web端可以多个同时在线
+multiloginpolicy: 1
 
 #token config
 tokenpolicy:
-  accessSecret: "open_im_server"
-  # Token effective time seconds as a unit
-  #Seven days   7*24*60*60
-  accessExpire: 604800
+  accessSecret: "open_im_server" #token生成相关，默认即可
+  # Token effective time day as a unit
+  accessExpire: 3650 #token过期时间（天） 默认即可
+messageverify:
+  friendVerify: false
+
+#  c2c:
+#    callbackBeforeSendMsg:
+#      switch: false
+#      timeoutStrategy: 1 #1:send
+#    callbackAfterSendMsg:
+#      switch: false
+#  state:
+#    stateChange:
+#      switch: false
+#ios系统推送声音以及标记计数
+iospush:
+  pushSound: "xxx"
+  badgeCount: true
+
+callback:
+  # callback url 需要自行更换callback url
+  callbackUrl : "http://127.0.0.1:8080/callback"
+  # 开启关闭操作前后回调的配置
+  callbackbeforeSendSingleMsg:
+    enable: false # 回调是否启用
+    callbackTimeOut: 2 # 回调超时时间
+    callbackFailedContinue: true # 回调超时是否继续执行代码
+  callbackAfterSendSingleMsg:
+    enable: false
+    callbackTimeOut: 2
+  callbackBeforeSendGroupMsg:
+    enable: false
+    callbackTimeOut: 2
+    callbackFailedContinue: true
+  callbackAfterSendGroupMsg:
+    enable: false
+    callbackTimeOut: 2
+  callbackWordFilter:
+    enable: false
+    callbackTimeOut: 2
+    callbackFailedContinue: true
+
+
+notification:
+  groupCreated:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: true
+      title: "create group title" # xx create the group
+      desc: "create group desc"
+      ext: "create group ext"
+    defaultTips:
+      tips: "create the group"  # xx create the group
+
+  groupInfoSet:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "groupInfoSet title"
+      desc: "groupInfoSet desc"
+      ext: "groupInfoSet ext"
+    defaultTips:
+      tips: "modified the group profile"  # group info changed by xx
+
+  joinGroupApplication:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: false
+      title: "joinGroupApplication title"
+      desc: "joinGroupApplication desc"
+      ext: "joinGroupApplication ext"
+    defaultTips:
+      tips: "apply to join the group"  # group info changed by xx
+
+  memberQuit:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "memberQuit title"
+      desc: "memberQuit desc"
+      ext: "memberQuit ext"
+    defaultTips:
+      tips: "quit group chat"  # group info changed by xx
+
+  groupApplicationAccepted:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "groupApplicationAccepted title"
+      desc: "groupApplicationAccepted desc"
+      ext: "groupApplicationAccepted ext"
+    defaultTips:
+      tips: "was allowed to join the group"  # group info changed by xx
+
+  groupApplicationRejected:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: false
+      title: " title"
+      desc: " desc"
+      ext: " ext"
+    defaultTips:
+      tips: "was rejected into the group"  # group info changed by xx
+
+  groupOwnerTransferred:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "groupOwnerTransferred title"
+      desc: "groupOwnerTransferred desc"
+      ext: "groupOwnerTransferred ext"
+    defaultTips:
+      tips: "become a new group owner"  # group info changed by xx
+
+  memberKicked:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "memberKicked title"
+      desc: "memberKicked desc"
+      ext: "memberKicked ext"
+    defaultTips:
+      tips: "was kicked out of the group"  # group info changed by xx
+
+  memberInvited:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "memberInvited title"
+      desc: "memberInvited desc"
+      ext: "memberInvited ext"
+    defaultTips:
+      tips: "was invited into the group"  # group info changed by xx
+
+  memberEnter:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "memberEnter title"
+      desc: "memberEnter desc"
+      ext: "memberEnter ext"
+    defaultTips:
+      tips: "entered the group"  # group info changed by xx
+
+  groupDismissed:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "groupDismissed title"
+      desc: "groupDismissed desc"
+      ext: "groupDismissed ext"
+    defaultTips:
+      tips: "group dismissed"
+  #############################friend#################################
+
+  friendApplicationAdded:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: true
+      title: "Somebody applies to add you as a friend"
+      desc: "Somebody applies to add you as a friend"
+      ext: "Somebody applies to add you as a friend"
+    defaultTips:
+      tips: "I applies to add you as a friend"  #
+
+  friendApplicationApproved:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: true
+      title: "Someone applies to add your friend application"
+      desc: "Someone applies to add your friend application"
+      ext: "Someone applies to add your friend application"
+    defaultTips:
+      tips: "I applies to add your friend application"  #
+
+
+  friendApplicationRejected:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: true
+      title: "Someone rejected your friend application"
+      desc: "Someone rejected your friend application"
+      ext: "Someone rejected your friend application"
+    defaultTips:
+      tips: "I rejected your friend application"  #
+
+
+
+
+
+  friendAdded:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: true
+      title: "We have become friends"
+      desc: "We have become friends"
+      ext: "We have become friends"
+    defaultTips:
+      tips: "We have become friends"  #
+
+
+
+  friendDeleted:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: true
+      title: "deleted a friend"
+      desc: "deleted a friend"
+      ext: "deleted a friend"
+    defaultTips:
+      tips: "deleted a friend"  #
+
+
+  friendRemarkSet:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: true
+      title: "Your friend's profile has been changed"
+      desc: "Your friend's profile has been changed"
+      ext: "Your friend's profile has been changed"
+    defaultTips:
+      tips: "Your friend's profile has been changed"  #
+
+
+
+  blackAdded:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: true
+      title: "blocked a user"
+      desc: "blocked a user"
+      ext: "blocked a user"
+    defaultTips:
+      tips: "blocked a user"  #
+
+
+  blackDeleted:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: true
+      title: "Remove a blocked user"
+      desc: "Remove a blocked user"
+      ext: "Remove a blocked user"
+    defaultTips:
+      tips: "Remove a blocked user"
+
+  #####################user#########################
+  userInfoUpdated:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: true
+      title: "Remove a blocked user"
+      desc: "Remove a blocked user"
+      ext: "Remove a blocked user"
+    defaultTips:
+      tips: "remove a blocked user"
+
+  #####################conversation#########################
+  conversationOptUpdate:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+      offlinePush:
+        switch: true
+        title: "conversation opt update"
+        desc: "conversation opt update"
+        ext: "conversation opt update"
+      defaultTips:
+        tips: "conversation opt update"
+
+
+
+#---------------demo configuration---------------------#
+#The following configuration items are applied to openIM Demo configuration
+#是否启动demo，如果自身没有账号体系，设置为true
+demoswitch: true
+demo:
+  #demo对外服务端口，默认即可，需要开放此端口或做nginx转发
+  openImDemoPort: [ 42233 ]
+  alismsverify: #阿里云短信配置，在阿里云申请成功后修改以下四项，必须修改
+    accessKeyId: LTAI5tJPkn4HuuePdiLdGqe7
+    accessKeySecret: 4n9OJ7ZCVN1U6KeHDAtOyNeVZcjOuV
+    signName: 托云信息技术
+    verificationCodeTemplateCode: SMS_226810164
+  superCode: 666666 #超级验证码，建议修改掉，收不到短信验证码时可以用此替代
+  #  second
+  codeTTL: 300
+  mail: #仅支持qq邮箱，具体操作参考 https://service.mail.qq.com/cgi-bin/help?subtype=1&id=28&no=1001256 必须修改
+    title: "openIM"
+    senderMail: "765567899@qq.com"
+    senderAuthorizationCode: "gxyausfoevlzbfag"
+    smtpAddr: "smtp.qq.com"
+    smtpPort: 25   #需开放此端口 出口方向
+
+
 
-messagecallback:
-  callbackSwitch: false
-  callbackUrl: "http://www.xxx.com/msg/judge"

deploy/.dockerignore

@@ -0,0 +1,6 @@
+# 先设为忽略所有内容
+**/**
+
+
+# 然后逐个排除
+!open_im_*

deploy/Makefile

@@ -0,0 +1,158 @@
+
+GREEN_PREFIX="\033[32m"
+COLOR_SUFFIX="\033[0m"
+SKY_BLUE_PREFIX="\033[36m"
+
+
+# 编译所有需要的组件源码
+win-build-all:
+	go env -w GOOS=linux 
+
+	make build-api && make build-msg-gateway && make build-msg-transfer  && make build-push && make build-timer-task
+	make build-rpc-user && make build-rpc-friend && make build-rpc-group && make build-rpc-msg && make build-rpc-auth
+	make build-demo
+
+	go env -w GOOS=windows
+
+# 编译 open_im_api
+build-api:
+	echo -e ${GREEN_PREFIX} "open_im_api building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_api ../cmd/open_im_api/main.go
+	echo -e ${GREEN_PREFIX} "open_im_api build ok" ${COLOR_SUFFIX}
+
+# 编译 open_im_msg_gateway
+build-msg-gateway:
+	echo -e ${GREEN_PREFIX} "open_im_msg_gateway building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_msg_gateway ../cmd/open_im_msg_gateway/main.go
+	echo -e ${GREEN_PREFIX} "open_im_msg_gateway build ok" ${COLOR_SUFFIX}
+
+# 编译 open_im_msg_transfer
+build-msg-transfer:
+	echo -e ${GREEN_PREFIX} "open_im_msg_transfer building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_msg_transfer ../cmd/open_im_msg_transfer/main.go
+	echo -e ${GREEN_PREFIX} "open_im_msg_transfer build ok" ${COLOR_SUFFIX}
+
+# 编译 open_im_push
+build-push:
+	echo -e ${GREEN_PREFIX} "open_im_push building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_push ../cmd/open_im_push/main.go
+	echo -e ${GREEN_PREFIX} "open_im_push build ok" ${COLOR_SUFFIX}
+
+# 编译 open_im_timer_task
+build-timer-task:
+	echo -e ${GREEN_PREFIX} "open_im_timer_task building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_timer_task ../cmd/open_im_timer_task/main.go
+	echo -e ${GREEN_PREFIX} "open_im_timer_task build ok" ${COLOR_SUFFIX}
+
+# 编译 build-rpc-user
+build-rpc-user:
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_user building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_rpc_user ../cmd/rpc/open_im_user/main.go
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_user build ok" ${COLOR_SUFFIX}
+
+# 编译 build-rpc-friend
+build-rpc-friend:
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_friend building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_rpc_friend ../cmd/rpc/open_im_friend/main.go
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_friend build ok" ${COLOR_SUFFIX}
+
+# 编译 build-rpc-group
+build-rpc-group:
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_group building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_rpc_group ../cmd/rpc/open_im_group/main.go
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_group build ok" ${COLOR_SUFFIX}
+
+# 编译 build-rpc-auth
+build-rpc-auth:
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_auth building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_rpc_auth ../cmd/rpc/open_im_auth/main.go
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_auth build ok" ${COLOR_SUFFIX}
+
+# 编译 build-rpc-msg
+build-rpc-msg:
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_msg building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_rpc_msg ../cmd/rpc/open_im_msg/main.go
+	echo -e ${SKY_BLUE_PREFIX} "open_im_rpc_msg build ok" ${COLOR_SUFFIX}
+
+# 编译 open_im_demo
+build-demo:
+	echo -e ${SKY_BLUE_PREFIX} "open_im_demo building..." ${COLOR_SUFFIX}
+	go build -ldflags="-w -s" -o open_im_demo ../cmd/open_im_demo/main.go
+	echo -e ${SKY_BLUE_PREFIX} "open_im_demo build ok" ${COLOR_SUFFIX}
+
+# 打包所有组件为镜像
+image-all:
+	make image-api && make image-msg-gateway && make image-msg-transfer & make image-push && make image-timer-task
+	make image-rpc-user && make image-rpc-friend && make image-rpc-group && make image-rpc-msg && make image-rpc-auth
+	make image-demo
+
+# 打包 open_im_api
+image-api:
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/api building..." ${COLOR_SUFFIX}
+	docker build -t openim/api:latest -f ./dockerfiles/Dockerfile.api .
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/api build ok" ${COLOR_SUFFIX}
+
+# 打包 open_im_msg_gateway
+image-msg-gateway:
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/msg_gateway building..." ${COLOR_SUFFIX}
+	docker build -t openim/msg_gateway:latest -f ./dockerfiles/Dockerfile.msg_gateway .
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/msg_gateway build ok" ${COLOR_SUFFIX}
+
+# 打包 open_im_msg_transfer
+image-msg-transfer:
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/msg_transfer building..." ${COLOR_SUFFIX}
+	docker build -t openim/msg_transfer:latest -f ./dockerfiles/Dockerfile.msg_transfer .
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/msg_transfer build ok" ${COLOR_SUFFIX}
+
+# 打包 open_im_push
+image-push:
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/push building..." ${COLOR_SUFFIX}
+	docker build -t openim/push:latest -f ./dockerfiles/Dockerfile.push .
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/push build ok" ${COLOR_SUFFIX}
+
+# 打包 open_im_timer_task
+image-timer-task:
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/timer_task building..." ${COLOR_SUFFIX}
+	docker build -t openim/timer_task:latest -f ./dockerfiles/Dockerfile.timer_task .
+	echo -e ${GREEN_PREFIX} "IMAGE:openim/timer_task build ok" ${COLOR_SUFFIX}
+
+# 打包 build-rpc-user
+image-rpc-user:
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_user building..." ${COLOR_SUFFIX}
+	docker build -t openim/rpc_user:latest -f ./dockerfiles/Dockerfile.rpc_user .
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_user build ok" ${COLOR_SUFFIX}
+
+# 打包 build-rpc-friend
+image-rpc-friend:
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_friend building..." ${COLOR_SUFFIX}
+	docker build -t openim/rpc_friend:latest -f ./dockerfiles/Dockerfile.rpc_friend .
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_friend build ok" ${COLOR_SUFFIX}
+
+# 打包 build-rpc-group
+image-rpc-group:
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_group building..." ${COLOR_SUFFIX}
+	docker build -t openim/rpc_group:latest -f ./dockerfiles/Dockerfile.rpc_group .
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_group build ok" ${COLOR_SUFFIX}
+
+# 打包 build-rpc-auth
+image-rpc-auth:
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_auth building..." ${COLOR_SUFFIX}
+	docker build -t openim/rpc_auth:latest -f ./dockerfiles/Dockerfile.rpc_auth .
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_auth build ok" ${COLOR_SUFFIX}
+
+# 打包 build-rpc-msg
+image-rpc-msg:
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_msg building..." ${COLOR_SUFFIX}
+	docker build -t openim/rpc_msg:latest -f ./dockerfiles/Dockerfile.rpc_msg .
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/rpc_msg build ok" ${COLOR_SUFFIX}
+
+# 打包 open_im_demo
+image-demo:
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/demo building..." ${COLOR_SUFFIX}
+	docker build -t openim/demo:latest -f ./dockerfiles/Dockerfile.demo .
+	echo -e ${SKY_BLUE_PREFIX} "IMAGE:openim/demo build ok" ${COLOR_SUFFIX}
+
+.PHONY: win-build-all build-api build-msg-gateway build-msg-transfer build-push 
+	build-timer-task build-rpc-user build-rpc-friend build-rpc-group build-rpc-msg build-demo
+	image-all image-api image-msg-gateway image-msg-transfer image-push 
+	image-timer-task image-rpc-user image-rpc-friend image-rpc-group image-rpc-msg image-demo

deploy/config.example.yaml

@@ -0,0 +1,182 @@
+# The class cannot be named by Pascal or camel case.
+# If it is not used, the corresponding structure will not be set,
+# and it will not be read naturally.
+serverversion: 1.0.3
+#---------------Infrastructure configuration---------------------#
+etcd:
+  etcdSchema: openIM
+  etcdAddr: [ openim_etcd:2379 ]
+
+mysql:
+  dbMysqlAddress: [ openim_mysql:3306 ] # openim_mysql 是对应的mysql服务的host
+  dbMysqlUserName: openIM
+  dbMysqlPassword: openIM
+  dbMysqlDatabaseName: openIM
+  dbTableName: eMsg
+  dbMsgTableNum: 1
+  dbMaxOpenConns: 20
+  dbMaxIdleConns: 10
+  dbMaxLifeTime: 120
+
+mongo:
+  dbAddress: [ openim_mongo:27017 ]
+  dbDirect: false
+  dbTimeout: 10
+  dbDatabase: openIM
+  dbSource: admin
+  dbUserName:
+  dbPassword:
+  dbMaxPoolSize: 20
+  dbRetainChatRecords: 7
+
+redis:
+  dbAddress: openim_redis:6379
+  dbMaxIdle: 128
+  dbMaxActive: 0
+  dbIdleTimeout: 120
+  dbPassWord: openIM
+
+kafka:
+  ws2mschat:
+    addr: [ openim_kafka:9092 ]
+    topic: "ws2ms_chat"
+  ms2pschat:
+    addr: [ openim_kafka:9092 ]
+    topic: "ms2ps_chat"
+  consumergroupid:
+    msgToMongo: mongo
+    msgToMySql: mysql
+    msgToPush: push
+
+
+
+#---------------Internal service configuration---------------------#
+
+# The service ip default is empty,
+# automatically obtain the machine's valid network card ip as the service ip,
+# otherwise the configuration ip is preferred
+serverip: 0.0.0.0
+
+# endpoints 内部组件间访问的端点host名称，访问时，可以内部直接访问 host:port 来访问
+#   新增的这一段配置节，主要是位了注册到etcd时，可以使用同一network下的容器名(host)来访问不同的容器，拆分到不同容器后原来全部使用serverip的形式不能用了
+endpoints:
+  api: openim_api
+  push: openim_push
+  msg_gateway: openim_msg_gateway
+  rpc_auth: openim_rpc_auth
+  rpc_friend: openim_rpc_friend
+  rpc_group: openim_rpc_group
+  rpc_msg: openim_rpc_msg
+  rpc_user: openim_rpc_user
+
+api:
+  openImApiPort: [ 10000 ]
+sdk:
+  openImSdkWsPort: [ 30000 ]
+cmsapi:
+  openImCmsApiPort: [ 8000 ]
+
+credential:
+  tencent:
+    appID: 1302656840
+    region: ap-chengdu
+    bucket: echat-1302656840
+    secretID: AKIDGNYVChzIQinu7QEgtNp0hnNgqcV8vZTC
+    secretKey: kz15vW83qM6dBUWIq681eBZA0c0vlIbe
+
+
+rpcport:
+  openImUserPort: [ 10100 ]
+  openImFriendPort: [ 10200 ]
+  openImOfflineMessagePort: [ 10300]
+  openImOnlineRelayPort: [ 10400 ]
+  openImGroupPort: [ 10500  ]
+  openImAuthPort: [ 10600 ]
+  openImPushPort: [ 10700 ]
+  openImStatisticsPort: [ 10800 ]
+  openImMessageCmsPort: [ 10900 ]
+  openImAdminCmsPort: [ 11000 ]
+
+rpcregistername:
+  openImUserName: User
+  openImFriendName: Friend
+  openImOfflineMessageName: OfflineMessage
+  openImPushName: Push
+  openImOnlineMessageRelayName: OnlineMessageRelay
+  openImGroupName: Group
+  openImAuthName: Auth
+
+log:
+  storageLocation: ../logs/
+  rotationTime: 24
+  remainRotationCount: 5
+  remainLogLevel: 6
+  elasticSearchSwitch: false
+  elasticSearchAddr: [ 127.0.0.1:9201 ]
+  elasticSearchUser: ""
+  elasticSearchPassword: ""
+
+modulename:
+  longConnSvrName: msg_gateway
+  msgTransferName: msg_transfer
+  pushName: push
+
+longconnsvr:
+  openImWsPort: [ 17778 ]
+  websocketMaxConnNum: 10000
+  websocketMaxMsgLen: 4096
+  websocketTimeOut: 10
+
+push:
+  tpns:
+    ios:
+      accessID: 1600018281
+      secretKey: 3cd68a77a95b89e5089a1aca523f318f
+    android:
+      accessID: 111
+      secretKey: 111
+  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"
+manager:
+  appManagerUid: ["openIM123456","openIM654321"]
+  secrets: ["openIM1","openIM2"]
+
+secret: tuoyun
+
+multiloginpolicy: 1
+
+#token config
+tokenpolicy:
+  accessSecret: "open_im_server"
+  # Token effective time day as a unit
+  accessExpire: 7
+
+messagecallback:
+  callbackSwitch: false
+  callbackUrl: "http://www.xxx.com/msg/judge"
+  #TimeOut use second as unit
+  callbackTimeOut: 10
+
+
+#---------------demo configuration---------------------#
+#The following configuration items are applied to openIM Demo configuration
+demoswitch: true
+demo:
+  openImDemoPort: [ 42233 ]
+  alismsverify:
+    accessKeyId: LTAI5tJPkn4HuuePdiLdGqe71
+    accessKeySecret: 4n9OJ7ZCVN1U6KeHDAtOyNeVZcjOuV1
+    signName: OpenIM Corporation
+    verificationCodeTemplateCode: SMS_2268101641
+  superCode: 666666
+  mail:
+    title: "openIM"
+    senderMail: "1765567899@qq.com"
+    senderAuthorizationCode: "1gxyausfoevlzbfag"
+    smtpAddr: "smtp.qq.com"
+    smtpPort: 25
+
+

deploy/dockerfiles/Dockerfile.api

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_api $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.demo

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_demo $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.msg_gateway

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_msg_gateway $WORKDIR/main
+
+# 创建用于挂载的几个目录，重命名可执行文件为 main，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.msg_transfer

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_msg_transfer $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.push

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_push $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.rpc_auth

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_rpc_auth $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.rpc_friend

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_rpc_friend $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.rpc_group

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_rpc_group $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.rpc_msg

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_rpc_msg $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.rpc_user

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_rpc_user $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/dockerfiles/Dockerfile.timer_task

@@ -0,0 +1,16 @@
+FROM alpine:3.13
+
+# 设置固定的项目路径
+ENV WORKDIR /app
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_timer_task $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+
+WORKDIR $WORKDIR
+CMD ./main

deploy/env.yaml

@@ -0,0 +1,101 @@
+version: "3.7"
+networks: 
+  openim: 
+    external: true
+ 
+services:
+  mysql:
+    networks: 
+      - openim
+    image: mysql:5.7
+    # ports:
+    #   #- 13306:3306
+    #   - 23306:33060
+    container_name: openim_mysql
+    volumes:
+      - ./components/mysql/data:/var/lib/mysql
+      - /etc/localtime:/etc/localtime
+    environment:
+      MYSQL_ROOT_PASSWORD: openIM
+    restart: always
+
+  mongodb:
+    networks: 
+      - openim
+    image: mongo:4.4.5-bionic
+    # ports:
+    #   - 37017:27017
+    container_name: openim_mongo
+    volumes:
+      - ./components/mongodb/data/db:/data/db
+      - ./components/mongodb/data/logs:/data/logs
+      - ./components/mongodb/data/conf:/etc/mongo
+   environment:
+    TZ: Asia/Shanghai
+   #   - MONGO_INITDB_ROOT_USERNAME=openIM
+    #  - MONGO_INITDB_ROOT_PASSWORD=openIM
+    restart: always
+
+  redis:
+    networks: 
+      - openim
+    image: redis:6.2.4-alpine
+    # ports:
+    #   - 16379:6379
+    container_name: openim_redis
+    volumes:
+      - ./components/redis/data:/data
+      #redis config file
+      #- ./components/redis/config/redis.conf:/usr/local/redis/config/redis.conf
+    environment:
+      TZ: Asia/Shanghai
+    restart: always
+    sysctls:
+      net.core.somaxconn: 1024
+    command: redis-server --requirepass openIM --appendonly yes
+
+
+  zookeeper:
+    networks: 
+      - openim
+    image: wurstmeister/zookeeper
+    # ports:
+    #   - 2181:2181
+    container_name: openim_zookeeper
+    volumes:
+      - /etc/localtime:/etc/localtime
+    environment:
+      TZ: Asia/Shanghai
+    restart: always
+
+  kafka:
+    networks: 
+      - openim
+    image: wurstmeister/kafka
+    container_name: openim_kafka
+    restart: always
+    environment:
+      TZ: Asia/Shanghai
+      KAFKA_BROKER_ID: 0
+      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
+      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
+      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092
+    depends_on:
+      - zookeeper
+
+  etcd:
+    networks: 
+      - openim
+    image: quay.io/coreos/etcd
+    # ports:
+    #   - 2379:2379
+    #   - 2380:2380
+    container_name: openim_etcd
+    volumes:
+      - /etc/timezone:/etc/timezone
+      - /etc/localtime:/etc/localtime
+    environment:
+      ETCDCTL_API: 3
+    restart: always
+    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
+

deploy/openim.yaml

@@ -0,0 +1,223 @@
+version: "3.7"
+networks: 
+  openim:
+    external: true
+ 
+services:
+  api:
+    networks: 
+      - openim
+    image: openim/api
+    container_name: openim_api
+    ports:
+      - 10000:10000 # API，必须开
+    volumes:
+      - ./logs:/app/logs
+      # Dockerfile 里定义了配置文件的路径环境变量，CONFIG_NAME，默认指向了 /app/config/config.yaml
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+    logging:
+      driver: json-file
+      options:
+        max-size: "1g"
+        max-file: "2"
+
+  msg_gateway:
+    networks: 
+      - openim
+    image: openim/msg_gateway
+    container_name: openim_msg_gateway
+    ports:
+      - 17778:17778 # 消息，必须开
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+    logging:
+      driver: json-file
+      options:
+        max-size: "1g"
+        max-file: "2"
+        
+  msg_transfer:
+    networks: 
+      - openim
+    image: openim/msg_transfer
+    container_name: openim_msg_transfer
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+    logging:
+      driver: json-file
+      options:
+        max-size: "1g"
+        max-file: "2"
+  
+  push:
+    networks: 
+      - openim
+    image: openim/push
+    container_name: openim_push
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+    logging:
+      driver: json-file
+      options:
+        max-size: "1g"
+        max-file: "2"
+
+  timer_task:
+    networks: 
+      - openim
+    image: openim/timer_task
+    container_name: openim_timer_task
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+    logging:
+      driver: json-file
+      options:
+        max-size: "1g"
+        max-file: "2"
+
+  rpc_user:
+    networks: 
+      - openim
+    image: openim/rpc_user
+    container_name: openim_rpc_user
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+    logging:
+      driver: json-file
+      options:
+        max-size: "1g"
+        max-file: "2"
+
+  rpc_friend:
+    networks: 
+      - openim
+    image: openim/rpc_friend
+    container_name: openim_rpc_friend
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+
+  rpc_group:
+    networks: 
+      - openim
+    image: openim/rpc_group
+    container_name: openim_rpc_group
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+
+  rpc_auth:
+    networks: 
+      - openim
+    image: openim/rpc_auth
+    container_name: openim_rpc_auth
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+
+  rpc_msg:
+    networks: 
+      - openim
+    image: openim/rpc_msg
+    container_name: openim_rpc_msg
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always
+    # depends_on:
+    #   - kafka
+    #   # - mysql
+    #   # - mongodb
+    #   - redis
+    #   - etcd
+
+  demo:
+    networks: 
+      - openim
+    image: openim/demo
+    container_name: openim_demo
+    ports:
+      - 42233:42233
+    volumes:
+      - ./logs:/app/logs
+      - ./config/config.yaml:/app/config/config.yaml
+      - ./db/sdk:/app/db/sdk
+    restart: always

deploy/readme.md

@@ -0,0 +1,30 @@
+
+### 以docker-compose 形式单独部署
+```sh
+# 查看 ./Makefile ，先编译各个需要的源码到 ../bin 
+# win-* 表示在win平台编译位linux二进制，其实就是处理了 go env -w GOOS=linux 
+make win-build-all
+
+# 得到各个二进制程序之后，打包为镜像
+# 目前没有处理 Open-IM-SDK-Core ，需要的话可以自己单独处理这个模块
+make image-all
+
+# docker-compose.yaml 分成了两部分，一部分是openIM的镜像容器 openim.yaml，一部分是依赖的环境 env.yaml
+# 两部分使用一个外部的网络来联通，所以首先创建用到的 network
+docker network create openim --attachable=true -d bridge
+
+# 处理openim组件需要的挂载目录，主要是处理config目录
+mkdir ./config
+cp ./config.example.yaml ./config/config.yaml # 修改 ./config/config.yaml 内容，比如各个依赖组件的 host
+
+# 然后拉起env.yaml
+docker-compose -f ./env.yaml up -d
+
+# 等env 容器全部拉起成功之后，拉起openim.yaml
+docker-compose -f ./openim.yaml up -d
+
+# 查看容器运行，推荐使用下 portainer ，web查看容器情况，查看日志等等
+docker container ps -a | grep openim
+
+# 正常应该是查看api,demo等的容器日志，看到gin打印的路由日志才算是成功
+```

docker-compose.yaml

@@ -5,7 +5,8 @@ services:
   mysql:
     image: mysql:5.7
     ports:
-      - 3306:3306
+      - 13306:3306
+      - 23306:33060
     container_name: mysql
     volumes:
       - ./components/mysql/data:/var/lib/mysql
@@ -15,20 +16,29 @@ services:
     restart: always
 
   mongodb:
-    image: mongo
+    image: mongo:4.0
     ports:
-      - 27017:27017
+      - 37017:27017
     container_name: mongo
     volumes:
-      - ./components/mongodb/data:/data/db
+      - ./components/mongodb/data/db:/data/db
+      - ./components/mongodb/data/logs:/data/logs
+      - ./components/mongodb/data/conf:/etc/mongo
     environment:
-      TZ: Asia/Shanghai
+      - TZ=Asia/Shanghai
+      # cache
+      - wiredTigerCacheSizeGB=1
+#    environment:
+#      - MONGO_INITDB_ROOT_USERNAME=openIM
+#      - MONGO_INITDB_ROOT_PASSWORD=openIM
+
+      #TZ: Asia/Shanghai
     restart: always
 
   redis:
     image: redis
     ports:
-      - 6379:6379
+      - 16379:6379
     container_name: redis
     volumes:
       - ./components/redis/data:/data
@@ -82,38 +92,14 @@ services:
     restart: always
     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
 
-
-  #fixme-----build from dockerfile---------
-  # open-im-server:
-  #    image: open_im_server
-  #    container_name: open-im-server
-  #    volumes:
-  #      - ./logs:/Open-IM-Server/logs
-  #      - ./config/config.yaml:/Open-IM-Server/config/config.yaml
-  #    restart: always
-  #    build:
-  #      context: .
-  #      dockerfile: deploy.Dockerfile
-  #    depends_on:
-  #      - mysql
-  #      - mongodb
-  #      - redis
-  #      - kafka
-  #      - etcd
-  #    network_mode: "host"
-  #      logging:
-  #        driver: json-file
-  #        options:
-  #          max-size: "1g"
-  #          max-file: "2"
-
-  #fixme----build from docker hub------
-  open-im-server:
-    image: lyt1123/open_im_server
-    container_name: open-im-server
+  open_im_server:
+    image: openim/open_im_server:v2.0.2
+    container_name: open_im_server
     volumes:
       - ./logs:/Open-IM-Server/logs
       - ./config/config.yaml:/Open-IM-Server/config/config.yaml
+      - ./db/sdk:/Open-IM-Server/db/sdk
+      - ./script:/Open-IM-Server/script
     restart: always
     depends_on:
       - kafka

go.mod

@@ -5,43 +5,63 @@ go 1.15
 require (
 	github.com/Shopify/sarama v1.19.0
 	github.com/Shopify/toxiproxy v2.1.4+incompatible // indirect
+	github.com/alibabacloud-go/darabonba-openapi v0.1.11
+	github.com/alibabacloud-go/dysmsapi-20170525/v2 v2.0.8
+	github.com/alibabacloud-go/tea v1.1.17
 	github.com/antonfisher/nested-logrus-formatter v1.3.0
-	github.com/coreos/go-semver v0.3.0 // indirect
-	github.com/dgrijalva/jwt-go v3.2.0+incompatible
-	github.com/dustin/go-humanize v1.0.0 // indirect
+	github.com/bwmarrin/snowflake v0.3.0
+	github.com/coreos/etcd v3.3.27+incompatible // indirect
+	github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f // indirect
 	github.com/eapache/go-resiliency v1.2.0 // indirect
 	github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21 // indirect
 	github.com/eapache/queue v1.1.0 // indirect
-	github.com/frankban/quicktest v1.11.3 // indirect
+	github.com/fatih/structs v1.1.0
+	github.com/frankban/quicktest v1.14.0 // indirect
 	github.com/garyburd/redigo v1.6.2
 	github.com/gin-gonic/gin v1.7.0
 	github.com/go-playground/validator/v10 v10.4.1
+	github.com/go-sql-driver/mysql v1.6.0 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang-jwt/jwt/v4 v4.1.0
 	github.com/golang/protobuf v1.5.2
-	github.com/golang/snappy v0.0.3 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
 	github.com/gorilla/websocket v1.4.2
+	github.com/jinzhu/copier v0.3.4
 	github.com/jinzhu/gorm v1.9.16
+	github.com/jinzhu/now v1.1.3 // indirect
 	github.com/jonboulle/clockwork v0.2.2 // indirect
 	github.com/lestrrat-go/file-rotatelogs v2.4.0+incompatible
 	github.com/lestrrat-go/strftime v1.0.4 // indirect
 	github.com/lib/pq v1.2.0 // indirect
+	//github.com/livekit/protocol v0.11.14-0.20220223195254-d8c251e13231 // indirect
+	//github.com/livekit/server-sdk-go v0.9.1
 	github.com/mattn/go-sqlite3 v1.14.6 // indirect
-	github.com/mitchellh/mapstructure v1.4.1
+	github.com/minio/minio-go/v7 v7.0.22
+	github.com/mitchellh/mapstructure v1.4.2
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
 	github.com/olivere/elastic/v7 v7.0.23
-	github.com/pierrec/lz4 v2.6.0+incompatible // indirect
+	github.com/pierrec/lz4 v2.6.1+incompatible // indirect
+	github.com/pkg/errors v0.9.1
 	github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
 	github.com/rifflock/lfshook v0.0.0-20180920164130-b9218ef580f5
-	github.com/sirupsen/logrus v1.6.0
+	github.com/sirupsen/logrus v1.8.1
+	github.com/spf13/viper v1.9.0
+	github.com/stretchr/testify v1.7.0
 	github.com/tencentyun/qcloud-cos-sts-sdk v0.0.0-20210325043845-84a0811633ca
 	github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5 // indirect
+	//go.etcd.io/etcd v3.3.27+incompatible
 	go.etcd.io/etcd v0.0.0-20200402134248-51bdeb39e698
+	go.mongodb.org/mongo-driver v1.8.3
 	golang.org/x/image v0.0.0-20210220032944-ac19c3e999fb
-	golang.org/x/net v0.0.0-20201110031124-69a78807bb2b
-	golang.org/x/tools v0.0.0-20210106214847-113979e3529a // indirect
-	google.golang.org/grpc v1.33.2
+	golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd
+	google.golang.org/grpc v1.42.0
+	google.golang.org/grpc/examples v0.0.0-20220311002955-722367c4a737 // indirect
+	google.golang.org/protobuf v1.27.1
+	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
+	gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df
 	gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22
-	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
 	sigs.k8s.io/yaml v1.2.0 // indirect
 )
 
-replace google.golang.org/grpc => google.golang.org/grpc v1.29.1
+replace google.golang.org/grpc => google.golang.org/grpc v1.29.0

internal/api/auth/auth.go

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

internal/api/chat/del_msg.go

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

internal/api/chat/get_max_min_seq.go

@@ -1,11 +1,11 @@
 package apiChat
 
 import (
-	"Open_IM/src/common/config"
-	"Open_IM/src/common/log"
-	"Open_IM/src/grpc-etcdv3/getcdv3"
-	pbMsg "Open_IM/src/proto/chat"
-	"Open_IM/src/utils"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbMsg "Open_IM/pkg/proto/chat"
 	"context"
 	"github.com/gin-gonic/gin"
 	"net/http"
@@ -19,7 +19,7 @@ type paramsUserNewestSeq struct {
 	MsgIncr       int    `json:"msgIncr" binding:"required"`
 }
 
-func UserGetSeq(c *gin.Context) {
+func GetSeq(c *gin.Context) {
 	params := paramsUserNewestSeq{}
 	if err := c.BindJSON(&params); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
@@ -27,8 +27,8 @@ func UserGetSeq(c *gin.Context) {
 	}
 
 	token := c.Request.Header.Get("token")
-	if !utils.VerifyToken(token, params.SendID) {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"})
+	if ok, err := token_verify.VerifyToken(token, params.SendID); !ok {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
 		return
 	}
 	pbData := pbMsg.GetMaxAndMinSeqReq{}
@@ -42,7 +42,8 @@ func UserGetSeq(c *gin.Context) {
 	msgClient := pbMsg.NewChatClient(grpcConn)
 	reply, err := msgClient.GetMaxAndMinSeq(context.Background(), &pbData)
 	if err != nil {
-		log.ErrorByKv("rpc call failed to getNewSeq", pbData.OperationID, "err", err, "pbData", pbData.String())
+		log.NewError(params.OperationID, "UserGetSeq rpc failed, ", params, err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "UserGetSeq rpc failed, " + err.Error()})
 		return
 	}
 

internal/api/chat/pull_msg.go

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

internal/api/chat/send_msg.go

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

internal/api/conversation/conversation.go

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

internal/api/friend/friend.go

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

internal/api/group/group.go

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

internal/api/manage/management_chat.go

@@ -7,12 +7,16 @@
 package manage
 
 import (
-	"Open_IM/src/common/config"
-	"Open_IM/src/common/constant"
-	"Open_IM/src/common/log"
-	"Open_IM/src/grpc-etcdv3/getcdv3"
-	pbChat "Open_IM/src/proto/chat"
-	"Open_IM/src/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"
+	pbChat "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/proto/sdk_ws"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
 	"context"
 	"github.com/gin-gonic/gin"
 	"github.com/go-playground/validator/v10"
@@ -23,19 +27,7 @@ import (
 
 var validate *validator.Validate
 
-type paramsManagementSendMsg struct {
-	OperationID    string                 `json:"operationID" binding:"required"`
-	SendID         string                 `json:"sendID" binding:"required"`
-	RecvID         string                 `json:"recvID" binding:"required"`
-	SenderNickName string                 `json:"senderNickName" `
-	SenderFaceURL  string                 `json:"senderFaceURL" `
-	ForceList      []string               `json:"forceList" `
-	Content        map[string]interface{} `json:"content" binding:"required"`
-	ContentType    int32                  `json:"contentType" binding:"required"`
-	SessionType    int32                  `json:"sessionType" binding:"required"`
-}
-
-func newUserSendMsgReq(params *paramsManagementSendMsg) *pbChat.UserSendMsgReq {
+func newUserSendMsgReq(params *ManagementSendMsgReq) *pbChat.SendMsgReq {
 	var newContent string
 	switch params.ContentType {
 	case constant.Text:
@@ -48,32 +40,47 @@ func newUserSendMsgReq(params *paramsManagementSendMsg) *pbChat.UserSendMsgReq {
 		fallthrough
 	case constant.File:
 		newContent = utils.StructToJsonString(params.Content)
+	case constant.Revoke:
+		newContent = params.Content["revokeMsgClientID"].(string)
 	default:
-
 	}
-	pbData := pbChat.UserSendMsgReq{
-		ReqIdentifier:  constant.WSSendMsg,
-		SendID:         params.SendID,
-		SenderNickName: params.SenderNickName,
-		SenderFaceURL:  params.SenderFaceURL,
-		OperationID:    params.OperationID,
-		PlatformID:     0,
-		SessionType:    params.SessionType,
-		MsgFrom:        constant.UserMsgType,
-		ContentType:    params.ContentType,
-		RecvID:         params.RecvID,
-		ForceList:      params.ForceList,
-		Content:        newContent,
-		ClientMsgID:    utils.GetMsgID(params.SendID),
+	var options map[string]bool
+	if params.IsOnlineOnly {
+		options = make(map[string]bool, 5)
+		utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
+		utils.SetSwitchFromOptions(options, constant.IsHistory, false)
+		utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
+		utils.SetSwitchFromOptions(options, constant.IsSenderSync, false)
+	}
+	pbData := pbChat.SendMsgReq{
+		OperationID: params.OperationID,
+		MsgData: &open_im_sdk.MsgData{
+			SendID:           params.SendID,
+			RecvID:           params.RecvID,
+			GroupID:          params.GroupID,
+			ClientMsgID:      utils.GetMsgID(params.SendID),
+			SenderPlatformID: params.SenderPlatformID,
+			SenderNickname:   params.SenderNickname,
+			SenderFaceURL:    params.SenderFaceURL,
+			SessionType:      params.SessionType,
+			MsgFrom:          constant.SysMsgType,
+			ContentType:      params.ContentType,
+			Content:          []byte(newContent),
+			//	ForceList:        params.ForceList,
+			CreateTime:      utils.GetCurrentTimestampByMill(),
+			Options:         options,
+			OfflinePushInfo: params.OfflinePushInfo,
+		},
 	}
 	return &pbData
 }
 func init() {
 	validate = validator.New()
 }
+
 func ManagementSendMsg(c *gin.Context) {
 	var data interface{}
-	params := paramsManagementSendMsg{}
+	params := ManagementSendMsgReq{}
 	if err := c.BindJSON(&params); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
 		log.ErrorByKv("json unmarshal err", c.PostForm("operationID"), "err", err.Error(), "content", c.PostForm("content"))
@@ -84,8 +91,25 @@ func ManagementSendMsg(c *gin.Context) {
 		data = TextElem{}
 	case constant.Picture:
 		data = PictureElem{}
+	case constant.Voice:
+		data = SoundElem{}
+	case constant.Video:
+		data = VideoElem{}
+	case constant.File:
+		data = FileElem{}
+	//case constant.AtText:
+	//	data = AtElem{}
+	//case constant.Merger:
+	//	data =
+	//case constant.Card:
+	//case constant.Location:
 	case constant.Custom:
 		data = CustomElem{}
+	case constant.Revoke:
+		data = RevokeElem{}
+	//case constant.HasReadReceipt:
+	//case constant.Typing:
+	//case constant.Quote:
 	default:
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 404, "errMsg": "contentType err"})
 		log.ErrorByKv("contentType err", c.PostForm("operationID"), "content", c.PostForm("content"))
@@ -100,17 +124,33 @@ func ManagementSendMsg(c *gin.Context) {
 		log.ErrorByKv("data args validate  err", "", "err", err.Error())
 		return
 	}
-
+	log.NewInfo("", data, params)
 	token := c.Request.Header.Get("token")
-	claims, err := utils.ParseToken(token)
+	claims, err := token_verify.ParseToken(token)
 	if err != nil {
 		log.NewError(params.OperationID, "parse token failed", err.Error())
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "parse token failed", "sendTime": 0, "MsgID": ""})
+		return
 	}
 	if !utils.IsContain(claims.UID, config.Config.Manager.AppManagerUid) {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "not authorized", "sendTime": 0, "MsgID": ""})
 		return
 
+	}
+	switch params.SessionType {
+	case constant.SingleChatType:
+		if len(params.RecvID) == 0 {
+			log.NewError(params.OperationID, "recvID is a null string")
+			c.JSON(http.StatusBadRequest, gin.H{"errCode": 405, "errMsg": "recvID is a null string", "sendTime": 0, "MsgID": ""})
+			return
+		}
+	case constant.GroupChatType:
+		if len(params.GroupID) == 0 {
+			log.NewError(params.OperationID, "groupID is a null string")
+			c.JSON(http.StatusBadRequest, gin.H{"errCode": 405, "errMsg": "groupID is a null string", "sendTime": 0, "MsgID": ""})
+			return
+		}
+
 	}
 	log.InfoByKv("Ws call success to ManagementSendMsgReq", params.OperationID, "Parameters", params)
 
@@ -122,16 +162,44 @@ func ManagementSendMsg(c *gin.Context) {
 
 	log.Info("", "", "api ManagementSendMsg call, api call rpc...")
 
-	reply, _ := client.UserSendMsg(context.Background(), pbData)
-	log.Info("", "", "api ManagementSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
+	RpcResp, err := client.SendMsg(context.Background(), pbData)
+	if err != nil {
+		log.NewError(params.OperationID, "call delete UserSendMsg rpc server failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call UserSendMsg  rpc server failed"})
+		return
+	}
+	log.Info("", "", "api ManagementSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), RpcResp.String())
+	resp := api.ManagementSendMsgResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, ResultList: server_api_params.UserSendMsgResp{ServerMsgID: RpcResp.ServerMsgID, ClientMsgID: RpcResp.ClientMsgID, SendTime: RpcResp.SendTime}}
+	log.Info(params.OperationID, "ManagementSendMsg return", resp)
+	c.JSON(http.StatusOK, resp)
 
-	c.JSON(http.StatusOK, gin.H{
-		"errCode":  reply.ErrCode,
-		"errMsg":   reply.ErrMsg,
-		"sendTime": reply.SendTime,
-		"msgID":    reply.ClientMsgID,
-	})
+}
 
+//
+//type MergeElem struct {
+//	Title        string       `json:"title"`
+//	AbstractList []string     `json:"abstractList"`
+//	MultiMessage []*MsgStruct `json:"multiMessage"`
+//}
+//
+//type QuoteElem struct {
+//	Text         string     `json:"text"`
+//	QuoteMessage *MsgStruct `json:"quoteMessage"`
+//}
+type ManagementSendMsgReq struct {
+	OperationID      string                       `json:"operationID" binding:"required"`
+	SendID           string                       `json:"sendID" binding:"required"`
+	RecvID           string                       `json:"recvID" `
+	GroupID          string                       `json:"groupID" `
+	SenderNickname   string                       `json:"senderNickname" `
+	SenderFaceURL    string                       `json:"senderFaceURL" `
+	SenderPlatformID int32                        `json:"senderPlatformID"`
+	ForceList        []string                     `json:"forceList" `
+	Content          map[string]interface{}       `json:"content" binding:"required"`
+	ContentType      int32                        `json:"contentType" binding:"required"`
+	SessionType      int32                        `json:"sessionType" binding:"required"`
+	IsOnlineOnly     bool                         `json:"isOnlineOnly"`
+	OfflinePushInfo  *open_im_sdk.OfflinePushInfo `json:"offlinePushInfo"`
 }
 
 type PictureBaseInfo struct {
@@ -177,12 +245,6 @@ type FileElem struct {
 	FileName  string `mapstructure:"fileName"`
 	FileSize  int64  `mapstructure:"fileSize"`
 }
-
-//type MergeElem struct {
-//	Title        string       `json:"title"`
-//	AbstractList []string     `json:"abstractList"`
-//	MultiMessage []*MsgStruct `json:"multiMessage"`
-//}
 type AtElem struct {
 	Text       string   `mapstructure:"text"`
 	AtUserList []string `mapstructure:"atUserList"`
@@ -202,7 +264,6 @@ type TextElem struct {
 	Text string `mapstructure:"text" validate:"required"`
 }
 
-//type QuoteElem struct {
-//	Text         string     `json:"text"`
-//	QuoteMessage *MsgStruct `json:"quoteMessage"`
-//}
+type RevokeElem struct {
+	RevokeMsgClientID string `mapstructure:"revokeMsgClientID" validate:"required"`
+}

internal/api/manage/management_user.go

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

internal/api/third/minio_init.go

@@ -0,0 +1,57 @@
+package apiThird
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	url2 "net/url"
+)
+
+var (
+	minioClient *minio.Client
+)
+
+func MinioInit() {
+	log.NewInfo("", utils.GetSelfFuncName())
+	minioUrl, err := url2.Parse(config.Config.Credential.Minio.Endpoint)
+	if err != nil {
+		log.NewError("", utils.GetSelfFuncName(), "parse failed, please check config/config.yaml", err.Error())
+		return
+	}
+	minioClient, err = minio.New(minioUrl.Host, &minio.Options{
+		Creds:  credentials.NewStaticV4(config.Config.Credential.Minio.AccessKeyID, config.Config.Credential.Minio.SecretAccessKey, ""),
+		Secure: false,
+	})
+	if err != nil {
+		log.NewError("", utils.GetSelfFuncName(), "init minio client failed", err.Error())
+		return
+	}
+	opt := minio.MakeBucketOptions{
+		Region:        config.Config.Credential.Minio.Location,
+		ObjectLocking: false,
+	}
+	err = minioClient.MakeBucket(context.Background(), config.Config.Credential.Minio.Bucket, opt)
+	if err != nil {
+		log.NewInfo("", utils.GetSelfFuncName(), 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)
+		} else {
+			if err != nil {
+				log.NewError("", utils.GetSelfFuncName(), err.Error())
+			}
+			log.NewError("", 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")
+}

internal/api/third/minio_storage_credential.go

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

internal/api/third/tencent_cloud_storage_credential.go

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

internal/api/user/user.go

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

internal/cms_api/admin/admin.go

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

internal/cms_api/group/group.go

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

internal/cms_api/message_cms/message.go

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

internal/cms_api/middleware/cors.go

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

internal/cms_api/middleware/jwt_auth.go

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

internal/cms_api/organization/organization.go

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

internal/cms_api/router.go

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

internal/cms_api/statistics/statistics.go

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

internal/cms_api/user/user.go

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

internal/demo/register/login.go

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

internal/demo/register/reset_password.go

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

internal/demo/register/send_code.go

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

internal/demo/register/set_password.go

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

internal/demo/register/verify.go

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

internal/msg_gateway/gate/init.go

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

internal/msg_gateway/gate/logic.go

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

internal/msg_gateway/gate/open_im_media/room.go

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

internal/msg_gateway/gate/rpc_server.go

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

internal/msg_gateway/gate/validate.go

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

internal/msg_gateway/gate/ws_server.go

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

internal/msg_transfer/logic/db.go

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

internal/msg_transfer/logic/history_msg_handler.go

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

internal/msg_transfer/logic/init.go

@@ -1,9 +1,9 @@
 package logic
 
 import (
-	"Open_IM/src/common/config"
-	"Open_IM/src/common/kafka"
-	"Open_IM/src/common/log"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/common/log"
 )
 
 var (

internal/msg_transfer/logic/persistent_msg_handler.go

@@ -7,16 +7,15 @@
 package logic
 
 import (
-	"Open_IM/src/common/config"
-	"Open_IM/src/common/constant"
-	"Open_IM/src/common/db/mysql_model/im_mysql_msg_model"
-	kfk "Open_IM/src/common/kafka"
-	"Open_IM/src/common/log"
-	pbMsg "Open_IM/src/proto/chat"
-	"Open_IM/src/utils"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/mysql_model/im_mysql_msg_model"
+	kfk "Open_IM/pkg/common/kafka"
+	"Open_IM/pkg/common/log"
+	pbMsg "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
 	"github.com/Shopify/sarama"
 	"github.com/golang/protobuf/proto"
-	"strings"
 )
 
 type PersistentConsumerHandler struct {
@@ -32,30 +31,29 @@ func (pc *PersistentConsumerHandler) Init() {
 		config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.ConsumerGroupID.MsgToMySql)
 
 }
+
 func (pc *PersistentConsumerHandler) handleChatWs2Mysql(msg []byte, msgKey string) {
-	log.InfoByKv("chat come here mysql!!!", "", "chat", string(msg))
-	pbData := pbMsg.WSToMsgSvrChatMsg{}
-	err := proto.Unmarshal(msg, &pbData)
+	log.NewInfo("msg come here mysql!!!", "", "msg", string(msg))
+	msgFromMQ := pbMsg.MsgDataToMQ{}
+	err := proto.Unmarshal(msg, &msgFromMQ)
 	if err != nil {
-		log.ErrorByKv("msg_transfer Unmarshal chat err", "", "chat", string(msg), "err", err.Error())
+		log.ErrorByKv("msg_transfer Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
 		return
 	}
-	Options := utils.JsonStringToMap(pbData.Options)
 	//Control whether to store history messages (mysql)
-	isPersist := utils.GetSwitchFromOptions(Options, "persistent")
+	isPersist := utils.GetSwitchFromOptions(msgFromMQ.MsgData.Options, constant.IsPersistent)
 	//Only process receiver data
 	if isPersist {
-		if msgKey == pbData.RecvID && pbData.SessionType == constant.SingleChatType {
-			log.InfoByKv("msg_transfer chat persisting", pbData.OperationID)
-			if err = im_mysql_msg_model.InsertMessageToChatLog(pbData); err != nil {
-				log.ErrorByKv("Message insert failed", pbData.OperationID, "err", err.Error(), "chat", pbData.String())
+		if msgKey == msgFromMQ.MsgData.RecvID && msgFromMQ.MsgData.SessionType == constant.SingleChatType {
+			log.InfoByKv("msg_transfer msg persisting", msgFromMQ.OperationID)
+			if err = im_mysql_msg_model.InsertMessageToChatLog(msgFromMQ); err != nil {
+				log.ErrorByKv("Message insert failed", msgFromMQ.OperationID, "err", err.Error(), "msg", msgFromMQ.String())
 				return
 			}
-		} else if pbData.SessionType == constant.GroupChatType && msgKey == "0" {
-			pbData.RecvID = strings.Split(pbData.RecvID, " ")[1]
-			log.InfoByKv("msg_transfer chat persisting", pbData.OperationID)
-			if err = im_mysql_msg_model.InsertMessageToChatLog(pbData); err != nil {
-				log.ErrorByKv("Message insert failed", pbData.OperationID, "err", err.Error(), "chat", pbData.String())
+		} else if msgFromMQ.MsgData.SessionType == constant.GroupChatType && msgKey == msgFromMQ.MsgData.SendID {
+			log.InfoByKv("msg_transfer msg persisting", msgFromMQ.OperationID)
+			if err = im_mysql_msg_model.InsertMessageToChatLog(msgFromMQ); err != nil {
+				log.ErrorByKv("Message insert failed", msgFromMQ.OperationID, "err", err.Error(), "msg", msgFromMQ.String())
 				return
 			}
 		}
@@ -67,7 +65,7 @@ func (PersistentConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error {
 func (pc *PersistentConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
 	claim sarama.ConsumerGroupClaim) error {
 	for msg := range claim.Messages() {
-		log.InfoByKv("kafka get info to mysql", "", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "chat", string(msg.Value))
+		log.InfoByKv("kafka get info to mysql", "", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value))
 		pc.msgHandle[msg.Topic](msg.Value, string(msg.Key))
 		sess.MarkMessage(msg, "")
 	}

internal/push/jpush/push.go

@@ -1,9 +1,9 @@
 package push
 
 import (
-	"Open_IM/src/common/config"
-	"Open_IM/src/push/jpush/common"
-	"Open_IM/src/push/jpush/requestBody"
+	"Open_IM/internal/push/jpush/common"
+	"Open_IM/internal/push/jpush/requestBody"
+	"Open_IM/pkg/common/config"
 	"bytes"
 	"encoding/json"
 	"io/ioutil"
@@ -13,21 +13,24 @@ import (
 type JPushResp struct {
 }
 
-func JGAccountListPush(accounts []string, content, detailContent, platform string) ([]byte, error) {
+func JGAccountListPush(accounts []string, alert, detailContent, platform string) ([]byte, error) {
 
 	var pf requestBody.Platform
 	_ = pf.SetPlatform(platform)
 	var au requestBody.Audience
 	au.SetAlias(accounts)
 	var no requestBody.Notification
-	no.SetAlert(content)
+	no.SetAlert(alert, platform)
 	var me requestBody.Message
 	me.SetMsgContent(detailContent)
+	var o requestBody.Options
+	o.SetApnsProduction(false)
 	var po requestBody.PushObj
 	po.SetPlatform(&pf)
 	po.SetAudience(&au)
 	po.SetNotification(&no)
 	po.SetMessage(&me)
+	po.SetOptions(&o)
 
 	con, err := json.Marshal(po)
 	if err != nil {