v2.1.0

# Conflicts:
#	internal/api/manage/management_chat.go

.github/ISSUE_TEMPLATE/ISSUE_TEMPLATE.md

@@ -0,0 +1,37 @@
+---
+name: "\U0001F41E Bug"
+about: File a bug/issue
+title: "[BUG] <title>"
+labels: ''
+assignees: ''
+
+---
+
+<!--
+Note: Please search to see if an issue already exists for the bug you encountered.
+-->
+
+### Environment:
+<!-- linux? windows? or Mac?
+Example:
+- OS: Ubuntu 20.04 -->
+
+### Physical Memory Capacity:
+<!-- 8G or above is better -->
+
+### Docker Image:
+<!-- Did you pull the docker image before execute docker images -->
+
+### Code Version:
+<!-- Did you pull code from github? Make sure the code is up to date-->
+
+### Component installation:
+<!-- Has etcd, mysql, mongodb, redis or Kafka been installed on the server before Open-IM-Server deployment-->
+
+
+### Log File:
+<!-- view log file(logs/openIM.log) content. -->
+
+
+### screenshot:
+<!---->

.github/ISSUE_TEMPLATE/deployment-issues.md

@@ -0,0 +1,36 @@
+---
+name: Deployment issues
+about: Deployment issues
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+If you are deploying OpenIM for the first time
+
+
+
+```
+git clone https://github.com/OpenIMSDK/Open-IM-Server.git --recursive
+```
+
+screenshot here
+
+```
+cd Open-IM-Server/script ; chmod +x *.sh ; ./env_check.sh
+```
+
+screenshot here
+
+```
+cd .. ; docker-compose up -d
+```
+
+screenshot here
+
+```
+cd script ; ./docker_check_service.sh
+```
+
+screenshot here

.github/ISSUE_TEMPLATE/update-.md

@@ -0,0 +1,38 @@
+---
+name: 'update '
+about: update docker image
+title: update docker image
+labels: ''
+assignees: ''
+
+---
+
+```
+cd Open-IM-Server ; docker-compose down
+```
+
+screenshot here
+
+```
+git pull
+```
+
+screenshot here
+
+```
+docker-compose pull
+```
+
+screenshot here
+
+```
+chmod +x script/*.sh ; docker-compose up -d
+```
+
+screenshot here
+
+```
+cd script ; ./docker_check_service.sh
+```
+
+screenshot here

.gitignore

@@ -5,6 +5,8 @@ components
 logs
 out-test
 .github
+.idea
+
 
 deploy/open_im_demo
 deploy/open_im_api

README.md

@@ -1,4 +1,5 @@
 # Open-IM-Server 
+![avatar](https://github.com/OpenIMSDK/OpenIM-Docs/blob/main/docs/images/WechatIMG20.jpeg)
 
 ![avatar](https://github.com/OpenIMSDK/Open-IM-Server/blob/main/docs/open-im-logo.png)
 
@@ -92,6 +93,7 @@ All images are available at https://hub.docker.com/r/lyt1123/open_im_server
 4. Start docker-compose with one click(Docker automatically pulls all images)
 
    ```
+   cd Open-IM-Server
    docker-compose up -d
    ```
 
@@ -99,6 +101,7 @@ All images are available at https://hub.docker.com/r/lyt1123/open_im_server
 
    ```
    ./docker_check_service.sh 
+   ./check_all.sh
    ```
 
    ![OpenIMServersondockerpng](https://github.com/OpenIMSDK/Open-IM-Server/blob/main/docs/Open-IM-Servers-on-docker.png)

cmd/open_im_api/main.go

@@ -7,100 +7,201 @@ import (
 	"Open_IM/internal/api/friend"
 	"Open_IM/internal/api/group"
 	"Open_IM/internal/api/manage"
+	"Open_IM/internal/api/office"
+	"Open_IM/internal/api/organization"
 	apiThird "Open_IM/internal/api/third"
 	"Open_IM/internal/api/user"
+	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
 	"flag"
+	"fmt"
+	"io"
+	"os"
 	"strconv"
 
 	"github.com/gin-gonic/gin"
 	//"syscall"
+	"Open_IM/pkg/common/constant"
 )
 
 func main() {
+	log.NewPrivateLog(constant.LogFileName)
+	gin.SetMode(gin.ReleaseMode)
+	f, _ := os.Create("../logs/api.log")
+	gin.DefaultWriter = io.MultiWriter(f)
+	gin.SetMode(gin.DebugMode)
 	r := gin.Default()
 	r.Use(utils.CorsHandler())
+
+	log.Info("load  config: ", config.Config)
 	// user routing group, which handles user registration and login services
 	userRouterGroup := r.Group("/user")
 	{
-		userRouterGroup.POST("/update_user_info", user.UpdateUserInfo)
+		userRouterGroup.POST("/update_user_info", user.UpdateUserInfo) //1
-		userRouterGroup.POST("/get_user_info", user.GetUserInfo)
+		userRouterGroup.POST("/set_global_msg_recv_opt", user.SetGlobalRecvMessageOpt)
-		userRouterGroup.POST("/get_users_online_status", user.GetUsersOnlineStatus)
+		userRouterGroup.POST("/get_users_info", user.GetUsersInfo)                  //1
+		userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo)           //1
+		userRouterGroup.POST("/get_users_online_status", user.GetUsersOnlineStatus) //1
+		userRouterGroup.POST("/get_users_info_from_cache", user.GetUsersInfoFromCache)
+		userRouterGroup.POST("/get_user_friend_from_cache", user.GetFriendIDListFromCache)
+		userRouterGroup.POST("/get_black_list_from_cache", user.GetBlackIDListFromCache)
 	}
 	//friend routing group
 	friendRouterGroup := r.Group("/friend")
 	{
-		friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo)
+		//	friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo)
-		friendRouterGroup.POST("/add_friend", friend.AddFriend)
+		friendRouterGroup.POST("/add_friend", friend.AddFriend)                              //1
-		friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList)
+		friendRouterGroup.POST("/delete_friend", friend.DeleteFriend)                        //1
-		friendRouterGroup.POST("/get_self_apply_list", friend.GetSelfApplyList)
+		friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList)          //1
-		friendRouterGroup.POST("/get_friend_list", friend.GetFriendList)
+		friendRouterGroup.POST("/get_self_friend_apply_list", friend.GetSelfFriendApplyList) //1
-		friendRouterGroup.POST("/add_blacklist", friend.AddBlacklist)
+		friendRouterGroup.POST("/get_friend_list", friend.GetFriendList)                     //1
-		friendRouterGroup.POST("/get_blacklist", friend.GetBlacklist)
+		friendRouterGroup.POST("/add_friend_response", friend.AddFriendResponse)             //1
-		friendRouterGroup.POST("/remove_blacklist", friend.RemoveBlacklist)
+		friendRouterGroup.POST("/set_friend_remark", friend.SetFriendRemark)                 //1
-		friendRouterGroup.POST("/delete_friend", friend.DeleteFriend)
+
-		friendRouterGroup.POST("/add_friend_response", friend.AddFriendResponse)
+		friendRouterGroup.POST("/add_black", friend.AddBlack)          //1
-		friendRouterGroup.POST("/set_friend_comment", friend.SetFriendComment)
+		friendRouterGroup.POST("/get_black_list", friend.GetBlacklist) //1
-		friendRouterGroup.POST("/is_friend", friend.IsFriend)
+		friendRouterGroup.POST("/remove_black", friend.RemoveBlack)    //1
-		friendRouterGroup.POST("/import_friend", friend.ImportFriend)
+
+		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)
+		groupRouterGroup.POST("/create_group", group.CreateGroup)                                   //1
-		groupRouterGroup.POST("/set_group_info", group.SetGroupInfo)
+		groupRouterGroup.POST("/set_group_info", group.SetGroupInfo)                                //1
-		groupRouterGroup.POST("join_group", group.JoinGroup)
+		groupRouterGroup.POST("/join_group", group.JoinGroup)                                       //1
-		groupRouterGroup.POST("/quit_group", group.QuitGroup)
+		groupRouterGroup.POST("/quit_group", group.QuitGroup)                                       //1
-		groupRouterGroup.POST("/group_application_response", group.ApplicationGroupResponse)
+		groupRouterGroup.POST("/group_application_response", group.ApplicationGroupResponse)        //1
-		groupRouterGroup.POST("/transfer_group", group.TransferGroupOwner)
+		groupRouterGroup.POST("/transfer_group", group.TransferGroupOwner)                          //1
-		groupRouterGroup.POST("/get_group_applicationList", group.GetGroupApplicationList)
+		groupRouterGroup.POST("/get_recv_group_applicationList", group.GetRecvGroupApplicationList) //1
-		groupRouterGroup.POST("/get_groups_info", group.GetGroupsInfo)
+		groupRouterGroup.POST("/get_user_req_group_applicationList", group.GetUserReqGroupApplicationList)
-		groupRouterGroup.POST("/kick_group", group.KickGroupMember)
+		groupRouterGroup.POST("/get_groups_info", group.GetGroupsInfo)                   //1
-		groupRouterGroup.POST("/get_group_member_list", group.GetGroupMemberList)
+		groupRouterGroup.POST("/kick_group", group.KickGroupMember)                      //1
-		groupRouterGroup.POST("/get_group_all_member_list", group.GetGroupAllMember)
+		groupRouterGroup.POST("/get_group_member_list", group.GetGroupMemberList)        //no use
-		groupRouterGroup.POST("/get_group_members_info", group.GetGroupMembersInfo)
+		groupRouterGroup.POST("/get_group_all_member_list", group.GetGroupAllMemberList) //1
-		groupRouterGroup.POST("/invite_user_to_group", group.InviteUserToGroup)
+		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)
+		groupRouterGroup.POST("/dismiss_group", group.DismissGroup) //
+		groupRouterGroup.POST("/mute_group_member", group.MuteGroupMember)
+		groupRouterGroup.POST("/cancel_mute_group_member", group.CancelMuteGroupMember) //MuteGroup
+		groupRouterGroup.POST("/mute_group", group.MuteGroup)
+		groupRouterGroup.POST("/cancel_mute_group", group.CancelMuteGroup)
+		groupRouterGroup.POST("/set_group_member_nickname", group.SetGroupMemberNickname)
+		groupRouterGroup.POST("/set_group_member_info", group.SetGroupMemberInfo)
+	}
+	superGroupRouterGroup := r.Group("/super_group")
+	{
+		superGroupRouterGroup.POST("/get_joined_group_list", group.GetJoinedSuperGroupList)
+		superGroupRouterGroup.POST("/get_groups_info", group.GetSuperGroupsInfo)
 	}
 	//certificate
 	authRouterGroup := r.Group("/auth")
 	{
-		authRouterGroup.POST("/user_register", apiAuth.UserRegister)
+		authRouterGroup.POST("/user_register", apiAuth.UserRegister) //1
-		authRouterGroup.POST("/user_token", apiAuth.UserToken)
+		authRouterGroup.POST("/user_token", apiAuth.UserToken)       //1
+		authRouterGroup.POST("/parse_token", apiAuth.ParseToken)     //1
+		authRouterGroup.POST("/force_logout", apiAuth.ForceLogout)   //1
 	}
 	//Third service
 	thirdGroup := r.Group("/third")
 	{
 		thirdGroup.POST("/tencent_cloud_storage_credential", apiThird.TencentCloudStorageCredential)
+		thirdGroup.POST("/ali_oss_credential", apiThird.AliOSSCredential)
+		thirdGroup.POST("/minio_storage_credential", apiThird.MinioStorageCredential)
+		thirdGroup.POST("/minio_upload", apiThird.MinioUploadFile)
+		thirdGroup.POST("/upload_update_app", apiThird.UploadUpdateApp)
+		thirdGroup.POST("/get_download_url", apiThird.GetDownloadURL)
+		thirdGroup.POST("/get_rtc_invitation_info", apiThird.GetRTCInvitationInfo)
+		thirdGroup.POST("/get_rtc_invitation_start_app", apiThird.GetRTCInvitationInfoStartApp)
 	}
 	//Message
-	chatGroup := r.Group("/chat")
+	chatGroup := r.Group("/msg")
 	{
-		chatGroup.POST("/newest_seq", apiChat.UserGetSeq)
+		chatGroup.POST("/newest_seq", apiChat.GetSeq)
-		chatGroup.POST("/pull_msg", apiChat.UserPullMsg)
+		chatGroup.POST("/send_msg", apiChat.SendMsg)
-		chatGroup.POST("/send_msg", apiChat.UserSendMsg)
+		chatGroup.POST("/pull_msg_by_seq", apiChat.PullMsgBySeqList)
-		chatGroup.POST("/pull_msg_by_seq", apiChat.UserPullMsgBySeqList)
+		chatGroup.POST("/del_msg", apiChat.DelMsg)
+		chatGroup.POST("/clear_msg", apiChat.ClearMsg)
 	}
 	//Manager
 	managementGroup := r.Group("/manager")
 	{
-		managementGroup.POST("/delete_user", manage.DeleteUser)
+		managementGroup.POST("/delete_user", manage.DeleteUser) //1
 		managementGroup.POST("/send_msg", manage.ManagementSendMsg)
-		managementGroup.POST("/get_all_users_uid", manage.GetAllUsersUid)
+		managementGroup.POST("/batch_send_msg", manage.ManagementBatchSendMsg)
-		managementGroup.POST("/account_check", manage.AccountCheck)
+		managementGroup.POST("/get_all_users_uid", manage.GetAllUsersUid)             //1
-		managementGroup.POST("/get_users_online_status", manage.GetUsersOnlineStatus)
+		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)
+		conversationGroup.POST("/modify_conversation_field", conversation.ModifyConversationField)
+	}
+	// office
+	officeGroup := r.Group("/office")
 	{
-		conversationGroup.POST("/set_receive_message_opt", conversation.SetReceiveMessageOpt)
+		officeGroup.POST("/get_user_tags", office.GetUserTags)
-		conversationGroup.POST("/get_receive_message_opt", conversation.GetReceiveMessageOpt)
+		officeGroup.POST("/get_user_tag_by_id", office.GetUserTagByID)
-		conversationGroup.POST("/get_all_conversation_message_opt", conversation.GetAllConversationMessageOpt)
+		officeGroup.POST("/create_tag", office.CreateTag)
+		officeGroup.POST("/delete_tag", office.DeleteTag)
+		officeGroup.POST("/set_tag", office.SetTag)
+		officeGroup.POST("/send_msg_to_tag", office.SendMsg2Tag)
+		officeGroup.POST("/get_send_tag_log", office.GetTagSendLogs)
+
+		officeGroup.POST("/create_one_work_moment", office.CreateOneWorkMoment)
+		officeGroup.POST("/delete_one_work_moment", office.DeleteOneWorkMoment)
+		officeGroup.POST("/like_one_work_moment", office.LikeOneWorkMoment)
+		officeGroup.POST("/comment_one_work_moment", office.CommentOneWorkMoment)
+		officeGroup.POST("/get_work_moment_by_id", office.GetWorkMomentByID)
+		officeGroup.POST("/get_user_work_moments", office.GetUserWorkMoments)
+		officeGroup.POST("/get_user_friend_work_moments", office.GetUserFriendWorkMoments)
+		officeGroup.POST("/set_user_work_moments_level", office.SetUserWorkMomentsLevel)
+		officeGroup.POST("/delete_comment", office.DeleteComment)
 	}
 
