Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode

 Conflicts:

	internal/api/auth.go

	internal/api/route.go

	internal/api/user.go

	internal/rpc/third/third.go

internal/api/conversation.go

@@ -0,0 +1,56 @@
+package api
+
+import (
+	"OpenIM/internal/api/a2r"
+	"OpenIM/pkg/common/config"
+	"OpenIM/pkg/proto/conversation"
+	"context"
+	"github.com/OpenIMSDK/openKeeper"
+	"github.com/gin-gonic/gin"
+)
+
+var _ context.Context // 解决goland编辑器bug
+
+func NewConversation(zk *openKeeper.ZkClient) *Conversation {
+	return &Conversation{zk: zk}
+}
+
+type Conversation struct {
+	zk *openKeeper.ZkClient
+}
+
+func (o *Conversation) client() (conversation.ConversationClient, error) {
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+	if err != nil {
+		return nil, err
+	}
+	return conversation.NewConversationClient(conn), nil
+}
+
+func (o *Conversation) GetAllConversations(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.GetAllConversations, o.client, c)
+}
+
+func (o *Conversation) GetConversation(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.GetConversation, o.client, c)
+}
+
+func (o *Conversation) GetConversations(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.GetConversations, o.client, c)
+}
+
+func (o *Conversation) SetConversation(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.SetConversation, o.client, c)
+}
+
+func (o *Conversation) BatchSetConversations(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.BatchSetConversations, o.client, c)
+}
+
+func (o *Conversation) SetRecvMsgOpt(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.SetRecvMsgOpt, o.client, c)
+}
+
+func (o *Conversation) ModifyConversationField(c *gin.Context) {
+	a2r.Call(conversation.ConversationClient.ModifyConversationField, o.client, c)
+}

internal/api/conversation/conversation.go

@@ -1,327 +0,0 @@
-package conversation
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/log"
-	pbConversation "OpenIM/pkg/proto/conversation"
-	pbUser "OpenIM/pkg/proto/user"
-	"OpenIM/pkg/utils"
-	"context"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-func SetConversation(c *gin.Context) {
-	var (
-		req   api.SetConversationReq
-		resp  api.SetConversationResp
-		reqPb pbUser.SetConversationReq
-	)
-	if err := c.BindJSON(&req); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	reqPb.Conversation = &pbConversation.Conversation{}
-	err := utils.CopyStructFields(&reqPb, req)
-	err = utils.CopyStructFields(reqPb.Conversation, req.Conversation)
-	if err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
-	}
-	etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	client := pbUser.NewUserClient(etcdConn)
-	respPb, err := client.SetConversation(context.Background(), &reqPb)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
-		return
-	}
-	resp.ErrMsg = respPb.CommonResp.ErrMsg
-	resp.ErrCode = respPb.CommonResp.ErrCode
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
-	c.JSON(http.StatusOK, resp)
-}
-func ModifyConversationField(c *gin.Context) {
-	var (
-		req   api.ModifyConversationFieldReq
-		resp  api.ModifyConversationFieldResp
-		reqPb pbConversation.ModifyConversationFieldReq
-	)
-	if err := c.BindJSON(&req); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "bind json failed", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "bind json failed " + err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	reqPb.Conversation = &pbConversation.Conversation{}
-	err := utils.CopyStructFields(&reqPb, req)
-	err = utils.CopyStructFields(reqPb.Conversation, req.Conversation)
-	if err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", err.Error())
-	}
-	etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImConversationName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	client := pbConversation.NewConversationClient(etcdConn)
-	respPb, err := client.ModifyConversationField(context.Background(), &reqPb)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": "GetAllConversationMsgOpt rpc failed, " + err.Error()})
-		return
-	}
-	resp.ErrMsg = respPb.CommonResp.ErrMsg
-	resp.ErrCode = respPb.CommonResp.ErrCode
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
-	c.JSON(http.StatusOK, resp)
-}
-
-func BatchSetConversations(c *gin.Context) {
-	var (
-		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 := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == 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)
-}
-
-// @Summary 获取用户所有会话
-// @Description 获取用户所有会话
-// @Tags 会话相关
-// @ID GetAllConversations
-// @Accept json
-// @Param token header string true "im token"
-// @Param req body api.GetAllConversationsReq true "ownerUserID为要获取的用户ID"
-// @Produce json
-// @Success 0 {object} api.GetAllConversationsResp
-// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
-// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
-// @Router /msg/get_all_conversations [post]
-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 := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == 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)
-}
-
-// @Summary 根据会话ID获取会话
-// @Description 根据会话ID获取会话
-// @Tags 会话相关
-// @ID GetConversation
-// @Accept json
-// @Param token header string true "im token"
-// @Param req body api.GetConversationReq true "ownerUserID为要获取的用户ID<br>conversationID为要获取的会话ID"
-// @Produce json
-// @Success 0 {object} api.GetConversationResp
-// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
-// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
-// @Router /msg/get_conversation [post]
-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 := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == 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)
-}
-
-// @Summary 根据会话ID列表获取会话
-// @Description 根据会话ID列表获取会话
-// @Tags 会话相关
-// @ID GetConversations
-// @Accept json
-// @Param token header string true "im token"
-// @Param req body api.GetConversationsReq true "ownerUserID为要获取的用户ID<br>conversationIDs为要获取的会话ID列表"
-// @Produce json
-// @Success 0 {object} api.GetConversationsResp
-// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
-// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
-// @Router /msg/get_conversations [post]
-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 := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == 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 := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == 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) {
-
-}
-
-// Deprecated
-func GetReceiveMessageOpt(c *gin.Context) {
-
-}
-
-// Deprecated
-func GetAllConversationMessageOpt(c *gin.Context) {
-
-}

internal/api/friend.go

@@ -19,58 +19,58 @@ type Friend struct {
 	zk *openKeeper.ZkClient
 }
 
