add cmd/open_im_api

2026-05-17 07:19:02 +08:00 · 2021-10-11 21:36:28 +08:00
parent c956add8b0
commit 9367ad901d
35 changed files with 20 additions and 20 deletions
@@ -0,0 +1,91 @@
+package apiAuth
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbAuth "Open_IM/src/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.RpcGetTokenName)
+	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
+	}
+	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,
+		})
+	}
+}
@@ -0,0 +1,68 @@
+package apiAuth
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbAuth "Open_IM/src/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.RpcGetTokenName)
+	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
+	}
+	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,
+		})
+	}
+
+}
@@ -0,0 +1,59 @@
+package apiChat
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbMsg "Open_IM/src/proto/chat"
+	"Open_IM/src/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsUserNewestSeq struct {
+	ReqIdentifier int    `json:"reqIdentifier" binding:"required"`
+	SendID        string `json:"sendID" binding:"required"`
+	OperationID   string `json:"operationID" binding:"required"`
+	MsgIncr       int    `json:"msgIncr" binding:"required"`
+}
+
+func UserNewestSeq(c *gin.Context) {
+	params := paramsUserNewestSeq{}
+	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 !utils.VerifyToken(token, params.SendID) {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"})
+		return
+	}
+	pbData := pbMsg.GetNewSeqReq{}
+	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)
+
+	if grpcConn == nil {
+		log.ErrorByKv("get grpcConn err", pbData.OperationID, "args", params)
+	}
+	msgClient := pbMsg.NewChatClient(grpcConn)
+	reply, err := msgClient.GetNewSeq(context.Background(), &pbData)
+	if err != nil {
+		log.ErrorByKv("rpc call failed to getNewSeq", pbData.OperationID, "err", err, "pbData", pbData.String())
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode":       reply.ErrCode,
+		"errMsg":        reply.ErrMsg,
+		"msgIncr":       params.MsgIncr,
+		"reqIdentifier": params.ReqIdentifier,
+		"data": gin.H{
+			"seq": reply.Seq,
+		},
+	})
+
+}
@@ -0,0 +1,72 @@
+package apiChat
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	"Open_IM/src/proto/chat"
+	"Open_IM/src/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsUserPullMsg struct {
+	ReqIdentifier *int   `json:"reqIdentifier" binding:"required"`
+	SendID        string `json:"sendID" binding:"required"`
+	OperationID   string `json:"operationID" binding:"required"`
+	Data          struct {
+		SeqBegin *int64 `json:"seqBegin" binding:"required"`
+		SeqEnd   *int64 `json:"seqEnd" binding:"required"`
+	}
+}
+
+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 !utils.VerifyToken(token, params.SendID) {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"})
+		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.ErrorByKv("PullMessage error", pbData.OperationID, "err", 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,
+	})
+
+}
@@ -0,0 +1,94 @@
+package apiChat
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	pbChat "Open_IM/src/proto/chat"
+	"Open_IM/src/utils"
+	"context"
+
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsUserSendMsg struct {
+	ReqIdentifier  int32  `json:"reqIdentifier" binding:"required"`
+	PlatformID     int32  `json:"platformID" binding:"required"`
+	SendID         string `json:"sendID" binding:"required"`
+	SenderNickName string `json:"senderNickName"`
+	SenderFaceURL  string `json:"senderFaceUrl"`
+	OperationID    string `json:"operationID" binding:"required"`
+	Data           struct {
+		SessionType int32                  `json:"sessionType" binding:"required"`
+		MsgFrom     int32                  `json:"msgFrom" binding:"required"`
+		ContentType int32                  `json:"contentType" binding:"required"`
+		RecvID      string                 `json:"recvID" binding:"required"`
+		ForceList   []string               `json:"forceList"`
+		Content     string                 `json:"content" binding:"required"`
+		Options     map[string]interface{} `json:"options" `
+		ClientMsgID string                 `json:"clientMsgID" binding:"required"`
+		OffLineInfo map[string]interface{} `json:"offlineInfo" `
+		Ex          map[string]interface{} `json:"ext"`
+	}
+}
+
+func newUserSendMsgReq(token string, params *paramsUserSendMsg) *pbChat.UserSendMsgReq {
+	pbData := pbChat.UserSendMsgReq{
+		ReqIdentifier:  params.ReqIdentifier,
+		Token:          token,
+		SendID:         params.SendID,
+		SenderNickName: params.SenderNickName,
+		SenderFaceURL:  params.SenderFaceURL,
+		OperationID:    params.OperationID,
+		PlatformID:     params.PlatformID,
+		SessionType:    params.Data.SessionType,
+		MsgFrom:        params.Data.MsgFrom,
+		ContentType:    params.Data.ContentType,
+		RecvID:         params.Data.RecvID,
+		ForceList:      params.Data.ForceList,
+		Content:        params.Data.Content,
+		Options:        utils.MapToJsonString(params.Data.Options),
+		ClientMsgID:    params.Data.ClientMsgID,
+		OffLineInfo:    utils.MapToJsonString(params.Data.OffLineInfo),
+		Ex:             utils.MapToJsonString(params.Data.Ex),
+	}
+	return &pbData
+}
+
+func UserSendMsg(c *gin.Context) {
+	params := paramsUserSendMsg{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		log.ErrorByKv("json unmarshal err", "", "err", err.Error(), "data", c.PostForm("data"))
+		return
+	}
+
+	token := c.Request.Header.Get("token")
+
+	log.InfoByKv("Ws call success to sendMsgReq", params.OperationID, "Parameters", params)
+
+	pbData := newUserSendMsgReq(token, &params)
+	log.Info("", "", "api UserSendMsg call start..., [data: %s]", pbData.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	client := pbChat.NewChatClient(etcdConn)
+
+	log.Info("", "", "api UserSendMsg call, api call rpc...")
+
+	reply, _ := client.UserSendMsg(context.Background(), pbData)
+	log.Info("", "", "api UserSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode":       reply.ErrCode,
+		"errMsg":        reply.ErrMsg,
+		"reqIdentifier": reply.ReqIdentifier,
+		"data": gin.H{
+			"clientMsgID": reply.ClientMsgID,
+			"serverMsgID": reply.ServerMsgID,
+			"sendTime":    reply.SendTime,
+		},
+	})
+
+}
@@ -0,0 +1,49 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/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())
+}
@@ -0,0 +1,84 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/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 ....")
+
+	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"),
+	}
+	RpcResp, err := client.ImportFriend(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "err=%s,ImportFriend failed", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "cImportFriend failed" + err.Error()})
+		return
+	}
+	log.InfoByArgs("ImportFriend  success,args=%s", RpcResp.String())
+	resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "failedUidList": RpcResp.FailedUidList}
+	c.JSON(http.StatusOK, resp)
+	log.InfoByArgs("ImportFriend success return,get args=%s,return args=%s", req.String(), RpcResp.String())
+}
+
+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())
+	resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg}
+	c.JSON(http.StatusOK, resp)
+	log.InfoByArgs("api add friend success return,get args=%s,return args=%s", req.String(), RpcResp.String())
+}
@@ -0,0 +1,49 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/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())
+}
@@ -0,0 +1,48 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/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())
+}
@@ -0,0 +1,79 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/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())
+}
@@ -0,0 +1,129 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/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())
+}
@@ -0,0 +1,83 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/proto/friend"
+	"context"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsGetFriendLIst struct {
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+type friendInfo 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"`
+	Comment       string `json:"comment"`
+	IsInBlackList int32  `json:"isInBlackList"`
+}
+
+func GetFriendList(c *gin.Context) {
+	log.Info("", "", fmt.Sprintf("api get_friendlist 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 := paramsGetFriendLIst{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbFriend.GetFriendListReq{
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "api get friend list is server")
+	RpcResp, err := client.GetFriendList(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 friend list rpc server failed"})
+		return
+	}
+	log.InfoByArgs("call get friend list rpc server success,args=%s", RpcResp.String())
+	if RpcResp.ErrorCode == 0 {
+		friendsInfo := make([]friendInfo, 0)
+		for _, friend := range RpcResp.Data {
+			var fi friendInfo
+			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
+			fi.Comment = friend.Comment
+			fi.IsInBlackList = friend.IsInBlackList
+			friendsInfo = append(friendsInfo, fi)
+		}
+		resp := gin.H{
+			"errCode": RpcResp.ErrorCode,
+			"errMsg":  RpcResp.ErrorMsg,
+			"data":    friendsInfo,
+		}
+		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 list success return,get args=%s,return=%s", req.String(), RpcResp.String())
+}
@@ -0,0 +1,70 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/proto/friend"
+	"context"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsSearchFriend struct {
+	OperationID string `json:"operationID" binding:"required"`
+	UID         string `json:"uid" binding:"required"`
+	OwnerUid    string `json:"ownerUid"`
+}
+
+func GetFriendsInfo(c *gin.Context) {
+	log.Info("", "", fmt.Sprintf("api search 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 := paramsSearchFriend{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbFriend.GetFriendsInfoReq{
+		Uid:         params.UID,
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "api search_friend is server")
+	RpcResp, err := client.GetFriendsInfo(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "err=%s,call search friend rpc server failed", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call search friend rpc server failed"})
+		return
+	}
+	log.InfoByArgs("call search friend rpc server success,args=%s", RpcResp.String())
+	if RpcResp.ErrorCode == 0 {
+		resp := gin.H{
+			"errCode": RpcResp.ErrorCode,
+			"errMsg":  RpcResp.ErrorMsg,
+			"data": gin.H{
+				"uid":     RpcResp.Data.Uid,
+				"icon":    RpcResp.Data.Icon,
+				"name":    RpcResp.Data.Name,
+				"gender":  RpcResp.Data.Gender,
+				"mobile":  RpcResp.Data.Mobile,
+				"birth":   RpcResp.Data.Birth,
+				"email":   RpcResp.Data.Email,
+				"ex":      RpcResp.Data.Ex,
+				"comment": RpcResp.Data.Comment,
+			},
+		}
+		c.JSON(http.StatusOK, resp)
+	} else {
+		resp := gin.H{
+			"errCode": RpcResp.ErrorCode,
+			"errMsg":  RpcResp.ErrorMsg,
+		}
+		c.JSON(http.StatusOK, resp)
+	}
+	log.InfoByArgs("api search_friend success return,get args=%s,return=%s", req.String(), RpcResp.String())
+}
@@ -0,0 +1,47 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/proto/friend"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsIsFriend struct {
+	OperationID string `json:"operationID" binding:"required"`
+	ReceiveUid  string `json:"receive_uid"`
+}
+
+func IsFriend(c *gin.Context) {
+	log.Info("", "", "api is 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 := paramsIsFriend{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbFriend.IsFriendReq{
+		OperationID: params.OperationID,
+		ReceiveUid:  params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "api is friend is server")
+	RpcResp, err := client.IsFriend(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 is friend rpc server success,args=%s", RpcResp.String())
+	resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg, "isFriend": RpcResp.ShipType}
+	c.JSON(http.StatusOK, resp)
+	log.InfoByArgs("api is friend success return,get args=%s,return args=%s", req.String(), RpcResp.String())
+}
@@ -0,0 +1,47 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/proto/friend"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsRemoveBlackList struct {
+	OperationID string `json:"operationID" binding:"required"`
+	UID         string `json:"uid" binding:"required"`
+}
+
+func RemoveBlacklist(c *gin.Context) {
+	log.Info("", "", "api remove_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 := paramsRemoveBlackList{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbFriend.RemoveBlacklistReq{
+		Uid:         params.UID,
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "api remove blacklist is server:userID=%s", req.Uid)
+	RpcResp, err := client.RemoveBlacklist(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "err=%s,call remove blacklist rpc server failed", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call remove blacklist rpc server failed"})
+		return
+	}
+	log.InfoByArgs("call remove 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 remove blacklist success return,get args=%s,return args=%s", req.String(), RpcResp.String())
+}
@@ -0,0 +1,48 @@
+package friend
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbFriend "Open_IM/src/proto/friend"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsSetFriendComment struct {
+	OperationID string `json:"operationID" binding:"required"`
+	UID         string `json:"uid" binding:"required"`
+	Comment     string `json:"comment"`
+}
+
+func SetFriendComment(c *gin.Context) {
+	log.Info("", "", "api set friend comment 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 := paramsSetFriendComment{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbFriend.SetFriendCommentReq{
+		Uid:         params.UID,
+		OperationID: params.OperationID,
+		Comment:     params.Comment,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "api set friend comment is server")
+	RpcResp, err := client.SetFriendComment(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "err=%s,call set friend comment rpc server failed", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call set friend comment rpc server failed"})
+		return
+	}
+	log.Info("", "", "call set friend comment rpc server success,args=%s", RpcResp.String())
+	c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg})
+	log.Info("", "", "api set friend comment success return,get args=%s,return args=%s", req.String(), RpcResp.String())
+}
@@ -0,0 +1,61 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pb "Open_IM/src/proto/group"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsCreateGroupStruct struct {
+	MemberList   []*pb.GroupAddMemberInfo `json:"memberList"`
+	GroupName    string                   `json:"groupName"`
+	Introduction string                   `json:"introduction"`
+	Notification string                   `json:"notification"`
+	FaceUrl      string                   `json:"faceUrl"`
+	OperationID  string                   `json:"operationID" binding:"required"`
+	Ex           string                   `json:"ex"`
+}
+
+func CreateGroup(c *gin.Context) {
+	log.Info("", "", "api create group init ....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsCreateGroupStruct{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.CreateGroupReq{
+		MemberList:   params.MemberList,
+		GroupName:    params.GroupName,
+		Introduction: params.Introduction,
+		Notification: params.Notification,
+		FaceUrl:      params.FaceUrl,
+		OperationID:  params.OperationID,
+		Ex:           params.Ex,
+		Token:        c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "api create group is server,params=%s", req.String())
+	RpcResp, err := client.CreateGroup(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "err=%s,call create group  rpc server failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	log.InfoByArgs("call create group  rpc server success,args=%s", RpcResp.String())
+	if RpcResp.ErrorCode == 0 {
+		resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg, "data": gin.H{"groupID": RpcResp.GroupID}}
+		c.JSON(http.StatusOK, resp)
+	} else {
+		c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg})
+	}
+	log.InfoByArgs("api create group success return,get args=%s,return args=%s", req.String(), RpcResp.String())
+}
@@ -0,0 +1,113 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	"Open_IM/src/proto/group"
+	"Open_IM/src/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsGroupApplicationList struct {
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+func newUserRegisterReq(params *paramsGroupApplicationList) *group.GetGroupApplicationListReq {
+	pbData := group.GetGroupApplicationListReq{
+		OperationID: params.OperationID,
+	}
+	return &pbData
+}
+
+type paramsGroupApplicationListRet struct {
+	ID               string `json:"id"`
+	GroupID          string `json:"groupID"`
+	FromUserID       string `json:"fromUserID"`
+	ToUserID         string `json:"toUserID"`
+	Flag             int32  `json:"flag"`
+	RequestMsg       string `json:"reqMsg"`
+	HandledMsg       string `json:"handledMsg"`
+	AddTime          int64  `json:"createTime"`
+	FromUserNickname string `json:"fromUserNickName"`
+	ToUserNickname   string `json:"toUserNickName"`
+	FromUserFaceUrl  string `json:"fromUserFaceURL"`
+	ToUserFaceUrl    string `json:"toUserFaceURL"`
+	HandledUser      string `json:"handledUser"`
+	Type             int32  `json:"type"`
+	HandleStatus     int32  `json:"handleStatus"`
+	HandleResult     int32  `json:"handleResult"`
+}
+
+func GetGroupApplicationList(c *gin.Context) {
+	log.Info("", "", "api GetGroupApplicationList init ....")
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := group.NewGroupClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsGroupApplicationList{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	pbData := newUserRegisterReq(&params)
+
+	token := c.Request.Header.Get("token")
+	if claims, err := utils.ParseToken(token); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"})
+		return
+	} else {
+		pbData.UID = claims.UID
+	}
+
+	log.Info("", "", "api GetGroupApplicationList is server, [data: %s]", pbData.String())
+	reply, err := client.GetGroupApplicationList(context.Background(), pbData)
+	if err != nil {
+		log.Error("", "", "api GetGroupApplicationList 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 GetGroupApplicationList call rpc success, [data: %s] [reply: %s]", pbData.String(), reply.String())
+
+	unProcessCount := 0
+	userReq := make([]paramsGroupApplicationListRet, 0)
+	if reply != nil && reply.Data != nil && reply.Data.User != nil {
+		for i := 0; i < len(reply.Data.User); i++ {
+			req := paramsGroupApplicationListRet{}
+			req.ID = reply.Data.User[i].ID
+			req.GroupID = reply.Data.User[i].GroupID
+			req.FromUserID = reply.Data.User[i].FromUserID
+			req.ToUserID = reply.Data.User[i].ToUserID
+			req.Flag = reply.Data.User[i].Flag
+			req.RequestMsg = reply.Data.User[i].RequestMsg
+			req.HandledMsg = reply.Data.User[i].HandledMsg
+			req.AddTime = reply.Data.User[i].AddTime
+			req.FromUserNickname = reply.Data.User[i].FromUserNickname
+			req.ToUserNickname = reply.Data.User[i].ToUserNickname
+			req.FromUserFaceUrl = reply.Data.User[i].FromUserFaceUrl
+			req.ToUserFaceUrl = reply.Data.User[i].ToUserFaceUrl
+			req.HandledUser = reply.Data.User[i].HandledUser
+			req.Type = reply.Data.User[i].Type
+			req.HandleStatus = reply.Data.User[i].HandleStatus
+			req.HandleResult = reply.Data.User[i].HandleResult
+			userReq = append(userReq, req)
+
+			if req.Flag == 0 {
+				unProcessCount++
+			}
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode": reply.ErrCode,
+		"errMsg":  reply.ErrMsg,
+		"data": gin.H{
+			"count": unProcessCount,
+			"user":  userReq,
+		},
+	})
+
+}
@@ -0,0 +1,67 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pb "Open_IM/src/proto/group"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsGetGroupInfo struct {
+	GroupIDList []string `json:"groupIDList" binding:"required"`
+	OperationID string   `json:"operationID" binding:"required"`
+}
+
+func GetGroupsInfo(c *gin.Context) {
+	log.Info("", "", "api get groups info init ....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsGetGroupInfo{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.GetGroupsInfoReq{
+		GroupIDList: params.GroupIDList,
+		Token:       c.Request.Header.Get("token"),
+		OperationID: params.OperationID,
+	}
+	log.Info(req.Token, req.OperationID, "get groups info is server,params=%s", req.String())
+	RpcResp, err := client.GetGroupsInfo(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "call get groups info rpc server failed,err=%s", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	log.InfoByArgs("call get groups info rpc server success", RpcResp.String())
+	if RpcResp.ErrorCode == 0 {
+		groupsInfo := make([]pb.GroupInfo, 0)
+		for _, v := range RpcResp.Data {
+			var groupInfo pb.GroupInfo
+			groupInfo.GroupId = v.GroupId
+			groupInfo.GroupName = v.GroupName
+			groupInfo.Notification = v.Notification
+			groupInfo.Introduction = v.Introduction
+			groupInfo.FaceUrl = v.FaceUrl
+			groupInfo.CreateTime = v.CreateTime
+			groupInfo.OwnerId = v.OwnerId
+			groupInfo.MemberCount = v.MemberCount
+
+			groupsInfo = append(groupsInfo, groupInfo)
+		}
+		c.JSON(http.StatusOK, gin.H{
+			"errCode": RpcResp.ErrorCode,
+			"errMsg":  RpcResp.ErrorMsg,
+			"data":    groupsInfo,
+		})
+	} else {
+		c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg})
+	}
+}
@@ -0,0 +1,351 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pb "Open_IM/src/proto/group"
+	"context"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type InviteUserToGroupReq struct {
+	GroupID     string   `json:"groupID" binding:"required"`
+	UidList     []string `json:"uidList" binding:"required"`
+	Reason      string   `json:"reason"`
+	OperationID string   `json:"operationID" binding:"required"`
+}
+
+type GetJoinedGroupListReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+type KickGroupMemberReq struct {
+	GroupID     string                    `json:"groupID"`
+	UidListInfo []*pb.GroupMemberFullInfo `json:"uidListInfo" binding:"required"`
+	Reason      string                    `json:"reason"`
+	OperationID string                    `json:"operationID" binding:"required"`
+}
+
+func KickGroupMember(c *gin.Context) {
+	log.Info("", "", "KickGroupMember start....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+
+	params := KickGroupMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &pb.KickGroupMemberReq{
+		OperationID: params.OperationID,
+		GroupID:     params.GroupID,
+		Token:       c.Request.Header.Get("token"),
+
+		UidListInfo: params.UidListInfo,
+	}
+	log.Info(req.Token, req.OperationID, "recv req: ", req.String())
+
+	RpcResp, err := client.KickGroupMember(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "GetGroupMemberList failed, err: ", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	type KickGroupMemberResp struct {
+		ErrorCode int32       `json:"errCode"`
+		ErrorMsg  string      `json:"errMsg"`
+		Data      []Id2Result `json:"data"`
+	}
+
+	var memberListResp KickGroupMemberResp
+	memberListResp.ErrorMsg = RpcResp.ErrorMsg
+	memberListResp.ErrorCode = RpcResp.ErrorCode
+	for _, v := range RpcResp.Id2Result {
+		memberListResp.Data = append(memberListResp.Data,
+			Id2Result{UId: v.UId,
+				Result: v.Result})
+	}
+	c.JSON(http.StatusOK, memberListResp)
+}
+
+type GetGroupMembersInfoReq struct {
+	GroupID     string   `json:"groupID"`
+	MemberList  []string `json:"memberList"`
+	OperationID string   `json:"operationID"`
+}
+type GetGroupMembersInfoResp struct {
+	ErrorCode int32          `json:"errCode"`
+	ErrorMsg  string         `json:"errMsg"`
+	Data      []MemberResult `json:"data"`
+}
+
+func GetGroupMembersInfo(c *gin.Context) {
+	log.Info("", "", "GetGroupMembersInfo start....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+
+	params := GetGroupMembersInfoReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &pb.GetGroupMembersInfoReq{
+		OperationID: params.OperationID,
+		GroupID:     params.GroupID,
+		MemberList:  params.MemberList,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "recv req: ", len(params.MemberList))
+
+	RpcResp, err := client.GetGroupMembersInfo(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "GetGroupMemberList failed, err: ", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	var memberListResp GetGroupMembersInfoResp
+	memberListResp.ErrorMsg = RpcResp.ErrorMsg
+	memberListResp.ErrorCode = RpcResp.ErrorCode
+	for _, v := range RpcResp.MemberList {
+		memberListResp.Data = append(memberListResp.Data,
+			MemberResult{GroupId: req.GroupID,
+				UserId:   v.UserId,
+				Role:     v.Role,
+				JoinTime: uint64(v.JoinTime),
+				Nickname: v.NickName,
+				FaceUrl:  v.FaceUrl})
+	}
+	c.JSON(http.StatusOK, memberListResp)
+}
+
+type GetGroupMemberListReq struct {
+	GroupID     string `json:"groupID"`
+	Filter      int32  `json:"filter"`
+	NextSeq     int32  `json:"nextSeq"`
+	OperationID string `json:"operationID"`
+}
+type getGroupAllMemberReq struct {
+	GroupID     string `json:"groupID"`
+	OperationID string `json:"operationID"`
+}
+
+type MemberResult struct {
+	GroupId  string `json:"groupID"`
+	UserId   string `json:"userId"`
+	Role     int32  `json:"role"`
+	JoinTime uint64 `json:"joinTime"`
+	Nickname string `json:"nickName"`
+	FaceUrl  string `json:"faceUrl"`
+}
+
+func GetGroupMemberList(c *gin.Context) {
+	log.Info("", "", "GetGroupMemberList start....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+
+	params := GetGroupMemberListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.GetGroupMemberListReq{
+		OperationID: params.OperationID,
+		Filter:      params.Filter,
+		NextSeq:     params.NextSeq,
+		GroupID:     params.GroupID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "recv req: ", req.String())
+	RpcResp, err := client.GetGroupMemberList(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "GetGroupMemberList failed, err: ", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	type GetGroupMemberListResp struct {
+		ErrorCode int32          `json:"errCode"`
+		ErrorMsg  string         `json:"errMsg"`
+		NextSeq   int32          `json:"nextSeq"`
+		Data      []MemberResult `json:"data"`
+	}
+
+	var memberListResp GetGroupMemberListResp
+	memberListResp.ErrorMsg = RpcResp.ErrorMsg
+	memberListResp.ErrorCode = RpcResp.ErrorCode
+	memberListResp.NextSeq = RpcResp.NextSeq
+	for _, v := range RpcResp.MemberList {
+		memberListResp.Data = append(memberListResp.Data,
+			MemberResult{GroupId: req.GroupID,
+				UserId:   v.UserId,
+				Role:     v.Role,
+				JoinTime: uint64(v.JoinTime),
+				Nickname: v.NickName,
+				FaceUrl:  v.FaceUrl})
+	}
+	c.JSON(http.StatusOK, memberListResp)
+
+}
+
+func GetGroupAllMember(c *gin.Context) {
+	log.Info("", "", "GetGroupAllMember start....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+
+	params := getGroupAllMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.GetGroupAllMemberReq{
+		GroupID:     params.GroupID,
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "recv req: ", req.String())
+	RpcResp, err := client.GetGroupAllMember(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "GetGroupAllMember failed, err: ", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	type GetGroupMemberListResp struct {
+		ErrorCode int32          `json:"errCode"`
+		ErrorMsg  string         `json:"errMsg"`
+		Data      []MemberResult `json:"data"`
+	}
+
+	var memberListResp GetGroupMemberListResp
+	memberListResp.ErrorMsg = RpcResp.ErrorMsg
+	memberListResp.ErrorCode = RpcResp.ErrorCode
+	for _, v := range RpcResp.MemberList {
+		memberListResp.Data = append(memberListResp.Data,
+			MemberResult{GroupId: req.GroupID,
+				UserId:   v.UserId,
+				Role:     v.Role,
+				JoinTime: uint64(v.JoinTime),
+				Nickname: v.NickName,
+				FaceUrl:  v.FaceUrl})
+	}
+	c.JSON(http.StatusOK, memberListResp)
+}
+
+type groupResult struct {
+	GroupId      string `json:"groupId"`
+	GroupName    string `json:"groupName"`
+	Notification string `json:"notification"`
+	Introduction string `json:"introduction"`
+	FaceUrl      string `json:"faceUrl"`
+	OwnerId      string `json:"ownerId"`
+	CreateTime   uint64 `json:"createTime"`
+	MemberCount  uint32 `json:"memberCount"`
+}
+
+func GetJoinedGroupList(c *gin.Context) {
+	log.Info("", "", "GetJoinedGroupList start....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	fmt.Println("config:    ", etcdConn, config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+
+	params := GetJoinedGroupListReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.GetJoinedGroupListReq{
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "recv req: ", req.String())
+
+	RpcResp, err := client.GetJoinedGroupList(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "GetJoinedGroupList failed, err: ", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+	log.Info(req.Token, req.OperationID, "GetJoinedGroupList: ", RpcResp)
+
+	type GetJoinedGroupListResp struct {
+		ErrorCode int32         `json:"errCode"`
+		ErrorMsg  string        `json:"errMsg"`
+		Data      []groupResult `json:"data"`
+	}
+
+	var GroupListResp GetJoinedGroupListResp
+	GroupListResp.ErrorCode = RpcResp.ErrorCode
+	GroupListResp.ErrorMsg = RpcResp.ErrorMsg
+	for _, v := range RpcResp.GroupList {
+		GroupListResp.Data = append(GroupListResp.Data,
+			groupResult{GroupId: v.GroupId, GroupName: v.GroupName,
+				Notification: v.Notification,
+				Introduction: v.Introduction,
+				FaceUrl:      v.FaceUrl,
+				OwnerId:      v.OwnerId,
+				CreateTime:   v.CreateTime,
+				MemberCount:  v.MemberCount})
+	}
+	c.JSON(http.StatusOK, GroupListResp)
+}
+
+type Id2Result struct {
+	UId    string `json:"uid"`
+	Result int32  `json:"result"`
+}
+
+func InviteUserToGroup(c *gin.Context) {
+	log.Info("", "", "InviteUserToGroup start....")
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+
+	params := InviteUserToGroupReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.InviteUserToGroupReq{
+		OperationID: params.OperationID,
+		GroupID:     params.GroupID,
+		Reason:      params.Reason,
+		UidList:     params.UidList,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "recv req: ", req.String())
+
+	RpcResp, err := client.InviteUserToGroup(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "InviteUserToGroup failed, err: ", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	type InviteUserToGroupResp struct {
+		ErrorCode int32       `json:"errCode"`
+		ErrorMsg  string      `json:"errMsg"`
+		I2R       []Id2Result `json:"data"`
+	}
+
+	var iResp InviteUserToGroupResp
+	iResp.ErrorMsg = RpcResp.ErrorMsg
+	iResp.ErrorCode = RpcResp.ErrorCode
+	for _, v := range RpcResp.Id2Result {
+		iResp.I2R = append(iResp.I2R, Id2Result{UId: v.UId, Result: v.Result})
+	}
+
+	//resp := gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg, "data": RpcResp.Id2Result}
+	c.JSON(http.StatusOK, iResp)
+}
@@ -0,0 +1,87 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	"Open_IM/src/proto/group"
+	"Open_IM/src/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsGroupApplicationResponse struct {
+	OperationID      string `json:"operationID" binding:"required"`
+	GroupID          string `json:"groupID" binding:"required"`
+	FromUserID       string `json:"fromUserID" binding:"required"`
+	FromUserNickName string `json:"fromUserNickName"`
+	FromUserFaceUrl  string `json:"fromUserFaceUrl"`
+	ToUserID         string `json:"toUserID" binding:"required"`
+	ToUserNickName   string `json:"toUserNickName"`
+	ToUserFaceUrl    string `json:"toUserFaceUrl"`
+	AddTime          int64  `json:"addTime"`
+	RequestMsg       string `json:"requestMsg"`
+	HandledMsg       string `json:"handledMsg"`
+	Type             int32  `json:"type"`
+	HandleStatus     int32  `json:"handleStatus"`
+	HandleResult     int32  `json:"handleResult"`
+}
+
+func newGroupApplicationResponse(params *paramsGroupApplicationResponse) *group.GroupApplicationResponseReq {
+	pbData := group.GroupApplicationResponseReq{
+		OperationID:      params.OperationID,
+		GroupID:          params.GroupID,
+		FromUserID:       params.FromUserID,
+		FromUserNickName: params.FromUserNickName,
+		FromUserFaceUrl:  params.FromUserFaceUrl,
+		ToUserID:         params.ToUserID,
+		ToUserNickName:   params.ToUserNickName,
+		ToUserFaceUrl:    params.ToUserFaceUrl,
+		AddTime:          params.AddTime,
+		RequestMsg:       params.RequestMsg,
+		HandledMsg:       params.HandledMsg,
+		Type:             params.Type,
+		HandleStatus:     params.HandleStatus,
+		HandleResult:     params.HandleResult,
+	}
+	return &pbData
+}
+
+func ApplicationGroupResponse(c *gin.Context) {
+	log.Info("", "", "api GroupApplicationResponse init ....")
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := group.NewGroupClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsGroupApplicationResponse{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	pbData := newGroupApplicationResponse(&params)
+
+	token := c.Request.Header.Get("token")
+	if claims, err := utils.ParseToken(token); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"})
+		return
+	} else {
+		pbData.OwnerID = claims.UID
+	}
+
+	log.Info("", "", "api GroupApplicationResponse is server, [data: %s]", pbData.String())
+	reply, err := client.GroupApplicationResponse(context.Background(), pbData)
+	if err != nil {
+		log.Error("", "", "api GroupApplicationResponse 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 GroupApplicationResponse call rpc success, [data: %s] [reply: %s]", pbData.String(), reply.String())
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode": reply.ErrCode,
+		"errMsg":  reply.ErrMsg,
+	})
+
+}
@@ -0,0 +1,47 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pb "Open_IM/src/proto/group"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsJoinGroup struct {
+	GroupID     string `json:"groupID" binding:"required"`
+	Message     string `json:"message"`
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+func JoinGroup(c *gin.Context) {
+	log.Info("", "", "api join group init....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsJoinGroup{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.JoinGroupReq{
+		GroupID:     params.GroupID,
+		Message:     params.Message,
+		Token:       c.Request.Header.Get("token"),
+		OperationID: params.OperationID,
+	}
+	log.Info(req.Token, req.OperationID, "api join group is server,params=%s", req.String())
+	RpcResp, err := client.JoinGroup(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "call join group  rpc server failed,err=%s", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	log.InfoByArgs("call join group rpc server success,args=%s", RpcResp.String())
+	c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg})
+}
@@ -0,0 +1,46 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pb "Open_IM/src/proto/group"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsQuitGroup struct {
+	GroupID     string `json:"groupID" binding:"required"`
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+func QuitGroup(c *gin.Context) {
+	log.Info("", "", "api quit group init ....")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsQuitGroup{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.QuitGroupReq{
+		GroupID:     params.GroupID,
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.Info(req.Token, req.OperationID, "api quit group is server,params=%s", req.String())
+	RpcResp, err := client.QuitGroup(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "call quit group rpc server failed,err=%s", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	log.InfoByArgs("call quit group rpc server success,args=%s", RpcResp.String())
+	c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg})
+	log.InfoByArgs("api quit group success return,get args=%s,return args=%s", req.String(), RpcResp.String())
+}
@@ -0,0 +1,53 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pb "Open_IM/src/proto/group"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsSetGroupInfo struct {
+	GroupID      string `json:"groupId"  binding:"required"`
+	GroupName    string `json:"groupName"`
+	Notification string `json:"notification"`
+	Introduction string `json:"introduction"`
+	FaceUrl      string `json:"faceUrl"`
+	OperationID  string `json:"operationID"  binding:"required"`
+}
+
+func SetGroupInfo(c *gin.Context) {
+	log.Info("", "", "api set group info init...")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pb.NewGroupClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsSetGroupInfo{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pb.SetGroupInfoReq{
+		GroupID:      params.GroupID,
+		GroupName:    params.GroupName,
+		Notification: params.Notification,
+		Introduction: params.Introduction,
+		FaceUrl:      params.FaceUrl,
+		Token:        c.Request.Header.Get("token"),
+		OperationID:  params.OperationID,
+	}
+	log.Info(req.Token, req.OperationID, "api set group info is server,params=%s", req.String())
+	RpcResp, err := client.SetGroupInfo(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "call set group info rpc server failed,err=%s", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	log.InfoByArgs("call set group info rpc server success,args=%s", RpcResp.String())
+	c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg})
+}
@@ -0,0 +1,65 @@
+package group
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	"Open_IM/src/proto/group"
+	"Open_IM/src/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsTransferGroupOwner struct {
+	OperationID string `json:"operationID" binding:"required"`
+	GroupID     string `json:"groupID" binding:"required"`
+	UID         string `json:"uid" binding:"required"`
+}
+
+func newTransferGroupOwnerReq(params *paramsTransferGroupOwner) *group.TransferGroupOwnerReq {
+	pbData := group.TransferGroupOwnerReq{
+		OperationID: params.OperationID,
+		GroupID:     params.GroupID,
+		NewOwner:    params.UID,
+	}
+	return &pbData
+}
+
+func TransferGroupOwner(c *gin.Context) {
+	log.Info("", "", "api TransferGroupOwner init ....")
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := group.NewGroupClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsTransferGroupOwner{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	pbData := newTransferGroupOwnerReq(&params)
+
+	token := c.Request.Header.Get("token")
+	if claims, err := utils.ParseToken(token); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err"})
+		return
+	} else {
+		pbData.OldOwner = claims.UID
+	}
+
+	log.Info("", "", "api TransferGroupOwner is server, [data: %s]", pbData.String())
+	reply, err := client.TransferGroupOwner(context.Background(), pbData)
+	if err != nil {
+		log.Error("", "", "api TransferGroupOwner 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 TransferGroupOwner call rpc success, [data: %s] [reply: %s]", pbData.String(), reply.String())
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode": reply.ErrCode,
+		"errMsg":  reply.ErrMsg,
+	})
+
+}
@@ -0,0 +1,205 @@
+/*
+** description("").
+** copyright('open-im,www.open-im.io').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/9/15 15:23).
+ */
+package manage
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/constant"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbChat "Open_IM/src/proto/chat"
+	"Open_IM/src/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+	"github.com/mitchellh/mapstructure"
+	"net/http"
+	"strings"
+)
+
+var validate *validator.Validate
+
+type paramsManagementSendMsg struct {
+	OperationID    string                 `json:"operationID" binding:"required"`
+	SendID         string                 `json:"sendID" binding:"required"`
+	RecvID         string                 `json:"recvID" binding:"required"`
+	SenderNickName string                 `json:"senderNickName" `
+	SenderFaceURL  string                 `json:"senderFaceURL" `
+	ForceList      []string               `json:"forceList" `
+	Content        map[string]interface{} `json:"content" binding:"required"`
+	ContentType    int32                  `json:"contentType" binding:"required"`
+	SessionType    int32                  `json:"sessionType" binding:"required"`
+}
+
+func newUserSendMsgReq(token string, params *paramsManagementSendMsg) *pbChat.UserSendMsgReq {
+	var newContent string
+	switch params.ContentType {
+	case constant.Text:
+		newContent = params.Content["text"].(string)
+	case constant.Picture:
+		fallthrough
+	case constant.Custom:
+		fallthrough
+	case constant.Voice:
+		fallthrough
+	case constant.File:
+		newContent = utils.StructToJsonString(params.Content)
+	default:
+
+	}
+	pbData := pbChat.UserSendMsgReq{
+		ReqIdentifier:  constant.WSSendMsg,
+		Token:          token,
+		SendID:         params.SendID,
+		SenderNickName: params.SenderNickName,
+		SenderFaceURL:  params.SenderFaceURL,
+		OperationID:    params.OperationID,
+		PlatformID:     0,
+		SessionType:    params.SessionType,
+		MsgFrom:        constant.UserMsgType,
+		ContentType:    params.ContentType,
+		RecvID:         params.RecvID,
+		ForceList:      params.ForceList,
+		Content:        newContent,
+		ClientMsgID:    utils.GetMsgID(params.SendID),
+	}
+	return &pbData
+}
+func init() {
+	validate = validator.New()
+}
+func ManagementSendMsg(c *gin.Context) {
+	var data interface{}
+	params := paramsManagementSendMsg{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		log.ErrorByKv("json unmarshal err", c.PostForm("operationID"), "err", err.Error(), "content", c.PostForm("content"))
+		return
+	}
+	switch params.ContentType {
+	case constant.Text:
+		data = TextElem{}
+	case constant.Picture:
+		data = PictureElem{}
+	case constant.Custom:
+		data = CustomElem{}
+	default:
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 404, "errMsg": "contentType err"})
+		log.ErrorByKv("contentType err", c.PostForm("operationID"), "content", c.PostForm("content"))
+		return
+	}
+	if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": err.Error()})
+		log.ErrorByKv("content to Data struct  err", "", "err", err.Error())
+		return
+	} else if err := validate.Struct(data); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 403, "errMsg": err.Error()})
+		log.ErrorByKv("data args validate  err", "", "err", err.Error())
+		return
+	}
+
+	token := c.Request.Header.Get("token")
+	if !utils.IsContain(params.SendID, config.Config.Manager.AppManagerUid) {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "not appManager", "sendTime": 0, "MsgID": ""})
+		return
+
+	}
+
+	log.InfoByKv("Ws call success to ManagementSendMsgReq", params.OperationID, "Parameters", params)
+
+	pbData := newUserSendMsgReq(token, &params)
+	log.Info("", "", "api ManagementSendMsg call start..., [data: %s]", pbData.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOfflineMessageName)
+	client := pbChat.NewChatClient(etcdConn)
+
+	log.Info("", "", "api ManagementSendMsg call, api call rpc...")
+
+	reply, _ := client.UserSendMsg(context.Background(), pbData)
+	log.Info("", "", "api ManagementSendMsg call end..., [data: %s] [reply: %s]", pbData.String(), reply.String())
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode":  reply.ErrCode,
+		"errMsg":   reply.ErrMsg,
+		"sendTime": reply.SendTime,
+		"msgID":    reply.ClientMsgID,
+	})
+
+}
+
+type PictureBaseInfo struct {
+	UUID   string `mapstructure:"uuid"`
+	Type   string `mapstructure:"type" validate:"required"`
+	Size   int64  `mapstructure:"size" validate:"required"`
+	Width  int32  `mapstructure:"width" validate:"required"`
+	Height int32  `mapstructure:"height" validate:"required"`
+	Url    string `mapstructure:"url" validate:"required"`
+}
+
+type PictureElem struct {
+	SourcePath      string          `mapstructure:"sourcePath"`
+	SourcePicture   PictureBaseInfo `mapstructure:"sourcePicture" validate:"required"`
+	BigPicture      PictureBaseInfo `mapstructure:"bigPicture" `
+	SnapshotPicture PictureBaseInfo `mapstructure:"snapshotPicture"`
+}
+type SoundElem struct {
+	UUID      string `mapstructure:"uuid"`
+	SoundPath string `mapstructure:"soundPath"`
+	SourceURL string `mapstructure:"sourceUrl"`
+	DataSize  int64  `mapstructure:"dataSize"`
+	Duration  int64  `mapstructure:"duration"`
+}
+type VideoElem struct {
+	VideoPath      string `mapstructure:"videoPath"`
+	VideoUUID      string `mapstructure:"videoUUID"`
+	VideoURL       string `mapstructure:"videoUrl"`
+	VideoType      string `mapstructure:"videoType"`
+	VideoSize      int64  `mapstructure:"videoSize"`
+	Duration       int64  `mapstructure:"duration"`
+	SnapshotPath   string `mapstructure:"snapshotPath"`
+	SnapshotUUID   string `mapstructure:"snapshotUUID"`
+	SnapshotSize   int64  `mapstructure:"snapshotSize"`
+	SnapshotURL    string `mapstructure:"snapshotUrl"`
+	SnapshotWidth  int32  `mapstructure:"snapshotWidth"`
+	SnapshotHeight int32  `mapstructure:"snapshotHeight"`
+}
+type FileElem struct {
+	FilePath  string `mapstructure:"filePath"`
+	UUID      string `mapstructure:"uuid"`
+	SourceURL string `mapstructure:"sourceUrl"`
+	FileName  string `mapstructure:"fileName"`
+	FileSize  int64  `mapstructure:"fileSize"`
+}
+
+//type MergeElem struct {
+//	Title        string       `json:"title"`
+//	AbstractList []string     `json:"abstractList"`
+//	MultiMessage []*MsgStruct `json:"multiMessage"`
+//}
+type AtElem struct {
+	Text       string   `mapstructure:"text"`
+	AtUserList []string `mapstructure:"atUserList"`
+	IsAtSelf   bool     `mapstructure:"isAtSelf"`
+}
+type LocationElem struct {
+	Description string  `mapstructure:"description"`
+	Longitude   float64 `mapstructure:"longitude"`
+	Latitude    float64 `mapstructure:"latitude"`
+}
+type CustomElem struct {
+	Data        string `mapstructure:"data" validate:"required"`
+	Description string `mapstructure:"description"`
+	Extension   string `mapstructure:"extension"`
+}
+type TextElem struct {
+	Text string `mapstructure:"text" validate:"required"`
+}
+
+//type QuoteElem struct {
+//	Text         string     `json:"text"`
+//	QuoteMessage *MsgStruct `json:"quoteMessage"`
+//}
@@ -0,0 +1,78 @@
+/*
+** description("").
+** copyright('open-im,www.open-im.io').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/9/15 10:28).
+ */
+package manage
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbUser "Open_IM/src/proto/user"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsDeleteUsers struct {
+	OperationID   string   `json:"operationID" binding:"required"`
+	DeleteUidList []string `json:"deleteUidList" binding:"required"`
+}
+type paramsGetAllUsersUid struct {
+	OperationID string `json:"operationID" binding:"required"`
+}
+
+func DeleteUser(c *gin.Context) {
+	params := paramsDeleteUsers{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	log.InfoByKv("DeleteUser req come here", params.OperationID, "DeleteUidList", params.DeleteUidList)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	//defer etcdConn.Close()
+
+	req := &pbUser.DeleteUsersReq{
+		OperationID:   params.OperationID,
+		DeleteUidList: params.DeleteUidList,
+		Token:         c.Request.Header.Get("token"),
+	}
+	RpcResp, err := client.DeleteUsers(context.Background(), req)
+	if err != nil {
+
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call delete users rpc server failed"})
+		return
+	}
+	log.InfoByKv("call delete user rpc server is success", params.OperationID, "resp args", RpcResp.String())
+	resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "failedUidList": RpcResp.FailedUidList}
+	c.JSON(http.StatusOK, resp)
+}
+func GetAllUsersUid(c *gin.Context) {
+	params := paramsGetAllUsersUid{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	log.InfoByKv("GetAllUsersUid req come here", params.OperationID)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	//defer etcdConn.Close()
+
+	req := &pbUser.GetAllUsersUidReq{
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	RpcResp, err := client.GetAllUsersUid(context.Background(), req)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error(), "uidList": []string{}})
+		return
+	}
+	log.InfoByKv("call GetAllUsersUid rpc server is success", params.OperationID, "resp args", RpcResp.String())
+	resp := gin.H{"errCode": RpcResp.CommonResp.ErrorCode, "errMsg": RpcResp.CommonResp.ErrorMsg, "uidList": RpcResp.UidList}
+	c.JSON(http.StatusOK, resp)
+
+}
@@ -0,0 +1,92 @@
+package apiThird
+
+import (
+	"Open_IM/src/common/config"
+	log2 "Open_IM/src/common/log"
+	"github.com/gin-gonic/gin"
+	sts "github.com/tencentyun/qcloud-cos-sts-sdk/go"
+	"net/http"
+	"time"
+)
+
+type paramsTencentCloudStorageCredential struct {
+	Token       string `json:"token"`
+	OperationID string `json:"operationID"`
+}
+
+var lastTime int64
+var lastRes *sts.CredentialResult
+
+func TencentCloudStorageCredential(c *gin.Context) {
+	params := paramsTencentCloudStorageCredential{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "Parameter parsing error，please check the parameters and request service again"})
+		return
+	}
+
+	log2.Info(params.Token, params.OperationID, "api TencentUpLoadCredential call start...")
+
+	if time.Now().Unix()-lastTime < 10 && lastRes != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"errCode": 0,
+			"errMsg":  "",
+			"region":  config.Config.Credential.Tencent.Region,
+			"bucket":  config.Config.Credential.Tencent.Bucket,
+			"data":    lastRes,
+		})
+		return
+	}
+
+	lastTime = time.Now().Unix()
+
+	cli := sts.NewClient(
+		config.Config.Credential.Tencent.SecretID,
+		config.Config.Credential.Tencent.SecretKey,
+		nil,
+	)
+	log2.Info(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential sts.NewClient cli = %v", cli)
+
+	opt := &sts.CredentialOptions{
+		DurationSeconds: int64(time.Hour.Seconds()),
+		Region:          config.Config.Credential.Tencent.Region,
+		Policy: &sts.CredentialPolicy{
+			Statement: []sts.CredentialPolicyStatement{
+				{
+					Action: []string{
+						"name/cos:PostObject",
+						"name/cos:PutObject",
+					},
+					Effect: "allow",
+					Resource: []string{
+						"qcs::cos:" + config.Config.Credential.Tencent.Region + ":uid/" + config.Config.Credential.Tencent.AppID + ":" + config.Config.Credential.Tencent.Bucket + "/*",
+					},
+				},
+			},
+		},
+	}
+	log2.Info(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential sts.CredentialOptions opt = %v", opt)
+
+	res, err := cli.GetCredential(opt)
+	if err != nil {
+		log2.Error(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential cli.GetCredential err = %s", err.Error())
+		c.JSON(http.StatusOK, gin.H{
+			"errCode": config.ErrTencentCredential.ErrCode,
+			"errMsg":  err.Error(),
+			"bucket":  "",
+			"region":  "",
+			"data":    res,
+		})
+		return
+	}
+	log2.Info(c.Request.Header.Get("token"), c.PostForm("optionID"), "api TencentUpLoadCredential cli.GetCredential success res = %v, res.Credentials = %v", res, res.Credentials)
+
+	lastRes = res
+
+	c.JSON(http.StatusOK, gin.H{
+		"errCode": 0,
+		"errMsg":  "",
+		"region":  config.Config.Credential.Tencent.Region,
+		"bucket":  config.Config.Credential.Tencent.Bucket,
+		"data":    res,
+	})
+}
@@ -0,0 +1,74 @@
+package user
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbUser "Open_IM/src/proto/user"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+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"`
+}
+
+func GetUserInfo(c *gin.Context) {
+	log.InfoByKv("api get userinfo init...", "")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsStruct{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbUser.GetUserInfoReq{
+		UserIDList:  params.UIDList,
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+	}
+	log.InfoByKv("api get user info is server", c.PostForm("OperationID"), c.Request.Header.Get("token"))
+	RpcResp, err := client.GetUserInfo(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "err=%s,call get user info rpc server failed", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"errorCode": 500,
+			"errorMsg":  "call  rpc server failed",
+		})
+		return
+	}
+	log.InfoByKv("call get user info rpc server success", params.OperationID)
+	if RpcResp.ErrorCode == 0 {
+		userInfoList := make([]userInfo, 0)
+		for _, user := range RpcResp.Data {
+			var ui userInfo
+			ui.UID = user.Uid
+			ui.Name = user.Name
+			ui.Icon = user.Icon
+			ui.Gender = user.Gender
+			ui.Mobile = user.Mobile
+			ui.Birth = user.Birth
+			ui.Email = user.Email
+			ui.Ex = user.Ex
+			userInfoList = append(userInfoList, ui)
+		}
+		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.InfoByKv("api get user info return success", params.OperationID, "args=%s", RpcResp.String())
+}
@@ -0,0 +1,62 @@
+package user
+
+import (
+	"Open_IM/src/common/config"
+	"Open_IM/src/common/log"
+	"Open_IM/src/grpc-etcdv3/getcdv3"
+	pbUser "Open_IM/src/proto/user"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+type paramsStruct struct {
+	OperationID string   `json:"operationID" binding:"required"`
+	UIDList     []string `json:"uidList"`
+	Platform    int32    `json:"platform"`
+	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"`
+	Uid         string   `json:"uid"`
+}
+
+func UpdateUserInfo(c *gin.Context) {
+	log.InfoByKv("api update userinfo init...", "")
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pbUser.NewUserClient(etcdConn)
+	//defer etcdConn.Close()
+
+	params := paramsStruct{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbUser.UpdateUserInfoReq{
+		OperationID: params.OperationID,
+		Token:       c.Request.Header.Get("token"),
+		Name:        params.Name,
+		Icon:        params.Icon,
+		Gender:      params.Gender,
+		Mobile:      params.Mobile,
+		Birth:       params.Birth,
+		Email:       params.Email,
+		Ex:          params.Ex,
+		Uid:         params.Uid,
+	}
+	log.InfoByKv("api update user info is server", req.OperationID, req.Token)
+	RpcResp, err := client.UpdateUserInfo(context.Background(), req)
+	if err != nil {
+		log.Error(req.Token, req.OperationID, "err=%s,call get user info rpc server failed", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call  rpc server failed"})
+		return
+	}
+	log.InfoByKv("call update user info rpc server success", params.OperationID)
+	c.JSON(http.StatusOK, gin.H{"errCode": RpcResp.ErrorCode, "errMsg": RpcResp.ErrorMsg})
+	log.InfoByKv("api update user info return success", params.OperationID, "args=%s", RpcResp.String())
+}