-	log.NewPrivateLog("api")
+	organizationGroup := r.Group("/organization")
-	ginPort := flag.Int("port", 10000, "get ginServerPort from cmd,default 10000 as port")
+	{
+		organizationGroup.POST("/create_department", organization.CreateDepartment)
+		organizationGroup.POST("/update_department", organization.UpdateDepartment)
+		organizationGroup.POST("/get_sub_department", organization.GetSubDepartment)
+		organizationGroup.POST("/delete_department", organization.DeleteDepartment)
+		organizationGroup.POST("/get_all_department", organization.GetAllDepartment)
+
+		organizationGroup.POST("/create_organization_user", organization.CreateOrganizationUser)
+		organizationGroup.POST("/update_organization_user", organization.UpdateOrganizationUser)
+		organizationGroup.POST("/delete_organization_user", organization.DeleteOrganizationUser)
+
+		organizationGroup.POST("/create_department_member", organization.CreateDepartmentMember)
+		organizationGroup.POST("/get_user_in_department", organization.GetUserInDepartment)
+		organizationGroup.POST("/update_user_in_department", organization.UpdateUserInDepartment)
+
+		organizationGroup.POST("/get_department_member", organization.GetDepartmentMember)
+		organizationGroup.POST("/delete_user_in_department", organization.DeleteUserInDepartment)
+
+	}
+
+	go apiThird.MinioInit()
+	defaultPorts := config.Config.Api.GinPort
+	ginPort := flag.Int("port", defaultPorts[0], "get ginServerPort from cmd,default 10002 as port")
 	flag.Parse()
-	r.Run(":" + strconv.Itoa(*ginPort))
+	address := "0.0.0.0:" + strconv.Itoa(*ginPort)
+	if config.Config.Api.ListenIP != "" {
+		address = config.Config.Api.ListenIP + ":" + strconv.Itoa(*ginPort)
+	}
+	address = config.Config.Api.ListenIP + ":" + strconv.Itoa(*ginPort)
+	fmt.Println("start api server, address: ", address)
+	err := r.Run(address)
+	if err != nil {
+		log.Error("", "run failed ", *ginPort, err.Error())
+	}
 }

cmd/open_im_cms_api/Makefile

@@ -1,8 +1,9 @@
 .PHONY: all build run gotool install clean help
 
-BINARY_NAME=open_im_timer_task
+BINARY_NAME=open_im_cms_api
 BIN_DIR=../../bin/
 
+
 all: gotool build
 
 build:
@@ -22,4 +23,3 @@ install:
 clean:
 	@if [ -f ${BINARY_NAME} ] ; then rm ${BINARY_NAME} ; fi
 
-

cmd/open_im_cms_api/main.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"Open_IM/internal/cms_api"
+	"Open_IM/pkg/utils"
+	"flag"
+	"fmt"
+	"strconv"
+
+	"Open_IM/pkg/common/config"
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+	gin.SetMode(gin.ReleaseMode)
+	router := cms_api.NewGinRouter()
+	router.Use(utils.CorsHandler())
+	defaultPorts := config.Config.CmsApi.GinPort
+	ginPort := flag.Int("port", defaultPorts[0], "get ginServerPort from cmd,default 10006 as port")
+	flag.Parse()
+	address := "0.0.0.0:" + strconv.Itoa(*ginPort)
+	if config.Config.Api.ListenIP != "" {
+		address = config.Config.Api.ListenIP + ":" + strconv.Itoa(*ginPort)
+	}
+	address = config.Config.CmsApi.ListenIP + ":" + strconv.Itoa(*ginPort)
+	fmt.Println("start cms api server, address: ", address)
+	router.Run(address)
+}

cmd/open_im_demo/main.go

@@ -2,28 +2,48 @@ package main
 
 import (
 	"Open_IM/internal/demo/register"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/utils"
 	"flag"
+	"fmt"
+	"io"
+	"os"
 	"strconv"
 
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
 	"github.com/gin-gonic/gin"
 )
 
 func main() {
+	log.NewPrivateLog(constant.LogFileName)
+	gin.SetMode(gin.ReleaseMode)
+	f, _ := os.Create("../logs/api.log")
+	gin.DefaultWriter = io.MultiWriter(f)
 
 	r := gin.Default()
 	r.Use(utils.CorsHandler())
 
-	authRouterGroup := r.Group("/auth")
+	authRouterGroup := r.Group("/demo")
 	{
 		authRouterGroup.POST("/code", register.SendVerificationCode)
 		authRouterGroup.POST("/verify", register.Verify)
 		authRouterGroup.POST("/password", register.SetPassword)
 		authRouterGroup.POST("/login", register.Login)
+		authRouterGroup.POST("/reset_password", register.ResetPassword)
 	}
-	log.NewPrivateLog("demo")
+	defaultPorts := config.Config.Demo.Port
-	ginPort := flag.Int("port", 42233, "get ginServerPort from cmd,default 42233 as port")
+	ginPort := flag.Int("port", defaultPorts[0], "get ginServerPort from cmd,default 42233 as port")
 	flag.Parse()
-	r.Run(":" + strconv.Itoa(*ginPort))
+	fmt.Println("start demo api server, port: ", *ginPort)
+	address := "0.0.0.0:" + strconv.Itoa(*ginPort)
+	if config.Config.Api.ListenIP != "" {
+		address = config.Config.Api.ListenIP + ":" + strconv.Itoa(*ginPort)
+	}
+	address = config.Config.CmsApi.ListenIP + ":" + strconv.Itoa(*ginPort)
+	fmt.Println("start demo api server address: ", address)
+	err := r.Run(address)
+	if err != nil {
+		log.Error("", "run failed ", *ginPort, err.Error())
+	}
 }

cmd/open_im_msg_gateway/main.go

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

cmd/open_im_msg_transfer/main.go

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

cmd/open_im_push/main.go

@@ -2,15 +2,22 @@ package main
 
 import (
 	"Open_IM/internal/push/logic"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/log"
 	"flag"
+	"fmt"
 	"sync"
 )
 
 func main() {
-	rpcPort := flag.Int("port", 10700, "rpc listening port")
+	defaultPorts := config.Config.RpcPort.OpenImPushPort
+	rpcPort := flag.Int("port", defaultPorts[0], "rpc listening port")
 	flag.Parse()
 	var wg sync.WaitGroup
 	wg.Add(1)
+	log.NewPrivateLog(constant.LogFileName)
+	fmt.Println("start push rpc server, port: ", *rpcPort)
 	logic.Init(*rpcPort)
 	logic.Run()
 	wg.Wait()

cmd/open_im_timer_task/main.go

@@ -1,65 +0,0 @@
-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.SelectAllUID()
-		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,17 @@
+package main
+
+import (
+	rpcMessageCMS "Open_IM/internal/rpc/admin_cms"
+	"Open_IM/pkg/common/config"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	defaultPorts := config.Config.RpcPort.OpenImAdminCmsPort
+	rpcPort := flag.Int("port", defaultPorts[0], "rpc listening port")
+	flag.Parse()
+	fmt.Println("start cms rpc server, port: ", *rpcPort)
+	rpcServer := rpcMessageCMS.NewAdminCMSServer(*rpcPort)
+	rpcServer.Run()
+}

cmd/rpc/open_im_auth/main.go

@@ -2,12 +2,17 @@ package main
 
 import (
 	rpcAuth "Open_IM/internal/rpc/auth"
+	"Open_IM/pkg/common/config"
 	"flag"
+	"fmt"
 )
 
 func main() {
-	rpcPort := flag.Int("port", 10600, "RpcToken default listen port 10800")
+	defaultPorts := config.Config.RpcPort.OpenImAuthPort
+	rpcPort := flag.Int("port", defaultPorts[0], "RpcToken default listen port 10800")
 	flag.Parse()
+	fmt.Println("start auth rpc server, port: ", *rpcPort)
 	rpcServer := rpcAuth.NewRpcAuthServer(*rpcPort)
 	rpcServer.Run()
+
 }

cmd/rpc/open_im_cache/Makefile

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

cmd/rpc/open_im_cache/main.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	rpcCache "Open_IM/internal/rpc/cache"
+	"Open_IM/pkg/common/config"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	defaultPorts := config.Config.RpcPort.OpenImCachePort
+	rpcPort := flag.Int("port", defaultPorts[0], "RpcToken default listen port 10800")
+	flag.Parse()
+	fmt.Println("start auth rpc server, port: ", *rpcPort)
+	rpcServer := rpcCache.NewCacheServer(*rpcPort)
+	rpcServer.Run()
+
+}

cmd/rpc/open_im_conversation/Makefile

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

cmd/rpc/open_im_conversation/main.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	rpcConversation "Open_IM/internal/rpc/conversation"
+	"Open_IM/pkg/common/config"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	defaultPorts := config.Config.RpcPort.OpenImConversationPort
+	rpcPort := flag.Int("port", defaultPorts[0], "RpcConversation default listen port 11300")
+	flag.Parse()
+	fmt.Println("start conversation rpc server, port: ", *rpcPort)
+	rpcServer := rpcConversation.NewRpcConversationServer(*rpcPort)
+	rpcServer.Run()
+
+}

cmd/rpc/open_im_friend/main.go

@@ -2,13 +2,16 @@ package main
 
 import (
 	"Open_IM/internal/rpc/friend"
+	"Open_IM/pkg/common/config"
 	"flag"
+	"fmt"
 )
 
 func main() {
-
+	defaultPorts := config.Config.RpcPort.OpenImFriendPort
-	rpcPort := flag.Int("port", 10200, "get RpcFriendPort from cmd,default 12000 as port")
+	rpcPort := flag.Int("port", defaultPorts[0], "get RpcFriendPort from cmd,default 12000 as port")
 	flag.Parse()
+	fmt.Println("start friend rpc server, port: ", *rpcPort)
 	rpcServer := friend.NewFriendServer(*rpcPort)
 	rpcServer.Run()
 }

cmd/rpc/open_im_group/main.go

@@ -2,12 +2,16 @@ package main
 
 import (
 	"Open_IM/internal/rpc/group"
+	"Open_IM/pkg/common/config"
 	"flag"
+	"fmt"
 )
 
 func main() {
-	rpcPort := flag.Int("port", 10500, "get RpcGroupPort from cmd,default 16000 as port")
+	defaultPorts := config.Config.RpcPort.OpenImGroupPort
+	rpcPort := flag.Int("port", defaultPorts[0], "get RpcGroupPort from cmd,default 16000 as port")
 	flag.Parse()
+	fmt.Println("start group rpc server, port: ", *rpcPort)
 	rpcServer := group.NewGroupServer(*rpcPort)
 	rpcServer.Run()
 }

cmd/rpc/open_im_message_cms/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,17 @@
+package main
+
+import (
+	rpcMessageCMS "Open_IM/internal/rpc/message_cms"
+	"Open_IM/pkg/common/config"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	defaultPorts := config.Config.RpcPort.OpenImMessageCmsPort[0]
+	rpcPort := flag.Int("port", defaultPorts, "rpc listening port")
+	flag.Parse()
+	fmt.Println("start msg cms rpc server, port: ", *rpcPort)
+	rpcServer := rpcMessageCMS.NewMessageCMSServer(*rpcPort)
+	rpcServer.Run()
+}

cmd/rpc/open_im_msg/main.go

@@ -1,13 +1,17 @@
 package main
 
 import (
-	rpcChat "Open_IM/internal/rpc/chat"
+	rpcChat "Open_IM/internal/rpc/msg"
+	"Open_IM/pkg/common/config"
 	"flag"
+	"fmt"
 )
 
 func main() {
-	rpcPort := flag.Int("port", 10300, "rpc listening port")
+	defaultPorts := config.Config.RpcPort.OpenImMessagePort
+	rpcPort := flag.Int("port", defaultPorts[0], "rpc listening port")
 	flag.Parse()
+	fmt.Println("start msg rpc server, port: ", *rpcPort)
 	rpcServer := rpcChat.NewRpcChatServer(*rpcPort)
 	rpcServer.Run()
 }

cmd/rpc/open_im_office/Makefile

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

cmd/rpc/open_im_office/main.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	rpc "Open_IM/internal/rpc/office"
+	"Open_IM/pkg/common/config"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	defaultPorts := config.Config.RpcPort.OpenImOfficePort
+	rpcPort := flag.Int("port", defaultPorts[0], "rpc listening port")
+	flag.Parse()
+	fmt.Println("start office rpc server, port: ", *rpcPort)
+	rpcServer := rpc.NewOfficeServer(*rpcPort)
+	rpcServer.Run()
+}

cmd/rpc/open_im_organization/Makefile

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