-func (f *Friend) getGroupClient() (friend.FriendClient, error) {
-	conn, err := f.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+func (o *Friend) client() (friend.FriendClient, error) {
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
 	if err != nil {
 		return nil, err
 	}
 	return friend.NewFriendClient(conn), nil
 }
 
-func (f *Friend) AddFriend(c *gin.Context) {
-	a2r.Call(friend.FriendClient.AddFriend, f.getGroupClient, c)
+func (o *Friend) ApplyToAddFriend(c *gin.Context) {
+	a2r.Call(friend.FriendClient.ApplyToAddFriend, o.client, c)
 }
 
-func (f *Friend) DeleteFriend(c *gin.Context) {
-	a2r.Call(friend.FriendClient.DeleteFriend, f.getGroupClient, c)
+func (o *Friend) DeleteFriend(c *gin.Context) {
+	a2r.Call(friend.FriendClient.DeleteFriend, o.client, c)
 }
 
-func (f *Friend) GetFriendApplyList(c *gin.Context) {
-	a2r.Call(friend.FriendClient.GetFriendApplyList, f.getGroupClient, c)
+func (o *Friend) GetFriendApplyList(c *gin.Context) {
+	a2r.Call(friend.FriendClient.GetPaginationFriendsApplyFrom, o.client, c)
 }
 
-func (f *Friend) GetSelfApplyList(c *gin.Context) {
-	a2r.Call(friend.FriendClient.GetSelfApplyList, f.getGroupClient, c)
+func (o *Friend) GetSelfApplyList(c *gin.Context) {
+	a2r.Call(friend.FriendClient.GetPaginationFriendsApplyFrom, o.client, c)
 }
 
-func (f *Friend) GetFriendList(c *gin.Context) {
-	a2r.Call(friend.FriendClient.GetFriendList, f.getGroupClient, c)
+func (o *Friend) GetFriendList(c *gin.Context) {
+	a2r.Call(friend.FriendClient.GetDesignatedFriends, o.client, c)
 }
 
-func (f *Friend) AddFriendResponse(c *gin.Context) {
-	a2r.Call(friend.FriendClient.AddFriendResponse, f.getGroupClient, c)
+func (o *Friend) RespondFriendApply(c *gin.Context) {
+	a2r.Call(friend.FriendClient.RespondFriendApply, o.client, c)
 }
 
-func (f *Friend) SetFriendRemark(c *gin.Context) {
-	a2r.Call(friend.FriendClient.SetFriendRemark, f.getGroupClient, c)
+func (o *Friend) SetFriendRemark(c *gin.Context) {
+	a2r.Call(friend.FriendClient.SetFriendRemark, o.client, c)
 }
 
-func (f *Friend) AddBlack(c *gin.Context) {
-	a2r.Call(friend.FriendClient.AddBlack, f.getGroupClient, c)
+func (o *Friend) AddBlack(c *gin.Context) {
+	a2r.Call(friend.FriendClient.AddBlack, o.client, c)
 }
 
-func (f *Friend) GetBlacklist(c *gin.Context) {
-	a2r.Call(friend.FriendClient.GetBlacklist, f.getGroupClient, c)
+func (o *Friend) GetPaginationBlacks(c *gin.Context) {
+	a2r.Call(friend.FriendClient.GetPaginationBlacks, o.client, c)
 }
 
-func (f *Friend) RemoveBlacklist(c *gin.Context) {
-	a2r.Call(friend.FriendClient.RemoveBlacklist, f.getGroupClient, c)
+func (o *Friend) RemoveBlack(c *gin.Context) {
+	a2r.Call(friend.FriendClient.RemoveBlack, o.client, c)
 }
 
-func (f *Friend) ImportFriend(c *gin.Context) {
-	a2r.Call(friend.FriendClient.ImportFriend, f.getGroupClient, c)
+func (o *Friend) ImportFriends(c *gin.Context) {
+	a2r.Call(friend.FriendClient.ImportFriends, o.client, c)
 }
 
-func (f *Friend) IsFriend(c *gin.Context) {
-	a2r.Call(friend.FriendClient.IsFriend, f.getGroupClient, c)
+func (o *Friend) IsFriend(c *gin.Context) {
+	a2r.Call(friend.FriendClient.IsFriend, o.client, c)
 }

internal/api/group.go

@@ -19,106 +19,106 @@ type Group struct {
 	zk *openKeeper.ZkClient
 }
 
-func (g *Group) getGroupClient() (group.GroupClient, error) {
-	conn, err := g.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+func (o *Group) client() (group.GroupClient, error) {
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
 	if err != nil {
 		return nil, err
 	}
 	return group.NewGroupClient(conn), nil
 }
 
-func (g *Group) NewCreateGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.CreateGroup, g.getGroupClient, c)
+func (o *Group) NewCreateGroup(c *gin.Context) {
+	a2r.Call(group.GroupClient.CreateGroup, o.client, c)
 }
 
-func (g *Group) NewSetGroupInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.SetGroupInfo, g.getGroupClient, c)
+func (o *Group) NewSetGroupInfo(c *gin.Context) {
+	a2r.Call(group.GroupClient.SetGroupInfo, o.client, c)
 }
 
-func (g *Group) JoinGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.JoinGroup, g.getGroupClient, c)
+func (o *Group) JoinGroup(c *gin.Context) {
+	a2r.Call(group.GroupClient.JoinGroup, o.client, c)
 }
 
-func (g *Group) QuitGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.QuitGroup, g.getGroupClient, c)
+func (o *Group) QuitGroup(c *gin.Context) {
+	a2r.Call(group.GroupClient.QuitGroup, o.client, c)
 }
 
-func (g *Group) ApplicationGroupResponse(c *gin.Context) {
-	a2r.Call(group.GroupClient.GroupApplicationResponse, g.getGroupClient, c)
+func (o *Group) ApplicationGroupResponse(c *gin.Context) {
+	a2r.Call(group.GroupClient.GroupApplicationResponse, o.client, c)
 }
 
-func (g *Group) TransferGroupOwner(c *gin.Context) {
-	a2r.Call(group.GroupClient.TransferGroupOwner, g.getGroupClient, c)
+func (o *Group) TransferGroupOwner(c *gin.Context) {
+	a2r.Call(group.GroupClient.TransferGroupOwner, o.client, c)
 }
 
-func (g *Group) GetRecvGroupApplicationList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupApplicationList, g.getGroupClient, c)
+func (o *Group) GetRecvGroupApplicationList(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetGroupApplicationList, o.client, c)
 }
 
-func (g *Group) GetUserReqGroupApplicationList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetUserReqApplicationList, g.getGroupClient, c)
+func (o *Group) GetUserReqGroupApplicationList(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetUserReqApplicationList, o.client, c)
 }
 
-func (g *Group) GetGroupsInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupsInfo, g.getGroupClient, c)
+func (o *Group) GetGroupsInfo(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetGroupsInfo, o.client, c)
 }
 
-func (g *Group) KickGroupMember(c *gin.Context) {
-	a2r.Call(group.GroupClient.KickGroupMember, g.getGroupClient, c)
+func (o *Group) KickGroupMember(c *gin.Context) {
+	a2r.Call(group.GroupClient.KickGroupMember, o.client, c)
 }
 
-func (g *Group) GetGroupMembersInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupMembersInfo, g.getGroupClient, c)
+func (o *Group) GetGroupMembersInfo(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetGroupMembersInfo, o.client, c)
 }
 
-func (g *Group) InviteUserToGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.InviteUserToGroup, g.getGroupClient, c)
+func (o *Group) InviteUserToGroup(c *gin.Context) {
+	a2r.Call(group.GroupClient.InviteUserToGroup, o.client, c)
 }
 
-func (g *Group) GetJoinedGroupList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetJoinedGroupList, g.getGroupClient, c)
+func (o *Group) GetJoinedGroupList(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetJoinedGroupList, o.client, c)
 }
 
-func (g *Group) DismissGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.DismissGroup, g.getGroupClient, c)
+func (o *Group) DismissGroup(c *gin.Context) {
+	a2r.Call(group.GroupClient.DismissGroup, o.client, c)
 }
 
-func (g *Group) MuteGroupMember(c *gin.Context) {
-	a2r.Call(group.GroupClient.MuteGroupMember, g.getGroupClient, c)
+func (o *Group) MuteGroupMember(c *gin.Context) {
+	a2r.Call(group.GroupClient.MuteGroupMember, o.client, c)
 }
 
-func (g *Group) CancelMuteGroupMember(c *gin.Context) {
-	a2r.Call(group.GroupClient.CancelMuteGroupMember, g.getGroupClient, c)
+func (o *Group) CancelMuteGroupMember(c *gin.Context) {
+	a2r.Call(group.GroupClient.CancelMuteGroupMember, o.client, c)
 }
 
-func (g *Group) MuteGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.MuteGroup, g.getGroupClient, c)
+func (o *Group) MuteGroup(c *gin.Context) {
+	a2r.Call(group.GroupClient.MuteGroup, o.client, c)
 }
 
-func (g *Group) CancelMuteGroup(c *gin.Context) {
-	a2r.Call(group.GroupClient.CancelMuteGroup, g.getGroupClient, c)
+func (o *Group) CancelMuteGroup(c *gin.Context) {
+	a2r.Call(group.GroupClient.CancelMuteGroup, o.client, c)
 }
 
-func (g *Group) SetGroupMemberInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.SetGroupMemberInfo, g.getGroupClient, c)
+func (o *Group) SetGroupMemberInfo(c *gin.Context) {
+	a2r.Call(group.GroupClient.SetGroupMemberInfo, o.client, c)
 }
 
-func (g *Group) GetGroupAbstractInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetGroupAbstractInfo, g.getGroupClient, c)
+func (o *Group) GetGroupAbstractInfo(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetGroupAbstractInfo, o.client, c)
 }
 
 //func (g *Group) SetGroupMemberNickname(c *gin.Context) {
-//	a2r.Call(group.GroupClient.SetGroupMemberNickname, g.getGroupClient, c)
+//	a2r.Call(group.GroupClient.SetGroupMemberNickname, g.client, c)
 //}
 //
 //func (g *Group) GetGroupAllMemberList(c *gin.Context) {
-//	a2r.Call(group.GroupClient.GetGroupAllMember, g.getGroupClient, c)
+//	a2r.Call(group.GroupClient.GetGroupAllMember, g.client, c)
 //}
 
-func (g *Group) GetJoinedSuperGroupList(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetJoinedSuperGroupList, g.getGroupClient, c)
+func (o *Group) GetJoinedSuperGroupList(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetJoinedSuperGroupList, o.client, c)
 }
 
-func (g *Group) GetSuperGroupsInfo(c *gin.Context) {
-	a2r.Call(group.GroupClient.GetSuperGroupsInfo, g.getGroupClient, c)
+func (o *Group) GetSuperGroupsInfo(c *gin.Context) {
+	a2r.Call(group.GroupClient.GetSuperGroupsInfo, o.client, c)
 }

internal/api/msg.go

@@ -0,0 +1,84 @@
+package api
+
+import (
+	"OpenIM/internal/api/a2r"
+	"OpenIM/pkg/common/config"
+	"OpenIM/pkg/proto/msg"
+	"context"
+	"github.com/OpenIMSDK/openKeeper"
+	"github.com/gin-gonic/gin"
+)
+
+var _ context.Context // 解决goland编辑器bug
+
+func NewMsg(zk *openKeeper.ZkClient) *Conversation {
+	return &Conversation{zk: zk}
+}
+
+type Msg struct {
+	zk *openKeeper.ZkClient
+}
+
+func (o *Msg) client() (msg.MsgClient, error) {
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImMsgName)
+	if err != nil {
+		return nil, err
+	}
+	return msg.NewMsgClient(conn), nil
+}
+
+func (o *Msg) GetSeq(c *gin.Context) {
+	a2r.Call(msg.MsgClient.GetSeq, o.client, c)
+}
+
+func (o *Msg) SendMsg(c *gin.Context) {
+	a2r.Call(msg.MsgClient.SendMsg, o.client, c)
+}
+
+func (o *Msg) PullMsgBySeqList(c *gin.Context) {
+	a2r.Call(msg.MsgClient.PullMsgBySeqList, o.client, c)
+}
+
+func (o *Msg) DelMsg(c *gin.Context) {
+	a2r.Call(msg.MsgClient.DelMsg, o.client, c)
+}
+
+func (o *Msg) DelSuperGroupMsg(c *gin.Context) {
+	a2r.Call(msg.MsgClient.DelSuperGroupMsg, o.client, c)
+}
+
+func (o *Msg) ClearMsg(c *gin.Context) {
+	a2r.Call(msg.MsgClient.ClearMsg, o.client, c)
+}
+
+func (o *Msg) SetMsgMinSeq(c *gin.Context) {
+	a2r.Call(msg.MsgClient.SetMsgMinSeq, o.client, c)
+}
+
+func (o *Msg) SetMessageReactionExtensions(c *gin.Context) {
+	a2r.Call(msg.MsgClient.SetMessageReactionExtensions, o.client, c)
+}
+
+func (o *Msg) GetMessageListReactionExtensions(c *gin.Context) {
+	a2r.Call(msg.MsgClient.GetMessageListReactionExtensions, o.client, c)
+}
+
+func (o *Msg) AddMessageReactionExtensions(c *gin.Context) {
+	a2r.Call(msg.MsgClient.AddMessageReactionExtensions, o.client, c)
+}
+
+func (o *Msg) DeleteMessageReactionExtensions(c *gin.Context) {
+	a2r.Call(msg.MsgClient.DeleteMessageReactionExtensions, o.client, c)
+}
+
+func (o *Msg) ManagementSendMsg(c *gin.Context) {
+	a2r.Call(msg.MsgClient.ManagementSendMsg, o.client, c)
+}
+
+func (o *Msg) ManagementBatchSendMsg(c *gin.Context) {
+	a2r.Call(msg.MsgClient.ManagementBatchSendMsg, o.client, c)
+}
+
+func (o *Msg) CheckMsgIsSendSuccess(c *gin.Context) {
+	a2r.Call(msg.MsgClient.CheckMsgIsSendSuccess, o.client, c)
+}

internal/api/msg/del_msg.go

@@ -1,273 +0,0 @@
-package msg
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/constant"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	rpc "OpenIM/pkg/proto/msg"
-	pbCommon "OpenIM/pkg/proto/sdkws"
-	"OpenIM/pkg/utils"
-	"context"
-	"github.com/gin-gonic/gin"
-	"github.com/golang/protobuf/proto"
-	"net/http"
-	"strings"
-)
-
-// @Summary 根据seq列表删除消息
-// @Description 根据seq列表删除消息
-// @Tags 消息相关
-// @ID DelMsg
-// @Accept json
-// @Param token header string true "im token"
-// @Param req body api.DelMsgReq true "userID为要删除的用户ID <br> seqList为seq列表"
-// @Produce json
-// @Success 0 {object} api.DelMsgResp
-// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
-// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
-// @Router /msg/del_msg [post]
-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())
-	}
-
-	var ok bool
-	var errInfo string
-	ok, reqPb.OpUserID, errInfo = tokenverify.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.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-
-	grpcConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if grpcConn == nil {
-		errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	msgClient := rpc.NewMsgClient(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 DelSuperGroupMsg(c *gin.Context) {
-	var (
-		req  api.DelSuperGroupMsgReq
-		resp api.DelSuperGroupMsgResp
-	)
-	rpcReq := &rpc.DelSuperGroupMsgReq{}
-	if err := c.BindJSON(&req); err != nil {
-		log.NewError("", "args err:", err.Error())
-		c.JSON(http.StatusOK, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	utils.CopyStructFields(rpcReq, &req)
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req)
-	var ok bool
-	var errInfo string
-	ok, rpcReq.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
-	if !ok {
-		errMsg := req.OperationID + " " + rpcReq.OpUserID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusOK, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	options := make(map[string]bool, 5)
-	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
-	utils.SetSwitchFromOptions(options, constant.IsSenderConversationUpdate, false)
-	utils.SetSwitchFromOptions(options, constant.IsUnreadCount, false)
-	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
-	pbData := rpc.SendMsgReq{
-		OperationID: req.OperationID,
-		MsgData: &pbCommon.MsgData{
-			SendID:      req.UserID,
-			RecvID:      req.UserID,
-			ClientMsgID: utils.GetMsgID(req.UserID),
-			SessionType: constant.SingleChatType,
-			MsgFrom:     constant.SysMsgType,
-			ContentType: constant.MsgDeleteNotification,
-			//	ForceList:        params.ForceList,
-			CreateTime: utils.GetCurrentTimestampByMill(),
-			Options:    options,
-		},
-	}
-	var tips pbCommon.TipsComm
-	deleteMsg := api.MsgDeleteNotificationElem{
-		GroupID:     req.GroupID,
-		IsAllDelete: req.IsAllDelete,
-		SeqList:     req.SeqList,
-	}
-	tips.JsonDetail = utils.StructToJsonString(deleteMsg)
-	var err error
-	pbData.MsgData.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(req.OperationID, "Marshal failed ", err.Error(), tips.String())
-		resp.ErrCode = 400
-		resp.ErrMsg = err.Error()
-		log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
-		c.JSON(http.StatusOK, resp)
-	}
-	log.Info(req.OperationID, "", "api DelSuperGroupMsg call start..., [data: %s]", pbData.String())
-	etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	client := rpc.NewMsgClient(etcdConn)
-
-	log.Info(req.OperationID, "", "api DelSuperGroupMsg call, api call rpc...")
-	if req.IsAllDelete {
-		RpcResp, err := client.DelSuperGroupMsg(context.Background(), rpcReq)
-		if err != nil {
-			log.NewError(req.OperationID, "call delete DelSuperGroupMsg rpc server failed", err.Error())
-			c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call DelSuperGroupMsg  rpc server failed"})
-			return
-		}
-		log.Info(req.OperationID, "", "api DelSuperGroupMsg call end..., [data: %s] [reply: %s]", pbData.String(), RpcResp.String())
-		resp.ErrCode = RpcResp.ErrCode
-		resp.ErrMsg = RpcResp.ErrMsg
-		log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
-		c.JSON(http.StatusOK, resp)
-	} else {
-		RpcResp, err := client.SendMsg(context.Background(), &pbData)
-		if err != nil {
-			log.NewError(req.OperationID, "call delete UserSendMsg rpc server failed", err.Error())
-			c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call UserSendMsg  rpc server failed"})
-			return
-		}
-		log.Info(req.OperationID, "", "api DelSuperGroupMsg call end..., [data: %s] [reply: %s]", pbData.String(), RpcResp.String())
-		resp.ErrCode = RpcResp.ErrCode
-		resp.ErrMsg = RpcResp.ErrMsg
-		log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
-		c.JSON(http.StatusOK, resp)
-	}
-
-}
-
-// @Summary 清空用户消息
-// @Description 清空用户消息
-// @Tags 消息相关
-// @ID ClearMsg
-// @Accept json
-// @Param token header string true "im token"
-// @Param req body api.CleanUpMsgReq true "userID为要清空的用户ID"
-// @Produce json
-// @Success 0 {object} api.CleanUpMsgResp
-// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
-// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
-// @Router /msg/clear_msg [post]
-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 = tokenverify.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 := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	client := rpc.NewMsgClient(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)
-}
-
-// @Summary 设置用户最小seq
-// @Description 设置用户最小seq，以及用户相关读扩散群组最小seq
-// @Tags 消息相关
-// @ID SetMsgMinSeq
-// @Accept json
-// @Param token header string true "im token"
-func SetMsgMinSeq(c *gin.Context) {
-	params := api.SetMsgMinSeqReq{}
-	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.SetMsgMinSeqReq{}
-	utils.CopyStructFields(req, &params)
-
-	var ok bool
-	var errInfo string
-	ok, req.OpUserID, errInfo = tokenverify.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 := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	client := rpc.NewMsgClient(etcdConn)
-	RpcResp, err := client.SetMsgMinSeq(context.Background(), req)
-	if err != nil {
-		log.NewError(req.OperationID, " SetMsgMinSeq failed ", err.Error(), req.String(), RpcResp.ErrMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": RpcResp.ErrMsg})
-		return
-	}
-
-	resp := api.SetMsgMinSeqResp{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/msg/extend_msg.go

@@ -1,202 +0,0 @@
-package msg
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/constant"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	rpc "OpenIM/pkg/proto/msg"
-	"OpenIM/pkg/utils"
-	"context"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-func SetMessageReactionExtensions(c *gin.Context) {
-	var (
-		req   api.SetMessageReactionExtensionsCallbackReq
-		resp  api.SetMessageReactionExtensionsCallbackResp
-		reqPb rpc.SetMessageReactionExtensionsReq
-	)
-
-	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())
-	}
-	var ok bool
-	var errInfo string
-	ok, reqPb.OpUserID, errInfo = tokenverify.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.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-
-	grpcConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if grpcConn == nil {
-		errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	msgClient := rpc.NewMsgClient(grpcConn)
-	respPb, err := msgClient.SetMessageReactionExtensions(context.Background(), &reqPb)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelMsgList failed", err.Error(), reqPb)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrServer.ErrCode, "errMsg": constant.ErrServer.ErrMsg + err.Error()})
-		return
-	}
-	resp.ErrCode = respPb.ErrCode
-	resp.ErrMsg = respPb.ErrMsg
-	resp.Data.ResultKeyValue = respPb.Result
-	resp.Data.MsgFirstModifyTime = reqPb.MsgFirstModifyTime
-	resp.Data.IsReact = reqPb.IsReact
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
-	c.JSON(http.StatusOK, resp)
-
-}
-
-func GetMessageListReactionExtensions(c *gin.Context) {
-	var (
-		req   api.GetMessageListReactionExtensionsReq
-		resp  api.GetMessageListReactionExtensionsResp
-		reqPb rpc.GetMessageListReactionExtensionsReq
-	)
-	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())
-	}
-	var ok bool
-	var errInfo string
-	ok, reqPb.OpUserID, errInfo = tokenverify.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.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-
-	grpcConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if grpcConn == nil {
-		errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	msgClient := rpc.NewMsgClient(grpcConn)
-	respPb, err := msgClient.GetMessageListReactionExtensions(context.Background(), &reqPb)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelMsgList failed", err.Error(), reqPb)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrServer.ErrCode, "errMsg": constant.ErrServer.ErrMsg + err.Error()})
-		return
-	}
-	resp.ErrCode = respPb.ErrCode
-	resp.ErrMsg = respPb.ErrMsg
-	resp.Data = respPb.SingleMessageResult
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
-	c.JSON(http.StatusOK, resp)
-}
-
-func AddMessageReactionExtensions(c *gin.Context) {
-	var (
-		req   api.AddMessageReactionExtensionsReq
-		resp  api.AddMessageReactionExtensionsResp
-		reqPb rpc.ModifyMessageReactionExtensionsReq
-	)
-	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())
-	}
-	var ok bool
-	var errInfo string
-	ok, reqPb.OpUserID, errInfo = tokenverify.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.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-
-	grpcConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if grpcConn == nil {
-		errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	msgClient := rpc.NewMsgClient(grpcConn)
-	respPb, err := msgClient.AddMessageReactionExtensions(context.Background(), &reqPb)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelMsgList failed", err.Error(), reqPb)
-		c.JSON(http.StatusInternalServerError, 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 DeleteMessageReactionExtensions(c *gin.Context) {
-	var (
-		req   api.DeleteMessageReactionExtensionsReq
-		resp  api.DeleteMessageReactionExtensionsResp
-		reqPb rpc.DeleteMessageListReactionExtensionsReq
-	)
-	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())
-	}
-	var ok bool
-	var errInfo string
-	ok, reqPb.OpUserID, errInfo = tokenverify.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.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-
-	grpcConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, req.OperationID)
-	if grpcConn == nil {
-		errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	msgClient := rpc.NewMsgClient(grpcConn)
-	respPb, err := msgClient.DeleteMessageReactionExtensions(context.Background(), &reqPb)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelMsgList failed", err.Error(), reqPb)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": constant.ErrServer.ErrCode, "errMsg": constant.ErrServer.ErrMsg + err.Error()})
-		return
-	}
-	resp.ErrCode = respPb.ErrCode
-	resp.ErrMsg = respPb.ErrMsg
-	resp.Data = respPb.Result
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
-	c.JSON(http.StatusOK, resp)
-}