cmd/rpc/open_im_organization/main.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"Open_IM/internal/rpc/organization"
+	"Open_IM/pkg/common/config"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	defaultPorts := config.Config.RpcPort.OpenImOrganizationPort
+	rpcPort := flag.Int("port", defaultPorts[0], "get RpcOrganizationPort from cmd,default 11200 as port")
+	flag.Parse()
+	fmt.Println("start organization rpc server, port: ", *rpcPort)
+	rpcServer := organization.NewServer(*rpcPort)
+	rpcServer.Run()
+}

cmd/rpc/open_im_statistics/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,17 @@
+package main
+
+import (
+	"Open_IM/internal/rpc/statistics"
+	"Open_IM/pkg/common/config"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	defaultPorts := config.Config.RpcPort.OpenImStatisticsPort
+	rpcPort := flag.Int("port", defaultPorts[0], "rpc listening port")
+	flag.Parse()
+	fmt.Println("start statistics rpc server, port: ", *rpcPort)
+	rpcServer := statistics.NewStatisticsServer(*rpcPort)
+	rpcServer.Run()
+}

cmd/rpc/open_im_user/main.go

@@ -2,12 +2,16 @@ package main
 
 import (
 	"Open_IM/internal/rpc/user"
+	"Open_IM/pkg/common/config"
 	"flag"
+	"fmt"
 )
 
 func main() {
-	rpcPort := flag.Int("port", 10100, "rpc listening port")
+	defaultPorts := config.Config.RpcPort.OpenImUserPort
+	rpcPort := flag.Int("port", defaultPorts[0], "rpc listening port")
 	flag.Parse()
+	fmt.Println("start user rpc server, port: ", *rpcPort)
 	rpcServer := user.NewUserServer(*rpcPort)
 	rpcServer.Run()
 }

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,50 +1,62 @@
 # The class cannot be named by Pascal or camel case.
+# 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
+serverversion: 2.0.0
 #---------------Infrastructure configuration---------------------#
 etcd:
-  etcdSchema: openIM
+  etcdSchema: openim  #默认即可
-  etcdAddr: [ 127.0.0.1:2379 ]
+  etcdAddr: [ 127.0.0.1:2379 ] #单机部署时，默认即可
+
+k8sMod: false #开启k8s模式 使用pod里面环境变量请求services调用服务 而并非etcd
 
 mysql:
-  dbMysqlAddress: [ 127.0.0.1:13306 ]
+  dbMysqlAddress: [ 127.0.0.1:13306 ] #mysql地址 目前仅支持单机，默认即可
-  dbMysqlUserName: root
+  dbMysqlUserName: root #mysql用户名，建议修改
-  dbMysqlPassword: openIM
+  dbMysqlPassword: openIM # mysql密码，建议修改
-  dbMysqlDatabaseName: openIM
+  dbMysqlDatabaseName: openIM_v2 #默认即可
-  dbTableName: eMsg
+  dbTableName: eMsg #默认即可
   dbMsgTableNum: 1
   dbMaxOpenConns: 20
   dbMaxIdleConns: 10
   dbMaxLifeTime: 120
 
 mongo:
-  dbAddress: [ 127.0.0.1:37017 ]
+  dbUri: ""#当dbUri值不为空则直接使用该值
+  dbAddress: 127.0.0.1:37017  #单机时为mongo地址，使用分片集群时，为mongos地址 默认即可
   dbDirect: false
-  dbTimeout: 10
+  dbTimeout: 60
-  dbDatabase: openIM
+  dbDatabase: openIM  #mongo db 默认即可
   dbSource: admin
-  dbUserName:
+  dbUserName: #mongo用户名，建议先不设置
-  dbPassword:
+  dbPassword: #mongo密码，建议先不设置
-  dbMaxPoolSize: 20
+  dbMaxPoolSize: 100
-  dbRetainChatRecords: 7
+  dbRetainChatRecords: 3650 #mongo保存离线消息时间（天），根据需求修改
 
 redis:
-  dbAddress: 127.0.0.1:16379
+  dbAddress: [ 127.0.0.1:16379 ] #redis地址 单机时，填写一个地址即可，使用redis集群时候，填写集群中多个节点地址（主从地址都可以填写，增加容灾能力），默认即可
   dbMaxIdle: 128
   dbMaxActive: 0
   dbIdleTimeout: 120
-  dbPassWord: openIM
+  dbPassWord: openIM #redis密码 建议修改
+  enableCluster: false #如果外部redis以集群方式启动，需要打开此开关
 
 kafka:
   ws2mschat:
-    addr: [ 127.0.0.1:9092 ]
+    addr: [ 127.0.0.1:9092 ] #kafka配置，默认即可
     topic: "ws2ms_chat"
+  ws2mschatoffline:
+    addr: [ 127.0.0.1:9092 ] #kafka配置，默认即可
+    topic: "ws2ms_chat_offline"
+  msgtomongo:
+    addr: [ 127.0.0.1:9092 ] #kafka配置，默认即可
+    topic: "msg_to_mongo"
   ms2pschat:
-    addr: [ 127.0.0.1:9092 ]
+    addr: [ 127.0.0.1:9092 ] #kafka配置，默认即可
     topic: "ms2ps_chat"
   consumergroupid:
-    msgToMongo: mongo
+    msgToTransfer: mongo
+    msgToMongo: mongo_ex
     msgToMySql: mysql
     msgToPush: push
 
@@ -55,11 +67,18 @@ 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
+#如果是单机模式，用0.0.0.0或者不填，默认即可
 serverip: 0.0.0.0
 
+rpcRegisterIP: 127.0.0.1
+listenIP: 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
@@ -67,29 +86,65 @@ endpoints:
   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
+  rpc_office: openim_rpc_office
 
 api:
-  openImApiPort: [ 10000 ]
+  openImApiPort: [ 10002 ] #api服务端口，默认即可，需要开放此端口或做nginx转发
+  listenIP: 0.0.0.0
+cmsapi:
+  openImCmsApiPort: [ 10006 ] #管理后台api服务端口，默认即可，需要开放此端口或做nginx转发
+  listenIP: 0.0.0.0
 sdk:
-  openImSdkWsPort: [ 30000 ]
+  openImSdkWsPort: [ 10003 ] #jssdk服务端口，默认即可，项目中使用jssdk才需开放此端口或做nginx转发
-
+  dataDir: [ ../db/sdk/ ]
-credential:
+#对象存储服务，以下配置二选一，目前支持两种，腾讯云和minio，二者配置好其中一种即可（如果使用minio参考https://doc.rentsoft.cn/#/qa/minio搭建minio服务器）
+credential: #腾讯cos，发送图片、视频、文件时需要，请自行申请后替换，必须修改
   tencent:
     appID: 1302656840
     region: ap-chengdu
     bucket: echat-1302656840
-    secretID: AKIDGNYVChzIQinu7QEgtNp0hnNgqcV8vZTC
+    secretID: AKIDGNYVChzIQinu7QEgtNp0hnNgqcV8vZTC1
-    secretKey: kz15vW83qM6dBUWIq681eBZA0c0vlIbe
+    secretKey: kz15vW83qM6dBUWIq681eBZA0c0vlIbe1
+  minio: #MinIO 发送图片、视频、文件时需要，请自行申请后替换，必须修改。 客户端初始化InitSDK，中 object_storage参数为minio
+    bucket: openim # 存储内容桶
+    appBucket: app # 存储app的桶
+    location: us-east-1
+    endpoint: http://127.0.0.1:10005 #minio外网ip 这个ip是给客户端访问的
+    endpointInner: http://127.0.0.1:10005 #minio内网地址 如果im server 可以通过内网访问到 minio就可以填写
+    endpointInnerEnable: true #是否启用minio内网地址 启用可以让桶初始化，IM server连接minio走内网地址访问
+    accessKeyID: user12345
+    secretAccessKey: key12345
+  ali: # ali oss
+    regionID: "oss-cn-beijing"
+    accessKeyID: ""
+    accessKeySecret: ""
+    stsEndpoint: "sts.cn-beijing.aliyun.com"
+    ossEndpoint: "oss-cn-beijing.aliyuncs.com"
+    bucket: "bucket1"
+    finalHost: "http://bucket1.oss-cn-beijing.aliyuncs.com"
+    stsDurationSeconds: 3600
+    OssRoleArn: "acs:ram::xxx:role/xxx"
 
 
-rpcport:
+
-  openImUserPort: [ 10100 ]
+rpcport: #rpc服务端口 默认即可
-  openImFriendPort: [ 10200 ]
+  openImUserPort: [ 10110 ]
-  openImOfflineMessagePort: [ 10300]
+  openImFriendPort: [ 10120 ]
-  openImOnlineRelayPort: [ 10400 ]
+  openImMessagePort: [ 10130 ]
-  openImGroupPort: [ 10500  ]
+  openImMessageGatewayPort: [ 10140 ]
-  openImAuthPort: [ 10600 ]
+  openImGroupPort: [ 10150 ]
-  openImPushPort: [ 10700 ]
+  openImAuthPort: [ 10160 ]
+  openImPushPort: [ 10170 ]
+  openImStatisticsPort: [ 10180 ]
+  openImMessageCmsPort: [ 10190 ]
+  openImAdminCmsPort: [ 10200 ]
+  openImOfficePort: [ 10210 ]
+  openImOrganizationPort: [ 10220 ]
+  openImConversationPort: [ 10230 ]
+  openImCachePort: [10240]
   c2c:
     callbackBeforeSendMsg:
       switch: false
@@ -100,7 +155,7 @@ rpcport:
     stateChange:
       switch: false
 
-rpcregistername:
+rpcregistername: #rpc注册服务名，默认即可
   openImUserName: User
   openImFriendName: Friend
   openImOfflineMessageName: OfflineMessage
@@ -108,85 +163,547 @@ rpcregistername:
   openImOnlineMessageRelayName: OnlineMessageRelay
   openImGroupName: Group
   openImAuthName: Auth
-
+  openImStatisticsName: Statistics
+  openImMessageCMSName: MessageCMS
+  openImAdminCMSName: AdminCMS
+  openImOfficeName: Office
+  openImOrganizationName: Organization
+  openImConversationName: Conversation
+  openImCacheName: Cache
+  openImRealTimeCommName: RealTimeComm
 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: [ 10001 ] # ws服务端口，默认即可，要开放此端口或做nginx转发
   websocketMaxConnNum: 10000
   websocketMaxMsgLen: 4096
   websocketTimeOut: 10
 
+## 推送只能开启一个 enable代表开启
 push:
-  tpns:
+  tpns: #腾讯推送，暂未测试 暂不要使用
     ios:
       accessID: 1600018281
       secretKey: 3cd68a77a95b89e5089a1aca523f318f
     android:
       accessID: 111
       secretKey: 111
-  jpns:
+    enable: false
+  jpns: #极光推送 在极光后台申请后，修改以下四项，必须修改
     appKey: cf47465a368f24c659608e7e
     masterSecret: 02204efe3f3832947a236ee5
     pushUrl: "https://api.jpush.cn/v3/push"
     pushIntent: "intent:#Intent;component=io.openim.app.enterprisechat/io.openim.app.enterprisechat.MainActivity;end"
+    enable: true
+  getui:  #个推推送，暂未测试 暂不要使用
+    pushUrl: "https://restapi.getui.com/v2/$appId"
+    masterSecret: ""
+    appKey: ""
+    intent: ""
+    enable: false
+
+
+
 manager:
-  appManagerUid: ["openIM123456","openIM654321"]
+  #app管理员userID和对应的secret  建议修改。 用于管理后台登录，也可以用户管理后台对应的api
-  secrets: ["openIM1","openIM2"]
+  appManagerUid: [ "openIM123456","openIM654321", "openIM333", "openIMAdmin"]
+  secrets: [ "openIM1","openIM2", "openIM333", "openIMAdmin"]
+  appSysNotificationName: "系统通知"
 
 secret: tuoyun
-
+# 多端互踢策略
+# 1：多平台登录：Android、iOS、Windows、Mac 每种平台只能一个在线，web端可以多个同时在线
 multiloginpolicy: 1
 
+#chat log insert to db
+chatpersistencemysql: true
+#可靠性存储
+reliablestorage: false
+#消息缓存时间
+msgCacheTimeout: 86400
+#群聊已读开启
+groupMessageHasReadReceiptEnable: true
+#单聊已读开启
+singleMessageHasReadReceiptEnable: true
+
 #token config
 tokenpolicy:
-  accessSecret: "open_im_server"
+  accessSecret: "open_im_server" #token生成相关，默认即可
   # Token effective time day as a unit
-  accessExpire: 7
+  accessExpire: 3650 #token过期时间（天） 默认即可
+messageverify:
+  friendVerify: false
 