internal/api/msg/get_max_min_seq.go

@@ -1,64 +0,0 @@
-package msg
-
-import (
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	pbChat "OpenIM/pkg/proto/msg"
-	sdkws "OpenIM/pkg/proto/sdkws"
-	"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 GetSeq(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 ok, err := tokenverify.VerifyToken(token, params.SendID); !ok {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "token validate err" + err.Error()})
-		return
-	}
-	pbData := sdkws.GetMaxAndMinSeqReq{}
-	pbData.UserID = params.SendID
-	pbData.OperationID = params.OperationID
-	grpcConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, pbData.OperationID)
-	if grpcConn == nil {
-		errMsg := pbData.OperationID + " getcdv3.GetDefaultConn == nil"
-		log.NewError(pbData.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-
-	msgClient := pbChat.NewMsgClient(grpcConn)
-	reply, err := msgClient.GetMaxAndMinSeq(context.Background(), &pbData)
-	if err != nil {
-		log.NewError(params.OperationID, "UserGetSeq rpc failed, ", params, err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": "UserGetSeq rpc failed, " + err.Error()})
-		return
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"errCode":       reply.ErrCode,
-		"errMsg":        reply.ErrMsg,
-		"msgIncr":       params.MsgIncr,
-		"reqIdentifier": params.ReqIdentifier,
-		"data": gin.H{
-			"maxSeq": reply.MaxSeq,
-			"minSeq": reply.MinSeq,
-		},
-	})
-
-}

internal/api/msg/pull_msg.go

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

internal/api/msg/send_msg.go

@@ -1,102 +0,0 @@
-package msg
-
-import (
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/log"
-	pbChat "OpenIM/pkg/proto/msg"
-	sdkws "OpenIM/pkg/proto/sdkws"
-	"context"
-
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"strings"
-)
-
-type paramsUserSendMsg struct {
-	SenderPlatformID int32  `json:"senderPlatformID" binding:"required"`
-	SendID           string `json:"sendID" binding:"required"`
-	SenderNickName   string `json:"senderNickName"`
-	SenderFaceURL    string `json:"senderFaceUrl"`
-	OperationID      string `json:"operationID" binding:"required"`
-	Data             struct {
-		SessionType int32                  `json:"sessionType" binding:"required"`
-		MsgFrom     int32                  `json:"msgFrom" binding:"required"`
-		ContentType int32                  `json:"contentType" binding:"required"`
-		RecvID      string                 `json:"recvID" `
-		GroupID     string                 `json:"groupID" `
-		ForceList   []string               `json:"forceList"`
-		Content     []byte                 `json:"content" binding:"required"`
-		Options     map[string]bool        `json:"options" `
-		ClientMsgID string                 `json:"clientMsgID" binding:"required"`
-		CreateTime  int64                  `json:"createTime" binding:"required"`
-		OffLineInfo *sdkws.OfflinePushInfo `json:"offlineInfo" `
-	}
-}
-
-func newUserSendMsgReq(token string, params *paramsUserSendMsg) *pbChat.SendMsgReq {
-	pbData := pbChat.SendMsgReq{
-		Token:       token,
-		OperationID: params.OperationID,
-		MsgData: &sdkws.MsgData{
-			SendID:           params.SendID,
-			RecvID:           params.Data.RecvID,
-			GroupID:          params.Data.GroupID,
-			ClientMsgID:      params.Data.ClientMsgID,
-			SenderPlatformID: params.SenderPlatformID,
-			SenderNickname:   params.SenderNickName,
-			SenderFaceURL:    params.SenderFaceURL,
-			SessionType:      params.Data.SessionType,
-			MsgFrom:          params.Data.MsgFrom,
-			ContentType:      params.Data.ContentType,
-			Content:          params.Data.Content,
-			CreateTime:       params.Data.CreateTime,
-			Options:          params.Data.Options,
-			OfflinePushInfo:  params.Data.OffLineInfo,
-		},
-	}
-	return &pbData
-}
-
-func SendMsg(c *gin.Context) {
-	params := paramsUserSendMsg{}
-	if err := c.BindJSON(&params); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		log.Error("0", "BindJSON failed ", err.Error())
-		return
-	}
-
-	token := c.Request.Header.Get("token")
-	log.NewInfo(params.OperationID, "api call success to sendMsgReq", params)
-	pbData := newUserSendMsgReq(token, &params)
-	log.Info(params.OperationID, "", "api SendMsg call start..., [data: %s]", pbData.String())
-
-	etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMsgName, params.OperationID)
-	if etcdConn == nil {
-		errMsg := params.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(params.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	client := pbChat.NewMsgClient(etcdConn)
-
-	log.Info(params.OperationID, "", "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,
-		"errMsg":  reply.ErrMsg,
-		"data": gin.H{
-			"clientMsgID": reply.ClientMsgID,
-			"serverMsgID": reply.ServerMsgID,
-			"sendTime":    reply.SendTime,
-		},
-	})
-
-}

internal/api/route.go

@@ -1,14 +1,13 @@
 package api
 
 import (
-	"OpenIM/internal/api/conversation"
 	"OpenIM/internal/api/manage"
 	"OpenIM/internal/api/msg"
-	"OpenIM/internal/api/third"
 	"OpenIM/pkg/common/config"
 	"OpenIM/pkg/common/log"
 	"OpenIM/pkg/common/middleware"
 	"OpenIM/pkg/common/prome"
+	"github.com/OpenIMSDK/openKeeper"
 	"github.com/gin-gonic/gin"
 	"io"
 	"os"
@@ -31,9 +30,11 @@ func NewGinRouter() *gin.Engine {
 		r.GET("/metrics", prome.PrometheusHandler())
 	}
 
+	var zk *openKeeper.ZkClient
+
 	userRouterGroup := r.Group("/user")
 	{
-		u := NewUser(nil)
+		u := NewUser(zk)
 		userRouterGroup.POST("/user_register", u.UserRegister)
 		userRouterGroup.POST("/update_user_info", u.UpdateUserInfo) //1
 		userRouterGroup.POST("/set_global_msg_recv_opt", u.SetGlobalRecvMessageOpt)
@@ -50,23 +51,23 @@ func NewGinRouter() *gin.Engine {
 	////friend routing group
 	friendRouterGroup := r.Group("/friend")
 	{
-		f := NewFriend(nil)
-		friendRouterGroup.POST("/add_friend", f.AddFriend)                        //1
+		f := NewFriend(zk)
+		friendRouterGroup.POST("/add_friend", f.ApplyToAddFriend)                 //1
 		friendRouterGroup.POST("/delete_friend", f.DeleteFriend)                  //1
 		friendRouterGroup.POST("/get_friend_apply_list", f.GetFriendApplyList)    //1
 		friendRouterGroup.POST("/get_self_friend_apply_list", f.GetSelfApplyList) //1
 		friendRouterGroup.POST("/get_friend_list", f.GetFriendList)               //1
-		friendRouterGroup.POST("/add_friend_response", f.AddFriendResponse)       //1
+		friendRouterGroup.POST("/add_friend_response", f.RespondFriendApply)      //1
 		friendRouterGroup.POST("/set_friend_remark", f.SetFriendRemark)           //1
 		friendRouterGroup.POST("/add_black", f.AddBlack)                          //1
-		friendRouterGroup.POST("/get_black_list", f.GetBlacklist)                 //1
-		friendRouterGroup.POST("/remove_black", f.RemoveBlacklist)                //1
-		friendRouterGroup.POST("/import_friend", f.ImportFriend)                  //1
+		friendRouterGroup.POST("/get_black_list", f.GetPaginationBlacks)          //1
+		friendRouterGroup.POST("/remove_black", f.RemoveBlack)                    //1
+		friendRouterGroup.POST("/import_friend", f.ImportFriends)                 //1
 		friendRouterGroup.POST("/is_friend", f.IsFriend)                          //1
 
 	}
 	groupRouterGroup := r.Group("/group")
-	g := NewGroup(nil)
+	g := NewGroup(zk)
 	{
 		groupRouterGroup.POST("/create_group", g.NewCreateGroup)                                //1
 		groupRouterGroup.POST("/set_group_info", g.NewSetGroupInfo)                             //1
@@ -99,8 +100,8 @@ func NewGinRouter() *gin.Engine {
 	////certificate
 	authRouterGroup := r.Group("/auth")
 	{
-		a := NewAuth(nil)
-		u := NewUser(nil)
+		a := NewAuth(zk)
+		u := NewUser(zk)
 		authRouterGroup.POST("/user_register", u.UserRegister) //1
 		authRouterGroup.POST("/user_token", a.UserToken)       //1
 		authRouterGroup.POST("/parse_token", a.ParseToken)     //1
@@ -109,17 +110,16 @@ func NewGinRouter() *gin.Engine {
 	////Third service
 	thirdGroup := r.Group("/third")
 	{
-		thirdGroup.POST("/tencent_cloud_storage_credential", third.TencentCloudStorageCredential)
-		thirdGroup.POST("/ali_oss_credential", third.AliOSSCredential)
-		thirdGroup.POST("/minio_storage_credential", third.MinioStorageCredential)
-		thirdGroup.POST("/minio_upload", third.MinioUploadFile)
-		thirdGroup.POST("/upload_update_app", third.UploadUpdateApp)
-		thirdGroup.POST("/get_download_url", third.GetDownloadURL)
-		thirdGroup.POST("/get_rtc_invitation_info", third.GetRTCInvitationInfo)
-		thirdGroup.POST("/get_rtc_invitation_start_app", third.GetRTCInvitationInfoStartApp)
-		thirdGroup.POST("/fcm_update_token", third.FcmUpdateToken)
-		thirdGroup.POST("/aws_storage_credential", third.AwsStorageCredential)
-		thirdGroup.POST("/set_app_badge", third.SetAppBadge)
+		t := NewThird(zk)
+
+		thirdGroup.POST("/get_rtc_invitation_info", t.GetSignalInvitationInfo)
+		thirdGroup.POST("/get_rtc_invitation_start_app", t.GetSignalInvitationInfoStartApp)
+		thirdGroup.POST("/fcm_update_token", t.FcmUpdateToken)
+		thirdGroup.POST("/set_app_badge", t.SetAppBadge)
+
+		thirdGroup.POST("/apply_put", t.ApplyPut)
+		thirdGroup.POST("/get_put", t.GetPut)
+		thirdGroup.POST("/confirm_put", t.ConfirmPut)
 	}
 	////Message
 	chatGroup := r.Group("/msg")
@@ -143,13 +143,36 @@ func NewGinRouter() *gin.Engine {
 	////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)
+		c := NewConversation(zk)
+		conversationGroup.POST("/get_all_conversations", c.GetAllConversations)
+		conversationGroup.POST("/get_conversation", c.GetConversation)
+		conversationGroup.POST("/get_conversations", c.GetConversations)
+		conversationGroup.POST("/set_conversation", c.SetConversation)
+		conversationGroup.POST("/batch_set_conversation", c.BatchSetConversations)
+		conversationGroup.POST("/set_recv_msg_opt", c.SetRecvMsgOpt)
+		conversationGroup.POST("/modify_conversation_field", c.ModifyConversationField)
 	}
 	return r
 }
+
+/*
+
+	{
+		GetSeq
+		SendMsg
+		PullMsgBySeqList
+		DelMsg
+		DelSuperGroupMsg
+		ClearMsg
+		SetMsgMinSeq
+		SetMessageReactionExtensions
+		GetMessageListReactionExtensions
+		AddMessageReactionExtensions
+		DeleteMessageReactionExtensions
+		ManagementSendMsg
+		ManagementBatchSendMsg
+		CheckMsgIsSendSuccess
+	}
+
+
+*/

internal/api/third.go

@@ -0,0 +1,56 @@
+package api
+
+import (
+	"OpenIM/internal/api/a2r"
+	"OpenIM/pkg/common/config"
+	"OpenIM/pkg/proto/third"
+	"context"
+	"github.com/OpenIMSDK/openKeeper"
+	"github.com/gin-gonic/gin"
+)
+
+var _ context.Context // 解决goland编辑器bug
+
+func NewThird(zk *openKeeper.ZkClient) *Third {
+	return &Third{zk: zk}
+}
+
+type Third struct {
+	zk *openKeeper.ZkClient
+}
+
+func (o *Third) client() (third.ThirdClient, error) {
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImThirdName)
+	if err != nil {
+		return nil, err
+	}
+	return third.NewThirdClient(conn), nil
+}
+
+func (o *Third) ApplyPut(c *gin.Context) {
+	a2r.Call(third.ThirdClient.ApplyPut, o.client, c)
+}
+
+func (o *Third) GetPut(c *gin.Context) {
+	a2r.Call(third.ThirdClient.GetPut, o.client, c)
+}
+
+func (o *Third) ConfirmPut(c *gin.Context) {
+	a2r.Call(third.ThirdClient.ConfirmPut, o.client, c)
+}
+
+func (o *Third) GetSignalInvitationInfo(c *gin.Context) {
+	a2r.Call(third.ThirdClient.GetSignalInvitationInfo, o.client, c)
+}
+
+func (o *Third) GetSignalInvitationInfoStartApp(c *gin.Context) {
+	a2r.Call(third.ThirdClient.GetSignalInvitationInfoStartApp, o.client, c)
+}
+
+func (o *Third) FcmUpdateToken(c *gin.Context) {
+	a2r.Call(third.ThirdClient.FcmUpdateToken, o.client, c)
+}
+
+func (o *Third) SetAppBadge(c *gin.Context) {
+	a2r.Call(third.ThirdClient.SetAppBadge, o.client, c)
+}

internal/api/third/ali_oss_credential.go

@@ -1,101 +0,0 @@
-package third
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/constant"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	"fmt"
-	openapi "github.com/alibabacloud-go/darabonba-openapi/client"
-	sts20150401 "github.com/alibabacloud-go/sts-20150401/client"
-	"github.com/alibabacloud-go/tea/tea"
-	"github.com/fatih/structs"
-
-	//"github.com/fatih/structs"
-	"github.com/gin-gonic/gin"
-	"net/http"
-	"time"
-)
-
-var stsClient *sts20150401.Client
-
-/**
- * 使用AK&SK初始化账号Client
- * @param accessKeyId
- * @param accessKeySecret
- * @return Client
- * @throws Exception
- */
-func getStsClient() *sts20150401.Client {
-	if stsClient != nil {
-		return stsClient
-	}
-	conf := &openapi.Config{
-		// 您的AccessKey ID
-		AccessKeyId: tea.String(config.Config.Credential.Ali.AccessKeyID),
-		// 您的AccessKey Secret
-		AccessKeySecret: tea.String(config.Config.Credential.Ali.AccessKeySecret),
-		// Endpoint
-		Endpoint: tea.String(config.Config.Credential.Ali.StsEndpoint),
-	}
-	result, err := sts20150401.NewClient(conf)
-	if err != nil {
-		log.NewError("", "alists client初始化失败 ", err)
-	}
-	stsClient = result
-	return stsClient
-}
-
-func AliOSSCredential(c *gin.Context) {
-	req := api.OSSCredentialReq{}
-	if err := c.BindJSON(&req); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-
-	var ok bool
-	var userID string
-	var errInfo string
-	ok, userID, errInfo = tokenverify.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, "AliOSSCredential args ", userID)
-
-	stsResp, err := getStsClient().AssumeRole(&sts20150401.AssumeRoleRequest{
-		DurationSeconds: tea.Int64(config.Config.Credential.Ali.StsDurationSeconds),
-		Policy:          nil,
-		RoleArn:         tea.String(config.Config.Credential.Ali.OssRoleArn),
-		RoleSessionName: tea.String(fmt.Sprintf("%s-%d", userID, time.Now().Unix())),
-	})
-
-	resp := api.OSSCredentialResp{}
-	if err != nil {
-		resp.ErrCode = constant.ErrTencentCredential.ErrCode
-		resp.ErrMsg = err.Error()
-	} else {
-		resp = api.OSSCredentialResp{
-			CommResp: api.CommResp{},
-			OssData: api.OSSCredentialRespData{
-				Endpoint:        config.Config.Credential.Ali.OssEndpoint,
-				AccessKeyId:     *stsResp.Body.Credentials.AccessKeyId,
-				AccessKeySecret: *stsResp.Body.Credentials.AccessKeySecret,
-				Token:           *stsResp.Body.Credentials.SecurityToken,
-				Bucket:          config.Config.Credential.Ali.Bucket,
-				FinalHost:       config.Config.Credential.Ali.FinalHost,
-			},
-			Data: nil,
-		}
-	}
-
-	resp.Data = structs.Map(&resp.OssData)
-	log.NewInfo(req.OperationID, "AliOSSCredential return ", resp)
-
-	c.JSON(http.StatusOK, resp)
-}

internal/api/third/aws_storage_credential.go

@@ -1,76 +0,0 @@
-package third
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/constant"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	"OpenIM/pkg/utils"
-	"context"
-	"net/http"
-
-	"github.com/aws/aws-sdk-go-v2/aws"
-	awsConfig "github.com/aws/aws-sdk-go-v2/config"
-	"github.com/aws/aws-sdk-go-v2/credentials"
-	"github.com/aws/aws-sdk-go-v2/service/sts"
-	"github.com/gin-gonic/gin"
-)
-
-func AwsStorageCredential(c *gin.Context) {
-	var (
-		req  api.AwsStorageCredentialReq
-		resp api.AwsStorageCredentialResp
-	)
-	if err := c.BindJSON(&req); err != nil {
-		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	var ok bool
-	var errInfo string
-	ok, _, errInfo = tokenverify.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
-	}
-	//原始帐号信息
-	awsSourceConfig, err := awsConfig.LoadDefaultConfig(context.TODO(), awsConfig.WithRegion(config.Config.Credential.Aws.Region),
-		awsConfig.WithCredentialsProvider(credentials.StaticCredentialsProvider{
-			Value: aws.Credentials{
-				AccessKeyID:     config.Config.Credential.Aws.AccessKeyID,
-				SecretAccessKey: config.Config.Credential.Aws.AccessKeySecret,
-				Source:          "Open IM OSS",
-			},
-		}))
-	if err != nil {
-		errMsg := req.OperationID + " " + "Init AWS S3 Credential failed " + err.Error() + " token:" + c.Request.Header.Get("token")
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	//帐号转化
-	awsStsClient := sts.NewFromConfig(awsSourceConfig)
-	StsRole, err := awsStsClient.AssumeRole(context.Background(), &sts.AssumeRoleInput{
-		RoleArn:         aws.String(config.Config.Credential.Aws.RoleArn),
-		DurationSeconds: aws.Int32(constant.AwsDurationTimes),
-		RoleSessionName: aws.String(config.Config.Credential.Aws.RoleSessionName),
-		ExternalId:      aws.String(config.Config.Credential.Aws.ExternalId),
-	})
-	if err != nil {
-		errMsg := req.OperationID + " " + "AWS S3 AssumeRole failed " + err.Error() + " token:" + c.Request.Header.Get("token")
-		log.NewError(req.OperationID, errMsg)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-	resp.CosData.AccessKeyId = string(*StsRole.Credentials.AccessKeyId)
-	resp.CosData.SecretAccessKey = string(*StsRole.Credentials.SecretAccessKey)
-	resp.CosData.SessionToken = string(*StsRole.Credentials.SessionToken)
-	resp.CosData.Bucket = config.Config.Credential.Aws.Bucket
-	resp.CosData.RegionID = config.Config.Credential.Aws.Region
-	resp.CosData.FinalHost = config.Config.Credential.Aws.FinalHost
-	c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
-}

internal/api/third/fcm_update_token.go

@@ -1,48 +0,0 @@
-package third
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	"OpenIM/pkg/utils"
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-func FcmUpdateToken(c *gin.Context) {
-	var (
-		req  api.FcmUpdateTokenReq
-		resp api.FcmUpdateTokenResp
-	)
-	if err := c.Bind(&req); err != nil {
-		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
-
-	ok, UserId, errInfo := tokenverify.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)
-		resp.ErrCode = 500
-		resp.ErrMsg = errMsg
-		c.JSON(http.StatusInternalServerError, resp)
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req, UserId)
-	//逻辑处理开始
-	err := db.DB.SetFcmToken(UserId, req.Platform, req.FcmToken, 0)
-	if err != nil {
-		errMsg := req.OperationID + " " + "SetFcmToken failed " + err.Error() + " token:" + c.Request.Header.Get("token")
-		log.NewError(req.OperationID, errMsg)
-		resp.ErrCode = 500
-		resp.ErrMsg = errMsg
-		c.JSON(http.StatusInternalServerError, resp)
-		return
-	}
-	//逻辑处理完毕
-	c.JSON(http.StatusOK, resp)
-	return
-}

internal/api/third/minio_init.go

@@ -1,101 +0,0 @@
-package third
-
-import (
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/utils"
-	"context"
-	"fmt"
-	"github.com/minio/minio-go/v7"
-	"github.com/minio/minio-go/v7/pkg/credentials"
-	url2 "net/url"
-)
-
-var (
-	MinioClient *minio.Client
-)
-
-func MinioInit() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, utils.GetSelfFuncName(), "minio config: ", config.Config.Credential.Minio)
-	var initUrl string
-	if config.Config.Credential.Minio.EndpointInnerEnable {
-		initUrl = config.Config.Credential.Minio.EndpointInner
-	} else {
-		initUrl = config.Config.Credential.Minio.Endpoint
-	}
-	log.NewInfo(operationID, utils.GetSelfFuncName(), "use initUrl: ", initUrl)
-	minioUrl, err := url2.Parse(initUrl)
-	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "parse failed, please check config/config.yaml", err.Error())
-		return
-	}
-	opts := &minio.Options{
-		Creds: credentials.NewStaticV4(config.Config.Credential.Minio.AccessKeyID, config.Config.Credential.Minio.SecretAccessKey, ""),
-		//Region: config.Config.Credential.Minio.Location,
-	}
-	if minioUrl.Scheme == "http" {
-		opts.Secure = false
-	} else if minioUrl.Scheme == "https" {
-		opts.Secure = true
-	}
-	log.NewInfo(operationID, utils.GetSelfFuncName(), "Parse ok ", config.Config.Credential.Minio)
-	MinioClient, err = minio.New(minioUrl.Host, opts)
-	log.NewInfo(operationID, utils.GetSelfFuncName(), "new ok ", config.Config.Credential.Minio)
-	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "init minio client failed", err.Error())
-		return
-	}
-	opt := minio.MakeBucketOptions{
-		Region: config.Config.Credential.Minio.Location,
-	}
-	if config.Config.Credential.Minio.IsDistributedMod == true {
-		opt.ObjectLocking = true
-	}
-	err = MinioClient.MakeBucket(context.Background(), config.Config.Credential.Minio.Bucket, opt)
-	if err != nil {
-		log.NewInfo(operationID, utils.GetSelfFuncName(), "MakeBucket failed ", err.Error())
-		exists, err := MinioClient.BucketExists(context.Background(), config.Config.Credential.Minio.Bucket)
-		if err == nil && exists {
-			log.NewInfo(operationID, utils.GetSelfFuncName(), "We already own ", config.Config.Credential.Minio.Bucket)
-		} else {
-			if err != nil {
-				log.NewInfo(operationID, utils.GetSelfFuncName(), err.Error())
-			}
-			log.NewInfo(operationID, utils.GetSelfFuncName(), "create bucket failed and bucket not exists")
-			return
-		}
-	}
-	// make app bucket
-	err = MinioClient.MakeBucket(context.Background(), config.Config.Credential.Minio.AppBucket, opt)
-	if err != nil {
-		log.NewInfo(operationID, utils.GetSelfFuncName(), "MakeBucket failed ", err.Error())
-		exists, err := MinioClient.BucketExists(context.Background(), config.Config.Credential.Minio.Bucket)
-		if err == nil && exists {
-			log.NewInfo(operationID, utils.GetSelfFuncName(), "We already own ", config.Config.Credential.Minio.Bucket)
-		} else {
-			if err != nil {
-				log.NewInfo(operationID, utils.GetSelfFuncName(), err.Error())
-			}
-			log.NewInfo(operationID, utils.GetSelfFuncName(), "create bucket failed and bucket not exists")
-			return
-		}
-	}
-	policy, err := MinioClient.GetBucketPolicy(context.Background(), config.Config.Credential.Minio.Bucket)
-	log.NewInfo("", utils.GetSelfFuncName(), policy)
-
-	// 自动化桶public的代码
-	policyJsonString := fmt.Sprintf(`{"Version": "2012-10-17","Statement": [{"Action": ["s3:GetObject","s3:PutObject"],
-		"Effect": "Allow","Principal": {"AWS": ["*"]},"Resource": ["arn:aws:s3:::%s/*"],"Sid": ""}]}`, config.Config.Credential.Minio.Bucket)
-	err = MinioClient.SetBucketPolicy(context.Background(), config.Config.Credential.Minio.Bucket, policyJsonString)
-	if err != nil {
-		log.NewInfo("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
-	}
-	policyJsonString = fmt.Sprintf(`{"Version": "2012-10-17","Statement": [{"Action": ["s3:GetObject","s3:PutObject"],
-		"Effect": "Allow","Principal": {"AWS": ["*"]},"Resource": ["arn:aws:s3:::%s/*"],"Sid": ""}]}`, config.Config.Credential.Minio.AppBucket)
-	err = MinioClient.SetBucketPolicy(context.Background(), config.Config.Credential.Minio.AppBucket, policyJsonString)
-	if err != nil {
-		log.NewInfo("", utils.GetSelfFuncName(), "SetBucketPolicy failed please set in web", err.Error())
-	}
-	log.NewInfo(operationID, utils.GetSelfFuncName(), "minio create and set policy success")
-}