-messagecallback:
+#  c2c:
-  callbackUrl: "http://www.xxx.com/msg/judge"
+#    callbackBeforeSendMsg:
-  #TimeOut use second as unit
+#      switch: false
-  callbackTimeOut: 10
+#      timeoutStrategy: 1 #1:send
-  c2c:
+#    callbackAfterSendMsg:
-    callbackBeforeSendMsg:
+#      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
+  callbackUserOnline:
+    enable: false
+    callbackTimeOut: 2
+  callbackUserOffline:
+    enable: false
+    callbackTimeOut: 2
+  callbackOfflinePush:
+    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
-      timeoutStrategy: 1 #1:send
+      title: "groupInfoSet title"
-    callbackAfterSendMsg:
+      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
-  state:
+      title: "joinGroupApplication title"
-    stateChange:
+      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"
+
+
+  groupMuted:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "groupMuted title"
+      desc: "groupMuted desc"
+      ext: "groupMuted ext"
+    defaultTips:
+      tips: "group Muted"
+
+  groupCancelMuted:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "groupCancelMuted title"
+      desc: "groupCancelMuted desc"
+      ext: "groupCancelMuted ext"
+    defaultTips:
+      tips: "group Cancel Muted"
+
+
+  groupMemberMuted:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "groupMemberMuted title"
+      desc: "groupMemberMuted desc"
+      ext: "groupMemberMuted ext"
+    defaultTips:
+      tips: "group Member Muted"
+
+  groupMemberCancelMuted:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: false
+      title: "groupMemberCancelMuted title"
+      desc: "groupMemberCancelMuted desc"
+      ext: "groupMemberCancelMuted ext"
+    defaultTips:
+      tips: "group Member Cancel Muted"
+
+  groupMemberInfoSet:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: false
+      title: "groupMemberInfoSet title"
+      desc: "groupMemberInfoSet desc"
+      ext: "groupMemberInfoSet ext"
+    defaultTips:
+      tips: "group member info set"
+
+
+  organizationChanged:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: false
+      title: "organizationChanged title"
+      desc: "organizationChanged desc"
+      ext: "organizationChanged ext"
+    defaultTips:
+      tips: "organization changed"
+
+
+
+  #############################friend#################################
+
+  friendApplicationAdded:
+    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"
+
+  conversationSetPrivate:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+    offlinePush:
+      switch: true
+      title: "burn after reading"
+      desc: "burn after reading"
+      ext: "burn after reading"
+    defaultTips:
+      openTips: "burn after reading was opened"
+      closeTips: "burn after reading was closed"
+
+  ###################workMoments################
+  workMomentsNotification:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: true
+      offlinePush:
+        switch: true
+        title: "burn after reading"
+        desc: "burn after reading"
+        ext: "burn after reading"
+      defaultTips:
+        openTips: "burn after reading was opened"
+        closeTips: "burn after reading was closed"
+
+  ###################organization################
+  joinDepartmentNotification:
+    conversation:
+      reliabilityLevel: 3
+      unreadCount: true
+      offlinePush:
+        switch: false
+        title: "welcome user join department"
+        desc: "welcome user join department"
+        ext: "welcome user join department"
+      defaultTips:
+        tips: "welcome user join department"
 
 #---------------demo configuration---------------------#
 #The following configuration items are applied to openIM Demo configuration
+#是否启动demo，如果自身没有账号体系，设置为true
 demoswitch: true
 demo:
-  openImDemoPort: [ 42233 ]
+  listenIP: 0.0.0.0
-  alismsverify:
+  #demo对外服务端口，默认即可，需要开放此端口或做nginx转发
-    accessKeyId: LTAI5tJPkn4HuuePdiLdGqe71
+  openImDemoPort: [ 10004 ]
-    accessKeySecret: 4n9OJ7ZCVN1U6KeHDAtOyNeVZcjOuV1
+  alismsverify: #阿里云短信配置，在阿里云申请成功后修改以下四项，必须修改
-    signName: OpenIM Corporation
+    accessKeyId: LTAI5tJPkn4HuuePdiLdGqe7
-    verificationCodeTemplateCode: SMS_2268101641
+    accessKeySecret: 4n9OJ7ZCVN1U6KeHDAtOyNeVZcjOuV
-  superCode: 666666
+    signName: 托云信息技术
-  mail:
+    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: "1765567899@qq.com"
+    senderMail: "765567899@qq.com"
-    senderAuthorizationCode: "1gxyausfoevlzbfag"
+    senderAuthorizationCode: "gxyausfoevlzbfag"
     smtpAddr: "smtp.qq.com"
-    smtpPort: 25
+    smtpPort: 25   #需开放此端口 出口方向
-
+  testDepartMentID: 001
+  imAPIURL: http://127.0.0.1:10002
 
+rtc:
+  signalTimeout: 35

deploy/config.example.yaml

@@ -19,6 +19,7 @@ mysql:
   dbMaxLifeTime: 120
 
 mongo:
+  dbUri: ""#当dbUri值不为空则直接使用该值
   dbAddress: [ openim_mongo:27017 ]
   dbDirect: false
   dbTimeout: 10
@@ -73,6 +74,8 @@ api:
   openImApiPort: [ 10000 ]
 sdk:
   openImSdkWsPort: [ 30000 ]
+cmsapi:
+  openImCmsApiPort: [ 8000 ]
 
 credential:
   tencent:
@@ -91,7 +94,9 @@ rpcport:
   openImGroupPort: [ 10500  ]
   openImAuthPort: [ 10600 ]
   openImPushPort: [ 10700 ]
-
+  openImStatisticsPort: [ 10800 ]
+  openImMessageCmsPort: [ 10900 ]
+  openImAdminCmsPort: [ 11000 ]
 
 rpcregistername:
   openImUserName: User

deploy/dockerfiles/Dockerfile.api

@@ -6,6 +6,7 @@ ENV CONFIG_NAME $WORKDIR/config/config.yaml
 
 # 将可执行文件复制到目标目录
 ADD ./open_im_api $WORKDIR/main
+COPY ./start_api.sh $$WORKDIR
 
 # 创建用于挂载的几个目录，添加可执行权限
 RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
@@ -13,4 +14,4 @@ RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
 
 
 WORKDIR $WORKDIR
-CMD ./main
+CMD ./start_api.sh

deploy_k8s/admin_cms/admin_cms.Dockerfile

@@ -0,0 +1,20 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CMDDIR $WORKDIR/cmd
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_admin_cms $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config", "/Open-IM-Server/script"]
+
+
+WORKDIR $CMDDIR
+CMD ./main

deploy_k8s/admin_cms/deployment.yaml

@@ -0,0 +1,32 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: admin-cms-deployment
+spec:
+  selector:
+    matchLabels:
+      app: admin-cms # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: admin-cms # 标签
+    spec:
+      containers:
+        - name: admin-cms
+          image: openim/admin_cms:v2.0.10k
+          # imagePullPolicy: Always #每次启动都重新拉取镜像
+          ports:
+            - containerPort: 10200
+          volumeMounts:
+            - name: config
+              mountPath: /Open-IM-Server/config
+              readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新
+

deploy_k8s/api/api.Dockerfile

@@ -0,0 +1,19 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CMDDIR $WORKDIR/cmd
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_api $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $CMDDIR
+CMD ./main

deploy_k8s/api/deployment.yaml

@@ -0,0 +1,45 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: api-deployment
+spec:
+  selector:
+    matchLabels:
+      app: api # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: api # 标签
+    spec:
+      containers:
+      - name: api
+        image: openim/api:v2.0.10k
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 10002
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: api
+spec:
+  ports:
+    - name: api-port
+      protocol: TCP
+      port: 10002
+      targetPort: 10002
+  selector:
+    app: api
+  type: NodePort  

deploy_k8s/auth/auth.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_auth $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/auth/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: auth-deployment
+spec:
+  selector:
+    matchLabels:
+      app: auth # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: auth # 标签
+    spec:
+      containers:
+      - name: auth
+        image: openim/auth:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10160
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/build_push_all_images.sh

@@ -0,0 +1,30 @@
+#/bin/sh
+source ./path_info.cfg
+
+# images version
+version=v2.0.10k
+git pull
+cd ../script/; ./build_all_service.sh
+cd ../deploy_k8s/
+
+for i in  ${service[*]}
+do
+  mv ../bin/open_im_${i} ./${i}/
+done
+
+echo "move success"
+
+echo "start to build images"
+
+for i in ${service[*]}
+do
+	echo "start to build images" $i
+	cd $i
+	image="openim/${i}:$version"
+	docker build -t $image . -f ./${i}.Dockerfile
+	echo "build ${dockerfile} success"
+	docker push $image
+	echo "push ${image} success "
+	cd ..
+done
+

deploy_k8s/cache/cache.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_cache $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/cache/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: cache-deployment
+spec:
+  selector:
+    matchLabels:
+      app: cache # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: cache # 标签
+    spec:
+      containers:
+      - name: cache
+        image: openim/cache:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10240
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/cms_api/cms_api.Dockerfile

@@ -0,0 +1,17 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_cms_api $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/cms_api/deployment.yaml

@@ -0,0 +1,45 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: cms-api-deployment
+spec:
+  selector:
+    matchLabels:
+      app: cms-api # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: cms-api # 标签
+    spec:
+      containers:
+      - name: cms-api
+        image: openim/cms_api:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10006
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: cms-api
+spec:
+  ports:
+    - name: cms-api-port
+      protocol: TCP
+      port: 10006
+      targetPort: 10006
+  selector:
+    app: cms-api
+  type: NodePort  

deploy_k8s/conversation/conversation.Dockerfile

@@ -0,0 +1,17 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_conversation $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/conversation/deployment.yaml

@@ -0,0 +1,32 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: conversation-deployment
+spec:
+  selector:
+    matchLabels:
+      app: conversation # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: conversation # 标签
+    spec:
+      containers:
+        - name: conversation
+          image: openim/conversation:v2.0.10k
+          # imagePullPolicy: Always
+          ports:
+            - containerPort: 10230
+          volumeMounts:
+            - name: config
+              mountPath: /Open-IM-Server/config
+              readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新
+

deploy_k8s/demo/demo.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_demo $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/demo/deployment.yaml

@@ -0,0 +1,45 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: demo-deployment
+spec:
+  selector:
+    matchLabels:
+      app: demo # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: demo # 标签
+    spec:
+      containers:
+      - name: demo
+        image: openim/demo:v2.0.10k
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 10004
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: demo
+spec:
+  ports:
+    - name: demo
+      protocol: TCP
+      port: 10004
+      targetPort: 10004
+  selector:
+    app: demo    
+  type: NodePort   

deploy_k8s/friend/deployment.yaml

@@ -0,0 +1,32 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: friend-deployment
+spec:
+  selector:
+    matchLabels:
+      app: friend # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: friend # 标签
+    spec:
+      containers:
+      - name: friend
+        image: openim/friend:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10120
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新
+

deploy_k8s/friend/friend.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_friend $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/group/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: group-deployment
+spec:
+  selector:
+    matchLabels:
+      app: group # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: group # 标签
+    spec:
+      containers:
+      - name: group
+        image: openim/group:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10150
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/group/group.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_group $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/ingress.yaml

@@ -0,0 +1,101 @@
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  annotations:
+    kubernetes.io/ingress.class: "nginx"
+    nginx.ingress.kubernetes.io/proxy-http-version: "1.1"
+    nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
+    nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
+  name: sdk-server-ingress
+spec:
+  rules:
+    - host: sdk-server.openim.xxx.com
+      http:
+        paths:
+          - backend:
+              service:
+                name: sdk-server
+                port:
+                  number: 10003
+            path: /
+            pathType: Prefix
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  annotations:
+    kubernetes.io/ingress.class: "nginx"
+    nginx.ingress.kubernetes.io/proxy-http-version: "1.1"
+    nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
+    nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
+  name: msg-gateway-ingress
+spec:
+  rules:
+    - host: msg-gateway.openim.xxx.com
+      http:
+        paths:
+          - backend:
+              service:
+                name: msg-gateway
+                port:
+                  number: 10001
+            path: /
+            pathType: Prefix
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  annotations:
+    kubernetes.io/ingress.class: "nginx"
+  name: api-ingress
+spec:
+  rules:
+    - host: api.openim.xxx.com
+      http:
+        paths:
+          - backend:
+              service:
+                name: api
+                port:
+                  number: 10002
+            path: /
+            pathType: Prefix
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  annotations:
+    kubernetes.io/ingress.class: "nginx"
+  name: demo-ingress
+spec:
+  rules:
+    - host: demo.openim.xxx.com
+      http:
+        paths:
+          - backend:
+              service:
+                name: demo
+                port:
+                  number: 10004 
+            path: /
+            pathType: Prefix
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  annotations:
+    kubernetes.io/ingress.class: "nginx"
+  name: cms-api-ingress
+spec:
+  rules:
+    - host: cms-api.openim.xxx.com
+      http:
+        paths:
+          - backend:
+              service:
+                name: cms-api
+                port:
+                  number: 10006
+            path: /
+            pathType: Prefix

deploy_k8s/k8s_openim_deploy.md

@@ -0,0 +1,38 @@
+#### openIM k8s部署文档
+### 1. 修改配置文件
+在Open-IM-SERVER目录下修改config/config.yaml配置文件, 将MySQL, Kafka, MongoDB等配置修改。
+使用demo需要修改demo/imAPIURL地址 让demo能请求到im的api
+
+### 2. 项目根目录创建im configMap到k8s openim namespace
+kubectl create namespace openim
+kubectl -n openim create configmap config --from-file=config/config.yaml
+openim 为im项目的namespace, 可选
+查看configmap
+kubectl -n openim get configmap
+
+### 3(可选). 修改每个deployment.yml
+kubectl get nodes
+kubectl label node k8s-node1 role=kube-Node
+应需要调度的node打上标签
+nodeSelector:
+  node: kube-Node
+创建资源清单时添加上nodeSelector属性对应即可
+修改每种服务数量，建议至少每种2个rpc。
+如果修改了config/config.yaml某些配置比如端口，同时需要修改对应deployment端口和ingress端口
+
+
+### 4. 修改ingress.yaml配置文件
+需要安装ingress controller 这里使用的是ingress-nginx 其他ingress需要修改配置文件
+进行域名修改等操作
+
+### 5. 执行./kubectl_start.sh脚本
+chmod +x ./kubectl_start.sh ./kubectl_stop.sh
+./kubectl_start.sh
+kubectl -n openim apply -f ingress.yaml
+kubectl 启动所有deployment，services，ingress
+
+### 6. 查看k8s deployment service ingress状态
+kubectl -n openim get services
+kubectl -n openim get deployment
+kubectl -n openim get ingress
+kubectl -n openim get pods

deploy_k8s/kubectl_start_all.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+source ./path_info.cfg
+
+#mkdir -p /db/sdk #path for jssdk sqlite
+
+for i in ${service[*]}
+do
+  kubectl -n openim apply -f ./${i}/deployment.yaml
+done
+

deploy_k8s/kubectl_stop_all.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+service=(
+  #api service file
+  api
+  cms-api
+  #rpc service file
+  user
+  friend
+  group
+  auth
+  admin-cms
+  message-cms
+  statistics
+  office
+  organization
+  conversation
+  cache
+  msg-gateway
+  msg-transfer
+  msg
+  push
+  sdk-server
+  demo
+)
+
+for i in ${service[*]}
+do
+    kubectl -n openim delete deployment "${i}-deployment"
+done
+
+kubectl -n openim delete service api
+kubectl -n openim delete service cms-api
+kubectl -n openim delete service sdk-server
+kubectl -n openim delete service msg-gateway
+kubectl -n openim delete service demo
+
+echo done