internal/api/third/minio_storage_credential.go

@@ -1,276 +0,0 @@
-package third
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/constant"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	_ "OpenIM/pkg/common/tokenverify"
-	"OpenIM/pkg/utils"
-	"context"
-	"github.com/gin-gonic/gin"
-	"github.com/minio/minio-go/v7"
-	_ "github.com/minio/minio-go/v7"
-	cr "github.com/minio/minio-go/v7/pkg/credentials"
-	"net/http"
-	"strconv"
-	"strings"
-)
-
-// @Summary minio上传文件(web api)
-// @Description minio上传文件(web api), 请注意本api请求为form并非json
-// @Tags 第三方服务相关
-// @ID MinioUploadFile
-// @Accept json
-// @Param token header string true "im token"
-// @Param file formData file true "要上传的文件文件"
-// @Param fileType formData int true "文件类型"
-// @Param operationID formData string true "操作唯一ID"
-// @Produce json
-// @Success 0 {object} api.MinioUploadFileResp ""
-// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
-// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
-// @Router /third/minio_upload [post]
-func MinioUploadFile(c *gin.Context) {
-	var (
-		req  api.MinioUploadFileReq
-		resp api.MinioUploadFile
-	)
-	defer func() {
-		if r := recover(); r != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), r)
-			c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "missing file or snapShot args"})
-			return
-		}
-	}()
-	if err := c.Bind(&req); err != nil {
-		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
-	var ok bool
-	var errInfo string
-	ok, _, errInfo = tokenverify.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.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
-		return
-	}
-
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
-	switch req.FileType {
-	// videoType upload snapShot
-	case constant.VideoType:
-		snapShotFile, err := c.FormFile("snapShot")
-		if err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "missing snapshot arg: " + err.Error()})
-			return
-		}
-		snapShotFileObj, err := snapShotFile.Open()
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "Open file error", err.Error())
-			c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-			return
-		}
-		snapShotNewName, snapShotNewType := utils.GetNewFileNameAndContentType(snapShotFile.Filename, constant.ImageType)
-		log.Debug(req.OperationID, utils.GetSelfFuncName(), snapShotNewName, snapShotNewType)
-		_, err = MinioClient.PutObject(context.Background(), config.Config.Credential.Minio.Bucket, snapShotNewName, snapShotFileObj, snapShotFile.Size, minio.PutObjectOptions{ContentType: snapShotNewType})
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "PutObject snapShotFile error", err.Error())
-			c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-			return
-		}
-		resp.SnapshotURL = config.Config.Credential.Minio.Endpoint + "/" + config.Config.Credential.Minio.Bucket + "/" + snapShotNewName
-		resp.SnapshotNewName = snapShotNewName
-	}
-	file, err := c.FormFile("file")
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "FormFile failed", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "missing file arg: " + err.Error()})
-		return
-	}
-	fileObj, err := file.Open()
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "Open file error", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "invalid file path" + err.Error()})
-		return
-	}
-	newName, newType := utils.GetNewFileNameAndContentType(file.Filename, req.FileType)
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), config.Config.Credential.Minio.Bucket, newName, fileObj, file.Size, newType, MinioClient.EndpointURL())
-	_, err = MinioClient.PutObject(context.Background(), config.Config.Credential.Minio.Bucket, newName, fileObj, file.Size, minio.PutObjectOptions{ContentType: newType})
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "upload file error", err.Error())
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "upload file error" + err.Error()})
-		return
-	}
-	resp.NewName = newName
-	resp.URL = config.Config.Credential.Minio.Endpoint + "/" + config.Config.Credential.Minio.Bucket + "/" + newName
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
-	c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
-	return
-}
-
-func MinioStorageCredential(c *gin.Context) {
-	var (
-		req  api.MinioStorageCredentialReq
-		resp api.MiniostorageCredentialResp
-	)
-	if err := c.BindJSON(&req); err != nil {
-		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	var ok bool
-	var errInfo string
-	ok, _, errInfo = tokenverify.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
-	}
-
-	var stsOpts cr.STSAssumeRoleOptions
-	stsOpts.AccessKey = config.Config.Credential.Minio.AccessKeyID
-	stsOpts.SecretKey = config.Config.Credential.Minio.SecretAccessKey
-	stsOpts.DurationSeconds = constant.MinioDurationTimes
-	var endpoint string
-	if config.Config.Credential.Minio.EndpointInnerEnable {
-		endpoint = config.Config.Credential.Minio.EndpointInner
-	} else {
-		endpoint = config.Config.Credential.Minio.Endpoint
-	}
-	li, err := cr.NewSTSAssumeRole(endpoint, stsOpts)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "NewSTSAssumeRole failed", err.Error(), stsOpts, config.Config.Credential.Minio.Endpoint)
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	v, err := li.Get()
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "li.Get error", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	resp.SessionToken = v.SessionToken
-	resp.SecretAccessKey = v.SecretAccessKey
-	resp.AccessKeyID = v.AccessKeyID
-	resp.BucketName = config.Config.Credential.Minio.Bucket
-	resp.StsEndpointURL = config.Config.Credential.Minio.Endpoint
-	resp.StorageTime = config.Config.Credential.Minio.StorageTime
-	resp.IsDistributedMod = config.Config.Credential.Minio.IsDistributedMod
-	c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "data": resp})
-}
-
-func UploadUpdateApp(c *gin.Context) {
-	var (
-		req  api.UploadUpdateAppReq
-		resp api.UploadUpdateAppResp
-	)
-	if err := c.Bind(&req); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-
-	var yamlName string
-	if req.Yaml == nil {
-		yamlName = ""
-	} else {
-		yamlName = req.Yaml.Filename
-	}
-	fileObj, err := req.File.Open()
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "Open file error", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "Open file error" + err.Error()})
-		return
-	}
-	_, err = MinioClient.PutObject(context.Background(), config.Config.Credential.Minio.AppBucket, req.File.Filename, fileObj, req.File.Size, minio.PutObjectOptions{})
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "PutObject file error")
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "PutObject file error" + err.Error()})
-		return
-	}
-	if yamlName != "" {
-		yamlObj, err := req.Yaml.Open()
-		if err == nil {
-			_, err = MinioClient.PutObject(context.Background(), config.Config.Credential.Minio.AppBucket, yamlName, yamlObj, req.Yaml.Size, minio.PutObjectOptions{})
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), "PutObject yaml error")
-				c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "PutObject yaml error" + err.Error()})
-				return
-			}
-		} else {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-		}
-	}
-	if err := imdb.UpdateAppVersion(req.Type, req.Version, req.ForceUpdate, req.File.Filename, yamlName, req.UpdateLog); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "UpdateAppVersion error", err.Error())
-		resp.ErrCode = http.StatusInternalServerError
-		resp.ErrMsg = err.Error()
-		c.JSON(http.StatusInternalServerError, resp)
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName())
-	c.JSON(http.StatusOK, resp)
-}
-
-func version2Int(version string) (int, error) {
-	versions := strings.Split(version, ".")
-	s := strings.Join(versions, "")
-	versionInt, err := strconv.Atoi(s)
-	return versionInt, err
-}
-
-func GetDownloadURL(c *gin.Context) {
-	var (
-		req  api.GetDownloadURLReq
-		resp api.GetDownloadURLResp
-	)
-	defer func() {
-		log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
-	}()
-	if err := c.Bind(&req); err != nil {
-		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	app, err := imdb.GetNewestVersion(req.Type)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "getNewestVersion failed", err.Error())
-	}
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "app: ", app)
-	if app != nil {
-		appVersion, err := version2Int(app.Version)
-		reqVersion, err := version2Int(req.Version)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), "req version", req.Version, "app version", app.Version)
-		}
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "req version:", reqVersion, "app version:", appVersion)
-		if appVersion > reqVersion && app.Version != "" {
-			resp.Data.HasNewVersion = true
-			if app.ForceUpdate == true {
-				resp.Data.ForceUpdate = true
-			}
-			if app.YamlName != "" {
-				resp.Data.YamlURL = config.Config.Credential.Minio.Endpoint + "/" + config.Config.Credential.Minio.AppBucket + "/" + app.YamlName
-			}
-			resp.Data.FileURL = config.Config.Credential.Minio.Endpoint + "/" + config.Config.Credential.Minio.AppBucket + "/" + app.FileName
-			resp.Data.Version = app.Version
-			resp.Data.UpdateLog = app.UpdateLog
-			c.JSON(http.StatusOK, resp)
-			return
-		} else {
-			resp.Data.HasNewVersion = false
-			c.JSON(http.StatusOK, resp)
-			return
-		}
-	}
-	c.JSON(http.StatusBadRequest, gin.H{"errCode": 0, "errMsg": "not found app version"})
-}

internal/api/third/rtc.go

@@ -1,95 +0,0 @@
-package third
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	"OpenIM/pkg/utils"
-	"github.com/gin-gonic/gin"
-	"net/http"
-)
-
-func GetRTCInvitationInfo(c *gin.Context) {
-	var (
-		req  api.GetRTCInvitationInfoReq
-		resp api.GetRTCInvitationInfoResp
-	)
-	if err := c.Bind(&req); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	ok, userID, errInfo := tokenverify.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
-	}
-	var err error
-	invitationInfo, err := db.DB.GetSignalInfoFromCacheByClientMsgID(req.ClientMsgID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetSignalInfoFromCache", err.Error(), req)
-		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
-		return
-	}
-	if err := db.DB.DelUserSignalList(userID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelUserSignalList result:", err.Error())
-	}
-
-	resp.Data.OpUserID = invitationInfo.OpUserID
-	resp.Data.Invitation.RoomID = invitationInfo.Invitation.RoomID
-	resp.Data.Invitation.SessionType = invitationInfo.Invitation.SessionType
-	resp.Data.Invitation.GroupID = invitationInfo.Invitation.GroupID
-	resp.Data.Invitation.InviterUserID = invitationInfo.Invitation.InviterUserID
-	resp.Data.Invitation.InviteeUserIDList = invitationInfo.Invitation.InviteeUserIDList
-	resp.Data.Invitation.MediaType = invitationInfo.Invitation.MediaType
-	resp.Data.Invitation.Timeout = invitationInfo.Invitation.Timeout
-	resp.Data.Invitation.InitiateTime = invitationInfo.Invitation.InitiateTime
-	resp.Data.Invitation.PlatformID = invitationInfo.Invitation.PlatformID
-	resp.Data.Invitation.CustomData = invitationInfo.Invitation.CustomData
-	c.JSON(http.StatusOK, resp)
-}
-
-func GetRTCInvitationInfoStartApp(c *gin.Context) {
-	var (
-		req  api.GetRTCInvitationInfoStartAppReq
-		resp api.GetRTCInvitationInfoStartAppResp
-	)
-	if err := c.Bind(&req); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
-	var ok bool
-	var errInfo string
-	ok, userID, errInfo := tokenverify.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
-	}
-
-	invitationInfo, err := db.DB.GetAvailableSignalInvitationInfo(userID)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetSignalInfoFromCache", err.Error(), req)
-		c.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": err.Error(), "data": struct{}{}})
-		return
-	}
-	resp.Data.OpUserID = invitationInfo.OpUserID
-	resp.Data.Invitation.RoomID = invitationInfo.Invitation.RoomID
-	resp.Data.Invitation.SessionType = invitationInfo.Invitation.SessionType
-	resp.Data.Invitation.GroupID = invitationInfo.Invitation.GroupID
-	resp.Data.Invitation.InviterUserID = invitationInfo.Invitation.InviterUserID
-	resp.Data.Invitation.InviteeUserIDList = invitationInfo.Invitation.InviteeUserIDList
-	resp.Data.Invitation.MediaType = invitationInfo.Invitation.MediaType
-	resp.Data.Invitation.Timeout = invitationInfo.Invitation.Timeout
-	resp.Data.Invitation.InitiateTime = invitationInfo.Invitation.InitiateTime
-	resp.Data.Invitation.PlatformID = invitationInfo.Invitation.PlatformID
-	resp.Data.Invitation.CustomData = invitationInfo.Invitation.CustomData
-	c.JSON(http.StatusOK, resp)
-
-}