deploy_k8s/message_cms/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: message-cms-deployment
+spec:
+  selector:
+    matchLabels:
+      app: message-cms # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: message-cms # 标签
+    spec:
+      containers:
+      - name: message-cms
+        image: openim/message_cms:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10190
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/message_cms/message_cms.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_message_cms $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/msg/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: msg-deployment
+spec:
+  selector:
+    matchLabels:
+      app: msg # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: msg # 标签
+    spec:
+      containers:
+      - name: msg
+        image: openim/msg:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10130
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/msg/msg.Dockerfile

@@ -0,0 +1,19 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_msg $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/msg_gateway/deployment.yaml

@@ -0,0 +1,50 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: msg-gateway-deployment
+spec:
+  selector:
+    matchLabels:
+      app: msg-gateway # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: msg-gateway # 标签
+    spec:
+      containers:
+      - name: msg-gateway
+        image: openim/msg_gateway:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - name: rpc-port
+          containerPort: 10140
+        - name: ws-port
+          containerPort: 10001
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: msg-gateway
+spec:
+  ports:
+    - name: msg-gateway-port
+      protocol: TCP
+      port: 10001
+      targetPort: ws-port
+  selector:
+    app: msg-gateway
+  type: NodePort   
+
+    

deploy_k8s/msg_gateway/msg_gateway.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_msg_gateway $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/msg_transfer/deployment.yaml

@@ -0,0 +1,29 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: msg-transfer-deployment
+spec:
+  selector:
+    matchLabels:
+      app: msg-transfer # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: msg-transfer # 标签
+    spec:
+      containers:
+      - name: msg-transfer
+        image: openim/msg_transfer:v2.0.10k
+        # imagePullPolicy: Always
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/msg_transfer/msg_transfer.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_msg_transfer $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/office/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: office-deployment
+spec:
+  selector:
+    matchLabels:
+      app: office # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: office # 标签
+    spec:
+      containers:
+      - name: office
+        image: openim/office:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10210
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/office/office.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_office $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/organization/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: organization-deployment
+spec:
+  selector:
+    matchLabels:
+      app: organization # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: organization # 标签
+    spec:
+      containers:
+      - name: organization
+        image: openim/organization:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10220
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/organization/organization.Dockerfile

@@ -0,0 +1,19 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_organization $WORKDIR/cmd/main
+
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/path_info.cfg

@@ -0,0 +1,24 @@
+#/bin/sh
+service=(
+  #api service file
+  api
+  cms_api
+  #rpc service file
+  user
+  friend
+  group
+  auth
+  admin_cms
+  message_cms
+  statistics
+  office
+  organization
+  conversation
+  cache
+  msg_gateway
+  msg_transfer
+  msg
+  push
+  sdk_server
+  demo
+)

deploy_k8s/push/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: push-deployment
+spec:
+  selector:
+    matchLabels:
+      app: push # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: push # 标签
+    spec:
+      containers:
+      - name: push
+        image: openim/push:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10170
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/push/push.Dockerfile

@@ -0,0 +1,19 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_push $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/sdk_server/deployment.yaml

@@ -0,0 +1,54 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: sdk-server-deployment
+spec:
+  selector:
+    matchLabels:
+      app: sdk-server # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: sdk-server # 标签
+    spec:
+      containers:
+      - name: sdk-server
+        image: openim/sdk_server:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10003
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+          - name: local-db
+            mountPath: /db/sdk
+        command: ["/Open-IM-Server/main"]
+        args: ["-openIM_api_port", "10002", "-openIM_ws_port", "10001", "-sdk_ws_port", "10003", "-openIM_log_level", "6"]
+      volumes:
+        - name: config
+          configMap:
+            name: config
+        - name: local-db
+          hostPath:
+            path: /db/sdk
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: sdk-server
+spec:
+  ports:
+    - name: sdk-server-port
+      protocol: TCP
+      port: 10003
+      targetPort: 10003
+  selector:
+    app: sdk-server
+  type: NodePort   
+
+    

deploy_k8s/sdk_server/sdk_server.Dockerfile

@@ -0,0 +1,17 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_sdk_server $WORKDIR/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/db && \
+  chmod +x $WORKDIR/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script","/Open-IM-Server/db/sdk"]
+
+WORKDIR $WORKDIR
+CMD ./main

deploy_k8s/statistics/deployment.yaml

@@ -0,0 +1,31 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: statistics-deployment
+spec:
+  selector:
+    matchLabels:
+      app: statistics # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: statistics # 标签
+    spec:
+      containers:
+      - name: statistics
+        image: openim/statistics:v2.0.10k
+        # imagePullPolicy: Always
+        ports:
+        - containerPort: 10180
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/statistics/statistics.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_statistics $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

deploy_k8s/user/deployment.yaml

@@ -0,0 +1,29 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: user-deployment
+spec:
+  selector:
+    matchLabels:
+      app: user # 选择这个指定标签执行
+  replicas: 2 # 运行pod数量
+  template:
+    metadata:
+      labels:
+        app: user # 标签
+    spec:
+      containers:
+      - name: user
+        image: openim/user:v2.0.10k
+        # imagePullPolicy: Always
+        volumeMounts:
+          - name: config
+            mountPath: /Open-IM-Server/config
+            readOnly: true
+      volumes:
+        - name: config
+          configMap:
+            name: config
+  strategy: #更新策略
+    type: RollingUpdate # 滚动更新

deploy_k8s/user/user.Dockerfile

@@ -0,0 +1,18 @@
+FROM ubuntu
+
+# 设置固定的项目路径
+ENV WORKDIR /Open-IM-Server
+ENV CONFIG_NAME $WORKDIR/config/config.yaml
+
+# 将可执行文件复制到目标目录
+ADD ./open_im_user $WORKDIR/cmd/main
+
+# 创建用于挂载的几个目录，添加可执行权限
+RUN mkdir $WORKDIR/logs $WORKDIR/config $WORKDIR/script && \
+  chmod +x $WORKDIR/cmd/main
+
+VOLUME ["/Open-IM-Server/logs","/Open-IM-Server/config","/Open-IM-Server/script"]
+
+
+WORKDIR $WORKDIR
+CMD ./cmd/main

docker-compose.yaml

@@ -24,10 +24,15 @@ services:
       - ./components/mongodb/data/db:/data/db
       - ./components/mongodb/data/logs:/data/logs
       - ./components/mongodb/data/conf:/etc/mongo
+    environment:
+      - TZ=Asia/Shanghai
+      # cache
+      - wiredTigerCacheSizeGB=1
 #    environment:
 #      - MONGO_INITDB_ROOT_USERNAME=openIM
 #      - MONGO_INITDB_ROOT_PASSWORD=openIM
 
+
       #TZ: Asia/Shanghai
     restart: always
 
@@ -64,12 +69,17 @@ services:
     image: wurstmeister/kafka
     container_name: kafka
     restart: always
+    ports:
+     - 9093:9093
     environment:
       TZ: Asia/Shanghai
       KAFKA_BROKER_ID: 0
       KAFKA_ZOOKEEPER_CONNECT: 127.0.0.1:2181
-      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://127.0.0.1:9092
+      KAFKA_CREATE_TOPICS: "ws2ms_chat:8:1,ms2ps_chat:8:1,msg_to_mongo:8:1"
-      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092
+      KAFKA_ADVERTISED_LISTENERS: INSIDE://127.0.0.1:9092,OUTSIDE://103.116.45.174:9093
+      KAFKA_LISTENERS: INSIDE://:9092,OUTSIDE://:9093
+      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: "INSIDE:PLAINTEXT,OUTSIDE:PLAINTEXT"
+      KAFKA_INTER_BROKER_LISTENER_NAME: INSIDE
     network_mode: "host"
     depends_on:
       - zookeeper
@@ -89,7 +99,7 @@ services:
     command: /usr/local/bin/etcd --name etcd0 --data-dir /etcd-data --listen-client-urls http://0.0.0.0:2379 --advertise-client-urls http://0.0.0.0:2379 --listen-peer-urls http://0.0.0.0:2380 --initial-advertise-peer-urls http://0.0.0.0:2380 --initial-cluster etcd0=http://0.0.0.0:2380 --initial-cluster-token tkn --initial-cluster-state new
 
   open_im_server:
-    image: openim/open_im_server
+    image: openim/open_im_server:v2.1.0
     container_name: open_im_server
     volumes:
       - ./logs:/Open-IM-Server/logs

go.mod