internal/api/third/set_app_badge.go

@@ -1,49 +0,0 @@
-package third
-
-import (
-	api "OpenIM/pkg/apistruct"
-	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/tokenverify"
-	"OpenIM/pkg/utils"
-	"github.com/gin-gonic/gin"
-	"net/http"
-)
-
-func SetAppBadge(c *gin.Context) {
-	var (
-		req  api.SetAppBadgeReq
-		resp api.SetAppBadgeResp
-	)
-	if err := c.Bind(&req); err != nil {
-		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
-		return
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
-
-	var ok bool
-	var errInfo, opUserID string
-	ok, opUserID, errInfo = tokenverify.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.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
-		return
-	}
-	if !tokenverify.CheckAccess(c, opUserID, req.FromUserID) {
-		log.NewError(req.OperationID, "CheckAccess false ", opUserID, req.FromUserID)
-		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": "no permission"})
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req, opUserID)
-	err := db.DB.SetUserBadgeUnreadCountSum(req.FromUserID, int(req.AppUnreadCount))
-	if err != nil {
-		errMsg := req.OperationID + " " + "SetUserBadgeUnreadCountSum failed " + err.Error() + " token:" + c.Request.Header.Get("token")
-		log.NewError(req.OperationID, errMsg)
-		resp.ErrCode = 500
-		resp.ErrMsg = errMsg
-		c.JSON(http.StatusInternalServerError, resp)
-		return
-	}
-	c.JSON(http.StatusOK, resp)
-	return
-}

internal/api/third/tencent_cloud_storage_credential.go

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

internal/api/user.go

@@ -19,58 +19,54 @@ type User struct {
 	zk *openKeeper.ZkClient
 }
 
-func (u *User) getGroupClient() (user.UserClient, error) {
-	conn, err := u.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+func (o *User) client() (user.UserClient, error) {
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
 	if err != nil {
 		return nil, err
 	}
 	return user.NewUserClient(conn), nil
 }
 
-func (u *User) UserRegister(c *gin.Context) {
-	a2r.Call(user.UserClient.UserRegister, u.getGroupClient, c)
+func (o *User) UpdateUserInfo(c *gin.Context) {
+	a2r.Call(user.UserClient.UpdateUserInfo, o.client, c)
 }
 
-func (u *User) UpdateUserInfo(c *gin.Context) {
-	a2r.Call(user.UserClient.UpdateUserInfo, u.getGroupClient, c)
+func (o *User) SetGlobalRecvMessageOpt(c *gin.Context) {
+	a2r.Call(user.UserClient.SetGlobalRecvMessageOpt, o.client, c)
 }
 
-func (u *User) SetGlobalRecvMessageOpt(c *gin.Context) {
-	a2r.Call(user.UserClient.SetGlobalRecvMessageOpt, u.getGroupClient, c)
+func (o *User) GetUsersPublicInfo(c *gin.Context) {
+	a2r.Call(user.UserClient.GetDesignateUsers, o.client, c)
 }
 
-func (u *User) GetUsersPublicInfo(c *gin.Context) {
-	a2r.Call(user.UserClient.GetDesignateUsers, u.getGroupClient, c)
+func (o *User) GetSelfUserInfo(c *gin.Context) {
+	a2r.Call(user.UserClient.GetSelfUserInfo, o.client, c)
 }
 
-func (u *User) GetSelfUserInfo(c *gin.Context) {
-	a2r.Call(user.UserClient.GetSelfUserInfo, u.getGroupClient, c)
+func (o *User) GetUsersOnlineStatus(c *gin.Context) {
+	a2r.Call(user.UserClient.GetUsersOnlineStatus, o.client, c)
 }
 
-func (u *User) GetUsersOnlineStatus(c *gin.Context) {
-	a2r.Call(user.UserClient.GetUsersOnlineStatus, u.getGroupClient, c)
+func (o *User) GetUsersInfoFromCache(c *gin.Context) {
+	a2r.Call(user.UserClient.GetUsersInfoFromCache, o.client, c)
 }
 
-func (u *User) GetUsersInfoFromCache(c *gin.Context) {
-	a2r.Call(user.UserClient.GetUsersInfoFromCache, u.getGroupClient, c)
+func (o *User) GetFriendIDListFromCache(c *gin.Context) {
+	a2r.Call(user.UserClient.GetFriendIDListFromCache, o.client, c)
 }
 
-func (u *User) GetFriendIDListFromCache(c *gin.Context) {
-	a2r.Call(user.UserClient.GetFriendIDListFromCache, u.getGroupClient, c)
-}
-
-func (u *User) GetBlackIDListFromCache(c *gin.Context) {
-	a2r.Call(user.UserClient.GetBlackIDListFromCache, u.getGroupClient, c)
+func (o *User) GetBlackIDListFromCache(c *gin.Context) {
+	a2r.Call(user.UserClient.GetBlackIDListFromCache, o.client, c)
 }
 
 //func (u *User) GetAllUsersUid(c *gin.Context) {
-//	a2r.Call(user.UserClient.GetAllUsersUid, u.getGroupClient, c)
+//	a2r.Call(user.UserClient.GetAllUsersUid, u.client, c)
 //}
 //
 //func (u *User) AccountCheck(c *gin.Context) {
-//	a2r.Call(user.UserClient.AccountCheck, u.getGroupClient, c)
+//	a2r.Call(user.UserClient.AccountCheck, u.client, c)
 //}
 
-func (u *User) GetUsers(c *gin.Context) {
-	a2r.Call(user.UserClient.GetPaginationUsers, u.getGroupClient, c)
+func (o *User) GetUsers(c *gin.Context) {
+	a2r.Call(user.UserClient.GetPaginationUsers, o.client, c)
 }

internal/rpc/third/s3.go

@@ -1 +1,18 @@
 package third
+
+import (
+	"OpenIM/pkg/proto/third"
+	"context"
+)
+
+func (t *thirdServer) ApplyPut(ctx context.Context, req *third.ApplyPutReq) (*third.ApplyPutResp, error) {
+	return t.s3dataBase.ApplyPut(ctx, req)
+}
+
+func (t *thirdServer) GetPut(ctx context.Context, req *third.GetPutReq) (*third.GetPutResp, error) {
+	return t.s3dataBase.GetPut(ctx, req)
+}
+
+func (t *thirdServer) ConfirmPut(ctx context.Context, req *third.ConfirmPutReq) (*third.ConfirmPutResp, error) {
+	return t.s3dataBase.ConfirmPut(ctx, req)
+}

internal/rpc/third/third.go

@@ -4,9 +4,9 @@ import (
 	"OpenIM/internal/common/check"
 	"OpenIM/pkg/common/db/cache"
 	"OpenIM/pkg/common/db/controller"
+	"OpenIM/pkg/common/db/obj"
 	"OpenIM/pkg/common/db/relation"
-	"OpenIM/pkg/common/db/tx"
-	"OpenIM/pkg/common/db/unrelation"
+	relationTb "OpenIM/pkg/common/db/table/relation"
 	"OpenIM/pkg/proto/third"
 	"context"
 	"github.com/OpenIMSDK/openKeeper"
@@ -18,20 +18,51 @@ func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
 	if err != nil {
 		return err
 	}
+	o, err := obj.NewMinioInterface()
+	if err != nil {
+		return err
+	}
+	db, err := relation.NewGormDB()
+	if err != nil {
+		return err
+	}
+	if err := db.AutoMigrate(&relationTb.ObjectHashModel{}, &relationTb.ObjectInfoModel{}, &relationTb.ObjectPutModel{}); err != nil {
+		return err
+	}
 	third.RegisterThirdServer(server, &thirdServer{
-		thirdDatabase: controller.NewThirdDatabase(cache.NewCacheModel(rdb)),
+		thirdDatabase: controller.NewThirdDatabase(cache.NewCache(rdb)),
 		userCheck:     check.NewUserCheck(client),
+		s3dataBase:    controller.NewS3Database(o, relation.NewObjectHash(db), relation.NewObjectInfo(db), relation.NewObjectPut(db)),
 	})
 	return nil
 }
 
 type thirdServer struct {
 	thirdDatabase controller.ThirdDatabase
+	s3dataBase    controller.S3Database
 	userCheck     *check.UserCheck
 }
 
-func (t *thirdServer) ApplySpace(ctx context.Context, req *third.ApplySpaceReq) (resp *third.ApplySpaceResp, err error) {
-	return
+func (t *thirdServer) GetSignalInvitationInfo(ctx context.Context, req *third.GetSignalInvitationInfoReq) (resp *third.GetSignalInvitationInfoResp, err error) {
+	signalReq, err := t.thirdDatabase.GetSignalInvitationInfoByClientMsgID(ctx, req.ClientMsgID)
+	if err != nil {
+		return nil, err
+	}
+	resp = &third.GetSignalInvitationInfoResp{}
+	resp.InvitationInfo = signalReq.Invitation
+	resp.OfflinePushInfo = signalReq.OfflinePushInfo
+	return resp, nil
+}
+
+func (t *thirdServer) GetSignalInvitationInfoStartApp(ctx context.Context, req *third.GetSignalInvitationInfoStartAppReq) (resp *third.GetSignalInvitationInfoStartAppResp, err error) {
+	signalReq, err := t.thirdDatabase.GetAvailableSignalInvitationInfo(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	resp = &third.GetSignalInvitationInfoStartAppResp{}
+	resp.InvitationInfo = signalReq.Invitation
+	resp.OfflinePushInfo = signalReq.OfflinePushInfo
+	return resp, nil
 }
 
 func (t *thirdServer) FcmUpdateToken(ctx context.Context, req *third.FcmUpdateTokenReq) (resp *third.FcmUpdateTokenResp, err error) {