@@ -3,51 +3,52 @@ module Open_IM
 go 1.15
 
 require (
-	github.com/Shopify/sarama v1.19.0
+	github.com/Shopify/sarama v1.32.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/sts-20150401 v1.1.0
 	github.com/alibabacloud-go/tea v1.1.17
 	github.com/antonfisher/nested-logrus-formatter v1.3.0
 	github.com/bwmarrin/snowflake v0.3.0
-	github.com/dustin/go-humanize v1.0.0 // indirect
+	github.com/fatih/structs v1.1.0
-	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.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-redis/redis/v8 v8.11.5
+	github.com/go-sql-driver/mysql v1.6.0 // indirect
+	github.com/gogo/protobuf v1.3.2
 	github.com/golang-jwt/jwt/v4 v4.1.0
 	github.com/golang/protobuf v1.5.2
-	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/mattn/go-sqlite3 v1.14.6 // indirect
+	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.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.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/api/v3 v3.5.4
-	go.etcd.io/etcd v0.0.0-20200402134248-51bdeb39e698
+	go.etcd.io/etcd/client/v3 v3.5.4
+	go.mongodb.org/mongo-driver v1.8.3
 	golang.org/x/image v0.0.0-20210220032944-ac19c3e999fb
-	golang.org/x/net v0.0.0-20210917221730-978cfadd31cf
+	golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd
-	google.golang.org/grpc v1.40.0
+	google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71 // indirect
+	google.golang.org/grpc v1.45.0
+	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/ini.v1 v1.66.2 // indirect
 	gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22
 	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 github.com/Shopify/sarama => github.com/Shopify/sarama v1.29.0

internal/api/auth/auth.go

@@ -0,0 +1,181 @@
+package apiAuth
+
+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/auth"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/fatih/structs"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func UserRegister(c *gin.Context) {
+	params := api.UserRegisterReq{}
+	if err := c.BindJSON(&params); err != nil {
+		errMsg := " BindJSON failed " + err.Error()
+		log.NewError("0", errMsg)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
+		return
+	}
+
+	if params.Secret != config.Config.Secret {
+		errMsg := " params.Secret != config.Config.Secret "
+		log.NewError(params.OperationID, errMsg, params.Secret, config.Config.Secret)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": errMsg})
+		return
+	}
+	req := &rpc.UserRegisterReq{UserInfo: &open_im_sdk.UserInfo{}}
+	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, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewAuthClient(etcdConn)
+	reply, err := client.UserRegister(context.Background(), req)
+	if err != nil {
+		errMsg := req.OperationID + " " + "UserRegister failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	if reply.CommonResp.ErrCode != 0 {
+		errMsg := req.OperationID + " " + " UserRegister failed " + reply.CommonResp.ErrMsg + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	pbDataToken := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
+	replyToken, err := client.UserToken(context.Background(), pbDataToken)
+	if err != nil {
+		errMsg := req.OperationID + " " + " client.UserToken failed " + err.Error() + pbDataToken.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	resp := api.UserRegisterResp{CommResp: api.CommResp{ErrCode: replyToken.CommonResp.ErrCode, ErrMsg: replyToken.CommonResp.ErrMsg},
+		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 {
+		errMsg := " BindJSON failed " + err.Error()
+		log.NewError("0", errMsg)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
+		return
+	}
+
+	if params.Secret != config.Config.Secret {
+		errMsg := params.OperationID + " params.Secret != config.Config.Secret "
+		log.NewError(params.OperationID, "params.Secret != config.Config.Secret", params.Secret, config.Config.Secret)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": errMsg})
+		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, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewAuthClient(etcdConn)
+	reply, err := client.UserToken(context.Background(), req)
+	if err != nil {
+		errMsg := req.OperationID + " UserToken failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	resp := api.UserTokenResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg},
+		UserToken: api.UserTokenInfo{UserID: req.FromUserID, Token: reply.Token, ExpiredTime: reply.ExpiredTime}}
+	log.NewInfo(req.OperationID, "UserToken return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func ParseToken(c *gin.Context) {
+	params := api.ParseTokenReq{}
+	if err := c.BindJSON(&params); err != nil {
+		errMsg := " BindJSON failed " + err.Error()
+		log.NewError("0", errMsg)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
+		return
+	}
+
+	var ok bool
+	var errInfo string
+	var expireTime int64
+	ok, _, errInfo, expireTime = token_verify.GetUserIDFromTokenExpireTime(c.Request.Header.Get("token"), params.OperationID)
+	if !ok {
+		errMsg := params.OperationID + " " + "GetUserIDFromTokenExpireTime failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(params.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	resp := api.ParseTokenResp{CommResp: api.CommResp{ErrCode: 0, ErrMsg: ""}, ExpireTime: api.ExpireTime{ExpireTimeSeconds: uint32(expireTime)}}
+	resp.Data = structs.Map(&resp.ExpireTime)
+	log.NewInfo(params.OperationID, "ParseToken return ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func ForceLogout(c *gin.Context) {
+	params := api.ForceLogoutReq{}
+	if err := c.BindJSON(&params); err != nil {
+		errMsg := " BindJSON failed " + err.Error()
+		log.NewError("0", errMsg)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
+		return
+	}
+
+	req := &rpc.ForceLogoutReq{}
+	utils.CopyStructFields(req, &params)
+
+	var ok bool
+	var errInfo string
+	ok, req.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, "ForceLogout args ", req.String())
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewAuthClient(etcdConn)
+	reply, err := client.ForceLogout(context.Background(), req)
+	if err != nil {
+		errMsg := req.OperationID + " UserToken failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	resp := api.ForceLogoutResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(params.OperationID, utils.GetSelfFuncName(), " return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/auth/user_register.go

@@ -1,95 +0,0 @@
-package apiAuth
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbAuth "Open_IM/pkg/proto/auth"
-	"context"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-type paramsUserRegister struct {
-	Secret   string `json:"secret" binding:"required,max=32"`
-	Platform int32  `json:"platform" binding:"required,min=1,max=7"`
-	UID      string `json:"uid" binding:"required,min=1,max=64"`
-	Name     string `json:"name" binding:"required,min=1,max=64"`
-	Icon     string `json:"icon" binding:"omitempty,max=1024"`
-	Gender   int32  `json:"gender" binding:"omitempty,oneof=0 1 2"`
-	Mobile   string `json:"mobile" binding:"omitempty,max=32"`
-	Birth    string `json:"birth" binding:"omitempty,max=16"`
-	Email    string `json:"email" binding:"omitempty,max=64"`
-	Ex       string `json:"ex" binding:"omitempty,max=1024"`
-}
-
-func newUserRegisterReq(params *paramsUserRegister) *pbAuth.UserRegisterReq {
-	pbData := pbAuth.UserRegisterReq{
-		UID:    params.UID,
-		Name:   params.Name,
-		Icon:   params.Icon,
-		Gender: params.Gender,
-		Mobile: params.Mobile,
-		Birth:  params.Birth,
-		Email:  params.Email,
-		Ex:     params.Ex,
-	}
-	return &pbData
-}
-
-func UserRegister(c *gin.Context) {
-	log.Info("", "", "api user_register init ....")
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
-	client := pbAuth.NewAuthClient(etcdConn)
-	//defer etcdConn.Close()
-
-	params := paramsUserRegister{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	if params.Secret != config.Config.Secret {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "not authorized"})
-		return
-	}
-	pbData := newUserRegisterReq(&params)
-
-	log.Info("", "", "api user_register is server, [data: %s]", pbData.String())
-	reply, err := client.UserRegister(context.Background(), pbData)
-	if err != nil || !reply.Success {
-		log.Error("", "", "api user_register call rpc fail, [data: %s] [err: %s]", pbData.String(), err.Error())
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
-		return
-	}
-	log.Info("", "", "api user_register call rpc success, [data: %s] [reply: %s]", pbData.String(), reply.String())
-
-	pbDataToken := &pbAuth.UserTokenReq{
-		Platform: params.Platform,
-		UID:      params.UID,
-	}
-	replyToken, err := client.UserToken(context.Background(), pbDataToken)
-	if err != nil {
-		log.Error("", "", "api user_register call rpc fail, [data: %s] [err: %s]", pbData.String(), err.Error())
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
-		return
-	}
-	log.Info("", "", "api user_register call success, [data: %s] [reply: %s]", pbData.String(), reply.String())
-
-	if replyToken.ErrCode == 0 {
-		c.JSON(http.StatusOK, gin.H{
-			"errCode": replyToken.ErrCode,
-			"errMsg":  replyToken.ErrMsg,
-			"data": gin.H{
-				"uid":         pbData.UID,
-				"token":       replyToken.Token,
-				"expiredTime": replyToken.ExpiredTime,
-			},
-		})
-	} else {
-		c.JSON(http.StatusOK, gin.H{
-			"errCode": replyToken.ErrCode,
-			"errMsg":  replyToken.ErrMsg,
-		})
-	}
-}

internal/api/auth/user_token.go

@@ -1,72 +0,0 @@
-package apiAuth
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbAuth "Open_IM/pkg/proto/auth"
-	"context"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-type paramsUserToken struct {
-	Secret   string `json:"secret" binding:"required,max=32"`
-	Platform int32  `json:"platform" binding:"required,min=1,max=8"`
-	UID      string `json:"uid" binding:"required,min=1,max=64"`
-}
-
-func newUserTokenReq(params *paramsUserToken) *pbAuth.UserTokenReq {
-	pbData := pbAuth.UserTokenReq{
-		Platform: params.Platform,
-		UID:      params.UID,
-	}
-	return &pbData
-}
-
-func UserToken(c *gin.Context) {
-	log.Info("", "", "api user_token init ....")
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName)
-	client := pbAuth.NewAuthClient(etcdConn)
-	//defer etcdConn.Close()
-
-	params := paramsUserToken{}
-	if err := c.BindJSON(&params); err != nil {
-		log.Error("", "", params.UID, params.Platform, params.Secret)
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	if params.Secret != config.Config.Secret {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "not authorized"})
-		return
-	}
-	pbData := newUserTokenReq(&params)
-
-	log.Info("", "", "api user_token is server, [data: %s]", pbData.String())
-	reply, err := client.UserToken(context.Background(), pbData)
-	if err != nil {
-		log.Error("", "", "api user_token call rpc fail, [data: %s] [err: %s]", pbData.String(), err.Error())
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
-		return
-	}
-	log.Info("", "", "api user_token call rpc success, [data: %s] [reply: %s]", pbData.String(), reply.String())
-
-	if reply.ErrCode == 0 {
-		c.JSON(http.StatusOK, gin.H{
-			"errCode": reply.ErrCode,
-			"errMsg":  reply.ErrMsg,
-			"data": gin.H{
-				"uid":         pbData.UID,
-				"token":       reply.Token,
-				"expiredTime": reply.ExpiredTime,
-			},
-		})
-	} else {
-		c.JSON(http.StatusOK, gin.H{
-			"errCode": reply.ErrCode,
-			"errMsg":  reply.ErrMsg,
-		})
-	}
-
-}

internal/api/chat/del_msg.go

@@ -0,0 +1,95 @@
+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/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	rpc "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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
+	if err := utils.CopyStructFields(&reqPb, &req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields", err.Error())
+	}
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, req.OperationID)
+	if grpcConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	msgClient := rpc.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
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+func ClearMsg(c *gin.Context) {
+	params := api.CleanUpMsgReq{}
+	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.ClearMsgReq{}
+	utils.CopyStructFields(req, &params)
+
+	var ok bool
+	var errInfo string
+	ok, req.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := rpc.NewChatClient(etcdConn)
+	RpcResp, err := client.ClearMsg(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, " CleanUpMsg failed ", err.Error(), req.String(), RpcResp.ErrMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": RpcResp.ErrMsg})
+		return
+	}
+
+	resp := api.CleanUpMsgResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/chat/get_max_min_seq.go

@@ -5,7 +5,8 @@ import (
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbMsg "Open_IM/pkg/proto/chat"
+	pbChat "Open_IM/pkg/proto/chat"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
 	"context"
 	"github.com/gin-gonic/gin"
 	"net/http"
@@ -19,7 +20,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()})
@@ -31,15 +32,18 @@ func UserGetSeq(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
 		return
 	}
-	pbData := pbMsg.GetMaxAndMinSeqReq{}
+	pbData := sdk_ws.GetMaxAndMinSeqReq{}
 	pbData.UserID = params.SendID
 	pbData.OperationID = params.OperationID
-	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, pbData.OperationID)
-
 	if grpcConn == nil {
-		log.ErrorByKv("get grpcConn err", pbData.OperationID, "args", params)
+		errMsg := pbData.OperationID + " getcdv3.GetConn == nil"
+		log.NewError(pbData.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
 	}
-	msgClient := pbMsg.NewChatClient(grpcConn)
+
+	msgClient := pbChat.NewChatClient(grpcConn)
 	reply, err := msgClient.GetMaxAndMinSeq(context.Background(), &pbData)
 	if err != nil {
 		log.NewError(params.OperationID, "UserGetSeq rpc failed, ", params, err.Error())

internal/api/chat/pull_msg.go

@@ -6,6 +6,8 @@ import (
 	"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"
@@ -22,64 +24,14 @@ type paramsUserPullMsg struct {
 	}
 }
 
-func UserPullMsg(c *gin.Context) {
-	params := paramsUserPullMsg{}
-	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 {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
-		return
-	}
-	pbData := pbChat.PullMessageReq{}
-	pbData.UserID = params.SendID
-	pbData.OperationID = params.OperationID
-	pbData.SeqBegin = *params.Data.SeqBegin
-	pbData.SeqEnd = *params.Data.SeqEnd
-	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
-	msgClient := pbChat.NewChatClient(grpcConn)
-	reply, err := msgClient.PullMessage(context.Background(), &pbData)
-	if err != nil {
-		log.NewError(params.OperationID, "UserPullMsg rpc failed, ", params, err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "UserPullMsg rpc failed, " + err.Error()})
-		return
-	}
-	log.InfoByKv("rpc call success to pullMsgRep", pbData.OperationID, "ReplyArgs", reply.String(), "maxSeq", reply.GetMaxSeq(),
-		"MinSeq", reply.GetMinSeq(), "singLen", len(reply.GetSingleUserMsg()), "groupLen", len(reply.GetGroupUserMsg()))
-
-	msg := make(map[string]interface{})
-	if v := reply.GetSingleUserMsg(); v != nil {
-		msg["single"] = v
-	} else {
-		msg["single"] = []pbChat.GatherFormat{}
-	}
-	if v := reply.GetGroupUserMsg(); v != nil {
-		msg["group"] = v
-	} else {
-		msg["group"] = []pbChat.GatherFormat{}
-	}
-	msg["maxSeq"] = reply.GetMaxSeq()
-	msg["minSeq"] = reply.GetMinSeq()
-	c.JSON(http.StatusOK, gin.H{
-		"errCode":       reply.ErrCode,
-		"errMsg":        reply.ErrMsg,
-		"reqIdentifier": *params.ReqIdentifier,
-		"data":          msg,
-	})
-
-}
-
 type paramsUserPullMsgBySeqList struct {
-	ReqIdentifier int     `json:"reqIdentifier" binding:"required"`
+	ReqIdentifier int      `json:"reqIdentifier" binding:"required"`
-	SendID        string  `json:"sendID" binding:"required"`
+	SendID        string   `json:"sendID" binding:"required"`
-	OperationID   string  `json:"operationID" binding:"required"`
+	OperationID   string   `json:"operationID" binding:"required"`
-	SeqList       []int64 `json:"seqList"`
+	SeqList       []uint32 `json:"seqList"`
 }
 
-func UserPullMsgBySeqList(c *gin.Context) {
+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()})
@@ -88,41 +40,35 @@ func UserPullMsgBySeqList(c *gin.Context) {
 
 	token := c.Request.Header.Get("token")
 	if ok, err := token_verify.VerifyToken(token, params.SendID); !ok {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
+		if err != nil {
+			log.NewError(params.OperationID, utils.GetSelfFuncName(), err.Error(), token, params.SendID)
+		}
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"})
 		return
 	}
-	pbData := pbChat.PullMessageBySeqListReq{}
+	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)
+	grpcConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, pbData.OperationID)
+	if grpcConn == nil {
+		errMsg := pbData.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(pbData.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
 	msgClient := pbChat.NewChatClient(grpcConn)
 	reply, err := msgClient.PullMessageBySeqList(context.Background(), &pbData)
 	if err != nil {
-		log.ErrorByKv("PullMessageBySeqList error", pbData.OperationID, "err", err.Error())
+		log.Error(pbData.OperationID, "PullMessageBySeqList error", err.Error())
 		return
 	}
-	log.InfoByKv("rpc call success to PullMessageBySeqList", pbData.OperationID, "ReplyArgs", reply.String(), "maxSeq", reply.GetMaxSeq(),
+	log.NewInfo(pbData.OperationID, "rpc call success to PullMessageBySeqList", reply.String(), len(reply.List))
-		"MinSeq", reply.GetMinSeq(), "singLen", len(reply.GetSingleUserMsg()), "groupLen", len(reply.GetGroupUserMsg()))
-
-	msg := make(map[string]interface{})
-	if v := reply.GetSingleUserMsg(); v != nil {
-		msg["single"] = v
-	} else {
-		msg["single"] = []pbChat.GatherFormat{}
-	}
-	if v := reply.GetGroupUserMsg(); v != nil {
-		msg["group"] = v
-	} else {
-		msg["group"] = []pbChat.GatherFormat{}
-	}
-	msg["maxSeq"] = reply.GetMaxSeq()
-	msg["minSeq"] = reply.GetMinSeq()
 	c.JSON(http.StatusOK, gin.H{
 		"errCode":       reply.ErrCode,
 		"errMsg":        reply.ErrMsg,
 		"reqIdentifier": params.ReqIdentifier,
-		"data":          msg,
+		"data":          reply.List,
 	})
 }

internal/api/chat/send_msg.go

@@ -4,7 +4,7 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/log"
 	pbChat "Open_IM/pkg/proto/chat"
-	"Open_IM/pkg/utils"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
 	"context"
 
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
@@ -14,81 +14,85 @@ import (
 )
 
 type paramsUserSendMsg struct {
-	ReqIdentifier  int32  `json:"reqIdentifier" binding:"required"`
+	SenderPlatformID int32  `json:"senderPlatformID" binding:"required"`
-	PlatformID     int32  `json:"platformID" binding:"required"`
+	SendID           string `json:"sendID" binding:"required"`
-	SendID         string `json:"sendID" binding:"required"`
+	SenderNickName   string `json:"senderNickName"`
-	SenderNickName string `json:"senderNickName"`
+	SenderFaceURL    string `json:"senderFaceUrl"`
-	SenderFaceURL  string `json:"senderFaceUrl"`
+	OperationID      string `json:"operationID" binding:"required"`
-	OperationID    string `json:"operationID" binding:"required"`
+	Data             struct {
-	Data           struct {
+		SessionType int32                        `json:"sessionType" binding:"required"`
-		SessionType int32                  `json:"sessionType" binding:"required"`
+		MsgFrom     int32                        `json:"msgFrom" binding:"required"`
-		MsgFrom     int32                  `json:"msgFrom" binding:"required"`
+		ContentType int32                        `json:"contentType" binding:"required"`
-		ContentType int32                  `json:"contentType" binding:"required"`
+		RecvID      string                       `json:"recvID" `
-		RecvID      string                 `json:"recvID" binding:"required"`
+		GroupID     string                       `json:"groupID" `
-		ForceList   []string               `json:"forceList"`
+		ForceList   []string                     `json:"forceList"`
-		Content     string                 `json:"content" binding:"required"`
+		Content     []byte                       `json:"content" binding:"required"`
-		Options     map[string]int32       `json:"options" `
+		Options     map[string]bool              `json:"options" `
-		ClientMsgID string                 `json:"clientMsgID" binding:"required"`
+		ClientMsgID string                       `json:"clientMsgID" binding:"required"`
-		OffLineInfo map[string]interface{} `json:"offlineInfo" `
+		CreateTime  int64                        `json:"createTime" binding:"required"`
-		Ex          map[string]interface{} `json:"ext"`
+		OffLineInfo *open_im_sdk.OfflinePushInfo `json:"offlineInfo" `
 	}
 }
 
-func newUserSendMsgReq(token string, params *paramsUserSendMsg) *pbChat.UserSendMsgReq {
+func newUserSendMsgReq(token string, params *paramsUserSendMsg) *pbChat.SendMsgReq {
-	pbData := pbChat.UserSendMsgReq{
+	pbData := pbChat.SendMsgReq{
-		ReqIdentifier:  params.ReqIdentifier,
+		Token:       token,
-		Token:          token,
+		OperationID: params.OperationID,
-		SendID:         params.SendID,
+		MsgData: &open_im_sdk.MsgData{
-		SenderNickName: params.SenderNickName,
+			SendID:           params.SendID,
-		SenderFaceURL:  params.SenderFaceURL,
+			RecvID:           params.Data.RecvID,
-		OperationID:    params.OperationID,
+			GroupID:          params.Data.GroupID,
-		PlatformID:     params.PlatformID,
+			ClientMsgID:      params.Data.ClientMsgID,
-		SessionType:    params.Data.SessionType,
+			SenderPlatformID: params.SenderPlatformID,
-		MsgFrom:        params.Data.MsgFrom,
+			SenderNickname:   params.SenderNickName,
-		ContentType:    params.Data.ContentType,
+			SenderFaceURL:    params.SenderFaceURL,
-		RecvID:         params.Data.RecvID,
+			SessionType:      params.Data.SessionType,
-		ForceList:      params.Data.ForceList,
+			MsgFrom:          params.Data.MsgFrom,
-		Content:        params.Data.Content,
+			ContentType:      params.Data.ContentType,
-		Options:        utils.MapIntToJsonString(params.Data.Options),
+			Content:          params.Data.Content,
-		ClientMsgID:    params.Data.ClientMsgID,
+			CreateTime:       params.Data.CreateTime,
-		OffLineInfo:    utils.MapToJsonString(params.Data.OffLineInfo),
+			Options:          params.Data.Options,
-		Ex:             utils.MapToJsonString(params.Data.Ex),
+			OfflinePushInfo:  params.Data.OffLineInfo,
+		},
 	}
 	return &pbData
 }
 
-func UserSendMsg(c *gin.Context) {
+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"))
+		log.Error("0", "BindJSON failed ", err.Error())
 		return
 	}
 
 	token := c.Request.Header.Get("token")
-
+	log.NewInfo(params.OperationID, "api call success to sendMsgReq", params)
-	log.InfoByKv("api call success to sendMsgReq", params.OperationID, "Parameters", params)
-
 	pbData := newUserSendMsgReq(token, &params)
-	log.Info("", "", "api UserSendMsg call start..., [data: %s]", pbData.String())
+	log.Info(params.OperationID, "", "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)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName, params.OperationID)
-	client := pbChat.NewChatClient(etcdConn)
+	if etcdConn == nil {
-
+		errMsg := params.OperationID + "getcdv3.GetConn == nil"
-	log.Info("", "", "api UserSendMsg call, api call rpc...")
+		log.NewError(params.OperationID, errMsg)
-
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-	reply, err := client.UserSendMsg(context.Background(), pbData)
-	if err != nil {
-		log.NewError(params.OperationID, "UserSendMsg rpc failed, ", params, err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "UserSendMsg rpc failed, " + err.Error()})
 		return
 	}
-	log.Info("", "", "api UserSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
+	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(params.OperationID, "", "api SendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
 
 	c.JSON(http.StatusOK, gin.H{
-		"errCode":       reply.ErrCode,
+		"errCode": reply.ErrCode,
-		"errMsg":        reply.ErrMsg,
+		"errMsg":  reply.ErrMsg,
-		"reqIdentifier": reply.ReqIdentifier,
 		"data": gin.H{
 			"clientMsgID": reply.ClientMsgID,
 			"serverMsgID": reply.ServerMsgID,

internal/api/conversation/conversation.go

@@ -1,11 +1,12 @@
 package conversation
 
 import (
+	api "Open_IM/pkg/base_info"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	"Open_IM/pkg/proto/user"
+	pbConversation "Open_IM/pkg/proto/conversation"
+	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
 	"github.com/gin-gonic/gin"
@@ -13,182 +14,279 @@ import (
 	"strings"
 )
 
-type paramsSetReceiveMessageOpt struct {
+func SetConversation(c *gin.Context) {
-	OperationID        string   `json:"operationID" binding:"required"`
+	var (
-	Option             *int32   `json:"option" binding:"required"`
+		req   api.SetConversationReq
-	ConversationIdList []string `json:"conversationIdList" binding:"required"`
+		resp  api.SetConversationResp
-}
+		reqPb pbUser.SetConversationReq
-
+	)
-type OptResult struct {
+	if err := c.BindJSON(&req); err != nil {
-	ConversationId string `json:"conversationId" binding:"required"`
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
-	Result         int32  `json:"result" binding:"required"`
-}
-
-type SetReceiveMessageOptResp struct {
-	ErrCode int32       `json:"errCode"`
-	ErrMsg  string      `json:"errMsg"`
-	Data    []OptResult `json:"data"`
-}
-
-type paramGetReceiveMessageOpt struct {
-	ConversationIdList []string `json:"conversationIdList" binding:"required"`
-	OperationID        string   `json:"operationID" binding:"required"`
-}
-
-type GetReceiveMessageOptResp struct {
-	SetReceiveMessageOptResp
-}
-
-type paramGetAllConversationMessageOpt struct {
-	OperationID string `json:"operationID" binding:"required"`
-}
-
-type GetAllConversationMessageOptResp struct {
-	SetReceiveMessageOptResp
-}
-
-//CopyStructFields
-
-func GetAllConversationMessageOpt(c *gin.Context) {
-	params := paramGetAllConversationMessageOpt{}
-	if err := c.BindJSON(&params); err != nil {
-		log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
 		return
 	}
-
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
+	reqPb.Conversation = &pbUser.Conversation{}
+	err := utils.CopyStructFields(&reqPb, req)
+	err = utils.CopyStructFields(reqPb.Conversation, req.Conversation)
 	if err != nil {
-		log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
-
+	client := pbUser.NewUserClient(etcdConn)
-	req := &user.GetAllConversationMsgOptReq{
+	respPb, err := client.SetConversation(context.Background(), &reqPb)
-		UId:         claims.UID,
-		OperationID: params.OperationID,
-	}
-	log.NewInfo(req.OperationID, "GetAllConversationMsgOpt req: ", req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
-	client := user.NewUserClient(etcdConn)
-	resp, err := client.GetAllConversationMsgOpt(context.Background(), req)
 	if err != nil {
-		log.NewError(params.OperationID, "GetAllConversationMsgOpt rpc failed, ", req, err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
 		return
 	}
-	var ginResp GetAllConversationMessageOptResp
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
-	ginResp.ErrCode = resp.ErrCode
+	resp.ErrCode = respPb.CommonResp.ErrCode
-	ginResp.ErrMsg = resp.ErrMsg
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
-	for _, v := range resp.ConversationOptResult {
+	c.JSON(http.StatusOK, resp)
-		var opt OptResult
-		err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
-		if err != nil {
-			log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
-			continue
-		}
-		ginResp.Data = append(ginResp.Data, opt)
-	}
-	log.NewInfo(req.OperationID, "GetAllConversationMsgOpt resp: ", ginResp, req)
-	c.JSON(http.StatusOK, ginResp)
 }
-
+func ModifyConversationField(c *gin.Context) {
-func GetReceiveMessageOpt(c *gin.Context) {
+	var (
-	params := paramGetReceiveMessageOpt{}
+		req   api.ModifyConversationFieldReq
-	if err := c.BindJSON(&params); err != nil {
+		resp  api.ModifyConversationFieldResp
-		log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
+		reqPb pbConversation.ModifyConversationFieldReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
 		return
 	}
-
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
+	reqPb.Conversation = &pbConversation.Conversation{}
+	err := utils.CopyStructFields(&reqPb, req)
+	err = utils.CopyStructFields(reqPb.Conversation, req.Conversation)
 	if err != nil {
-		log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
 		return
 	}
-
+	client := pbConversation.NewConversationClient(etcdConn)
-	req := &user.GetReceiveMessageOptReq{
+	respPb, err := client.ModifyConversationField(context.Background(), &reqPb)
-		UId:            claims.UID,
-		ConversationId: params.ConversationIdList,
-		OperationID:    params.OperationID,
-	}
-	log.NewInfo(req.OperationID, "GetReceiveMessageOptReq req: ", req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
-	client := user.NewUserClient(etcdConn)
-	resp, err := client.GetReceiveMessageOpt(context.Background(), req)
 	if err != nil {
-		log.NewError(params.OperationID, "GetReceiveMessageOpt rpc failed, ", req, err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "GetReceiveMessageOpt rpc failed, " + err.Error()})
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
 		return
 	}
-	log.NewInfo(req.OperationID, "GetReceiveMessageOptReq req: ", req, resp)
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
-	var ginResp GetReceiveMessageOptResp
+	resp.ErrCode = respPb.CommonResp.ErrCode
-	ginResp.ErrCode = resp.ErrCode
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
-	ginResp.ErrMsg = resp.ErrMsg
+	c.JSON(http.StatusOK, resp)
-
-	for _, v := range resp.ConversationOptResult {
-		var opt OptResult
-		log.NewInfo("CopyStructFields begin ", v, req.OperationID)
-		err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
-		log.NewInfo("CopyStructFields end ", v, req.OperationID)
-		if err != nil {
-			log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
-			continue
-		}
-		ginResp.Data = append(ginResp.Data, opt)
-	}
-	log.NewInfo(req.OperationID, "GetReceiveMessageOpt resp: ", ginResp)
-	c.JSON(http.StatusOK, ginResp)
 }
 
+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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.GetConversation(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetConversation 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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
+	if err := utils.CopyStructFields(&reqPb, req); err != nil {
+		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := pbUser.NewUserClient(etcdConn)
+	respPb, err := client.SetRecvMsgOpt(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetRecvMsgOpt rpc failed, ", reqPb.String(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
+		return
+	}
+	resp.ErrMsg = respPb.CommonResp.ErrMsg
+	resp.ErrCode = respPb.CommonResp.ErrCode
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
+	c.JSON(http.StatusOK, resp)
+}
+
+//Deprecated
 func SetReceiveMessageOpt(c *gin.Context) {
-	params := paramsSetReceiveMessageOpt{}
-	if err := c.BindJSON(&params); err != nil {
-		log.NewError(params.OperationID, "bind json failed ", err.Error(), c)
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
-		return
-	}
 
-	claims, err := token_verify.ParseToken(c.Request.Header.Get("token"))
+}
-	if err != nil {
+
-		log.NewError(params.OperationID, "ParseToken failed, ", err.Error(), c.Request.Header.Get("token"))
+//Deprecated
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "ParseToken failed, " + err.Error()})
+func GetReceiveMessageOpt(c *gin.Context) {
-		return
+
-	}
+}
-
+
-	req := &user.SetReceiveMessageOptReq{
+//Deprecated
-		UId:            claims.UID,
+func GetAllConversationMessageOpt(c *gin.Context) {
-		Opt:            *params.Option,
+
-		ConversationId: params.ConversationIdList,
-		OperationID:    params.OperationID,
-	}
-	log.NewInfo(req.OperationID, "SetReceiveMessageOpt req: ", req)
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
-	client := user.NewUserClient(etcdConn)
-	resp, err := client.SetReceiveMessageOpt(context.Background(), req)
-	if err != nil {
-		log.NewError(params.OperationID, "SetReceiveMessageOpt rpc failed, ", req, err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "SetReceiveMessageOpt rpc failed, " + err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, "SetReceiveMessageOpt req: ", req, resp)
-	ginResp := SetReceiveMessageOptResp{
-		ErrCode: resp.ErrCode,
-		ErrMsg:  resp.ErrMsg,
-	}
-
-	for _, v := range resp.OptResult {
-		var opt OptResult
-		log.NewDebug("CopyStructFields begin ", v, req.OperationID)
-		err := utils.CopyStructFields(&opt, *v, "ConversationId", "Result")
-		log.NewDebug("CopyStructFields end ", v, req.OperationID)
-		if err != nil {
-			log.NewError(req.OperationID, "CopyStructFields failed ", err.Error())
-			continue
-		}
-		ginResp.Data = append(ginResp.Data, opt)
-	}
-	log.NewInfo(req.OperationID, "SetReceiveMessageOpt resp: ", ginResp)
-	c.JSON(http.StatusOK, ginResp)
 }

internal/api/friend/add_blacklist.go

@@ -1,49 +0,0 @@
-package friend
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbFriend "Open_IM/pkg/proto/friend"
-	"context"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-/*
-type paramsAddBlackList struct {
-	OperationID string `json:"operationID" binding:"required"`
-	UID         string `json:"uid" binding:"required"`
-}*/
-
-func AddBlacklist(c *gin.Context) {
-	log.Info("", "", "api add blacklist init ....")
-
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := pbFriend.NewFriendClient(etcdConn)
-	//defer etcdConn.Close()
-
-	params := paramsSearchFriend{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	req := &pbFriend.AddBlacklistReq{
-		Uid:         params.UID,
-		OperationID: params.OperationID,
-		Token:       c.Request.Header.Get("token"),
-		OwnerUid:    params.OwnerUid,
-	}
-	log.Info(req.Token, req.OperationID, "api add blacklist is server:userID=%s", req.Uid)
-	RpcResp, err := client.AddBlacklist(context.Background(), req)
-	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,call add blacklist rpc server failed", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add blacklist rpc server failed"})
-		return
-	}
-	log.InfoByArgs("call add blacklist rpc server success,args=%s", RpcResp.String())
-	resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg}
-	c.JSON(http.StatusOK, resp)
-	log.InfoByArgs("api add blacklist success return,get args=%s,return args=%s", req.String(), RpcResp.String())
-}

internal/api/friend/add_friend.go

@@ -1,88 +0,0 @@
-package friend
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbFriend "Open_IM/pkg/proto/friend"
-	"context"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-type paramsImportFriendReq struct {
-	OperationID string   `json:"operationID" binding:"required"`
-	UIDList     []string `json:"uidList" binding:"required"`
-	OwnerUid    string   `json:"ownerUid" binding:"required"`
-}
-
-type paramsAddFriend struct {
-	OperationID string `json:"operationID" binding:"required"`
-	UID         string `json:"uid" binding:"required"`
-	ReqMessage  string `json:"reqMessage"`
-}
-
-//
-func ImportFriend(c *gin.Context) {
-	log.Info("", "", "ImportFriend init ....")
-	log.NewDebug("", "api importFriend start")
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := pbFriend.NewFriendClient(etcdConn)
-
-	params := paramsImportFriendReq{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	req := &pbFriend.ImportFriendReq{
-		UidList:     params.UIDList,
-		OperationID: params.OperationID,
-		OwnerUid:    params.OwnerUid,
-		Token:       c.Request.Header.Get("token"),
-	}
-	log.NewDebug(req.OperationID, "args is ", req.String())
-	RpcResp, err := client.ImportFriend(context.Background(), req)
-	if err != nil {
-		log.NewError(req.OperationID, "rpc importFriend failed", err.Error())
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "cImportFriend failed " + err.Error()})
-		return
-	}
-	failedUidList := make([]string, 0)
-	for _, v := range RpcResp.FailedUidList {
-		failedUidList = append(failedUidList, v)
-	}
-	log.NewDebug(req.OperationID, "rpc importFriend success", RpcResp.CommonResp.ErrorMsg, RpcResp.CommonResp.ErrorCode, RpcResp.FailedUidList)
-	c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "failedUidList": failedUidList})
-}
-
-func AddFriend(c *gin.Context) {
-	log.Info("", "", "api add friend init ....")
-
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := pbFriend.NewFriendClient(etcdConn)
-
-	params := paramsAddFriend{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	req := &pbFriend.AddFriendReq{
-		Uid:         params.UID,
-		OperationID: params.OperationID,
-		ReqMessage:  params.ReqMessage,
-		Token:       c.Request.Header.Get("token"),
-	}
-	log.Info(req.Token, req.OperationID, "api add friend is server")
-	RpcResp, err := client.AddFriend(context.Background(), req)
-	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,call add friend rpc server failed", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add friend rpc server failed"})
-		return
-	}
-	log.InfoByArgs("call add friend rpc server success,args=%s", RpcResp.String())
-	c.JSON(http.StatusOK, gin.H{
-		"errCode": RpcResp.ErrorCode,
-		"errMsg":  RpcResp.ErrorMsg,
-	})
-}

internal/api/friend/add_friend_response.go

@@ -1,49 +0,0 @@
-package friend
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbFriend "Open_IM/pkg/proto/friend"
-	"context"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-type paramsAddFriendResponse struct {
-	OperationID string `json:"operationID" binding:"required"`
-	UID         string `json:"uid" binding:"required"`
-	Flag        int32  `json:"flag" binding:"required"`
-}
-
-func AddFriendResponse(c *gin.Context) {
-	log.Info("", "", fmt.Sprintf("api add friend response init ...."))
-
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := pbFriend.NewFriendClient(etcdConn)
-	//defer etcdConn.Close()
-
-	params := paramsAddFriendResponse{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	req := &pbFriend.AddFriendResponseReq{
-		Uid:         params.UID,
-		Flag:        params.Flag,
-		OperationID: params.OperationID,
-		Token:       c.Request.Header.Get("token"),
-	}
-	log.Info(req.Token, req.OperationID, "api add friend response is server:userID=%s", req.Uid)
-	RpcResp, err := client.AddFriendResponse(context.Background(), req)
-	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,call add_friend_response rpc server failed", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add_friend_response rpc server failed"})
-		return
-	}
-	log.InfoByArgs("call add friend response rpc server success,args=%s", RpcResp.String())
-	c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg})
-	log.InfoByArgs("api add friend response success return,get args=%s,return args=%s", req.String(), RpcResp.String())
-}

internal/api/friend/delete_friend.go

@@ -1,48 +0,0 @@
-package friend
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbFriend "Open_IM/pkg/proto/friend"
-	"context"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-type paramsDeleteFriend struct {
-	OperationID string `json:"operationID" binding:"required"`
-	UID         string `json:"uid" binding:"required"`
-}
-
-func DeleteFriend(c *gin.Context) {
-	log.Info("", "", fmt.Sprintf("api delete_friend init ...."))
-
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := pbFriend.NewFriendClient(etcdConn)
-	//defer etcdConn.Close()
-
-	params := paramsDeleteFriend{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	req := &pbFriend.DeleteFriendReq{
-		Uid:         params.UID,
-		OperationID: params.OperationID,
-		Token:       c.Request.Header.Get("token"),
-	}
-	log.Info(req.Token, req.OperationID, "api delete_friend  is server:%s", req.Uid)
-	RpcResp, err := client.DeleteFriend(context.Background(), req)
-	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,call delete_friend rpc server failed", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call delete_friend rpc server failed"})
-		return
-	}
-	log.InfoByArgs("call delete_friend rpc server,args=%s", RpcResp.String())
-	resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg}
-	c.JSON(http.StatusOK, resp)
-	log.InfoByArgs("api delete_friend success return,get args=%s,return args=%s", req.String(), RpcResp.String())
-}

internal/api/friend/friend.go

@@ -0,0 +1,534 @@
+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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	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
+	var errInfo string
+	ok, req.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.OperationID)
+	if etcdConn == nil {
+		errMsg := req.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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 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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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
+	var errInfo string
+	ok, req.CommID.OpUserID, errInfo = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
+	if !ok {
+		errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		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, req.CommID.OperationID)
+	if etcdConn == nil {
+		errMsg := req.CommID.OperationID + "getcdv3.GetConn == nil"
+		log.NewError(req.CommID.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	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/friend/get_blcaklist.go

@@ -1,79 +0,0 @@
-package friend
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbFriend "Open_IM/pkg/proto/friend"
-	"context"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-type paramsGetBlackList struct {
-	OperationID string `json:"operationID" binding:"required"`
-}
-
-type blackListUserInfo struct {
-	UID    string `json:"uid"`
-	Name   string `json:"name"`
-	Icon   string `json:"icon"`
-	Gender int32  `json:"gender"`
-	Mobile string `json:"mobile"`
-	Birth  string `json:"birth"`
-	Email  string `json:"email"`
-	Ex     string `json:"ex"`
-}
-
-func GetBlacklist(c *gin.Context) {
-	log.Info("", "", "api get blacklist init ....")
-
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := pbFriend.NewFriendClient(etcdConn)
-	//defer etcdConn.Close()
-
-	params := paramsGetBlackList{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	req := &pbFriend.GetBlacklistReq{
-		OperationID: params.OperationID,
-		Token:       c.Request.Header.Get("token"),
-	}
-	log.Info(req.Token, req.OperationID, fmt.Sprintf("api get blacklist is server"))
-	RpcResp, err := client.GetBlacklist(context.Background(), req)
-	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,call get_friend_list rpc server failed", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get blacklist rpc server failed"})
-		return
-	}
-	log.InfoByArgs("call get blacklist rpc server success,args=%s", RpcResp.String())
-	if RpcResp.ErrorCode == 0 {
-		userBlackList := make([]blackListUserInfo, 0)
-		for _, friend := range RpcResp.Data {
-			var fi blackListUserInfo
-			fi.UID = friend.Uid
-			fi.Name = friend.Name
-			fi.Icon = friend.Icon
-			fi.Gender = friend.Gender
-			fi.Mobile = friend.Mobile
-			fi.Birth = friend.Birth
-			fi.Email = friend.Email
-			fi.Ex = friend.Ex
-			userBlackList = append(userBlackList, fi)
-		}
-		resp := gin.H{
-			"errCode": RpcResp.ErrorCode,
-			"errMsg":  RpcResp.ErrorMsg,
-			"data":    userBlackList,
-		}
-		c.JSON(http.StatusOK, resp)
-	} else {
-		resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg}
-		c.JSON(http.StatusOK, resp)
-	}
-	log.InfoByArgs("api get black list success return,get args=%s,return=%s", req.String(), RpcResp.String())
-}

internal/api/friend/get_friend_apply_list.go

@@ -1,129 +0,0 @@
-package friend
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/grpc-etcdv3/getcdv3"
-	pbFriend "Open_IM/pkg/proto/friend"
-	"context"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-type paramsGetApplyList struct {
-	OperationID string `json:"operationID" binding:"required"`
-}
-type UserInfo struct {
-	UID        string `json:"uid"`
-	Name       string `json:"name"`
-	Icon       string `json:"icon"`
-	Gender     int32  `json:"gender"`
-	Mobile     string `json:"mobile"`
-	Birth      string `json:"birth"`
-	Email      string `json:"email"`
-	Ex         string `json:"ex"`
-	ReqMessage string `json:"reqMessage"`
-	ApplyTime  string `json:"applyTime"`
-	Flag       int32  `json:"flag"`
-}
-
-func GetFriendApplyList(c *gin.Context) {
-	log.Info("", "", "api get_friend_apply_list init ....")
-
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := pbFriend.NewFriendClient(etcdConn)
-	//defer etcdConn.Close()
-
-	params := paramsGetApplyList{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	req := &pbFriend.GetFriendApplyReq{
-		OperationID: params.OperationID,
-		Token:       c.Request.Header.Get("token"),
-	}
-	log.Info(req.Token, req.OperationID, "api get friend apply list  is server")
-	RpcResp, err := client.GetFriendApplyList(context.Background(), req)
-	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,call get friend apply list rpc server failed", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get friend apply list rpc server failed"})
-		return
-	}
-	log.InfoByArgs("call get friend apply list rpc server success,args=%s", RpcResp.String())
-	if RpcResp.ErrorCode == 0 {
-		userInfoList := make([]UserInfo, 0)
-		for _, applyUserinfo := range RpcResp.Data {
-			var un UserInfo
-			un.UID = applyUserinfo.Uid
-			un.Name = applyUserinfo.Name
-			un.Icon = applyUserinfo.Icon
-			un.Gender = applyUserinfo.Gender
-			un.Mobile = applyUserinfo.Mobile
-			un.Birth = applyUserinfo.Birth
-			un.Email = applyUserinfo.Email
-			un.Ex = applyUserinfo.Ex
-			un.Flag = applyUserinfo.Flag
-			un.ApplyTime = applyUserinfo.ApplyTime
-			un.ReqMessage = applyUserinfo.ReqMessage
-			userInfoList = append(userInfoList, un)
-		}
-		resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg, "data": userInfoList}
-		c.JSON(http.StatusOK, resp)
-	} else {
-		resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg}
-		c.JSON(http.StatusOK, resp)
-	}
-	log.InfoByArgs("api get friend apply list success return,get args=%s,return args=%s", req.String(), RpcResp.String())
-}
-
-func GetSelfApplyList(c *gin.Context) {
-	log.Info("", "", "api get self friend apply list init ....")
-
-	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName)
-	client := pbFriend.NewFriendClient(etcdConn)
-	//defer etcdConn.Close()
-
-	params := paramsGetApplyList{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	req := &pbFriend.GetFriendApplyReq{
-		OperationID: params.OperationID,
-		Token:       c.Request.Header.Get("token"),
-	}
-	log.Info(req.Token, req.OperationID, "api get self apply list  is server")
-	RpcResp, err := client.GetSelfApplyList(context.Background(), req)
-	if err != nil {
-		log.Error(req.Token, req.OperationID, "err=%s,call get self apply list rpc server failed", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get self apply list rpc server failed"})
-		return
-	}
-	log.InfoByArgs("call get self apply list rpc server success,args=%s", RpcResp.String())
-	if RpcResp.ErrorCode == 0 {
-		userInfoList := make([]UserInfo, 0)
-		for _, selfApplyOtherUserinfo := range RpcResp.Data {
-			var un UserInfo
-			un.UID = selfApplyOtherUserinfo.Uid
-			un.Name = selfApplyOtherUserinfo.Name
-			un.Icon = selfApplyOtherUserinfo.Icon
-			un.Gender = selfApplyOtherUserinfo.Gender
-			un.Mobile = selfApplyOtherUserinfo.Mobile
-			un.Birth = selfApplyOtherUserinfo.Birth
-			un.Email = selfApplyOtherUserinfo.Email
-			un.Ex = selfApplyOtherUserinfo.Ex
-			un.Flag = selfApplyOtherUserinfo.Flag
-			un.ApplyTime = selfApplyOtherUserinfo.ApplyTime
-			un.ReqMessage = selfApplyOtherUserinfo.ReqMessage
-			userInfoList = append(userInfoList, un)
-		}
-		resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg, "data": userInfoList}
-		c.JSON(http.StatusOK, resp)
-	} else {
-		resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg}
-		c.JSON(http.StatusOK, resp)
-	}
-	log.InfoByArgs("api get self apply list success return,get args=%s,return args=%s", req.String(), RpcResp.String())
-}