blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-08-10 04:59:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

api2rpc

Browse Source
This commit is contained in:
withchao 2023-02-27 09:53:17 +08:00
parent 0547f25ecb
commit 08fdac83fc
4 changed files with 30 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
internal/api/group/group1.go
View File

@ -22,14 +22,10 @@ func (g *Group) getGroupClient() (group.GroupClient, error) {
} }
func (g *Group) KickGroupMember(c *gin.Context) { func (g *Group) KickGroupMember(c *gin.Context) {
api2rpc.Rpc( var fn = group.GroupClient.KickGroupMember
&apistruct.KickGroupMemberReq{}, api2rpc.New(&apistruct.KickGroupMemberReq{}, &apistruct.KickGroupMemberResp{}, fn).Call(c, g.getGroupClient)
&apistruct.KickGroupMemberResp{},
group.GroupClient.KickGroupMember,
).Must(c, g.getGroupClient).Call()
} }
//func (g *Group) KickGroupMember1(c *gin.Context) { func (g *Group) GetGroupMembersInfo(c *gin.Context) {
// var fn func(client group.GroupClient, ctx context.Context, in *group.KickGroupMemberReq, opts ...grpc.CallOption) (*group.KickGroupMemberResp, error) = group.GroupClient.KickGroupMember api2rpc.New(&apistruct.GetGroupMembersInfoReq{}, &apistruct.GetGroupMembersInfoResp{}, group.GroupClient.GetGroupMembersInfo).Call(c, g.getGroupClient)
// api2rpc.Rpc(&apistruct.KickGroupMemberReq{}, &apistruct.KickGroupMemberResp{}, fn).Must(c, g.getGroupClient).Call() }
//}

1
internal/api/group/group1_test.go
View File

@ -6,5 +6,6 @@ func TestName(t *testing.T) {
var g Group var g Group
g.KickGroupMember(nil) g.KickGroupMember(nil)
g.GetGroupMembersInfo(nil)
} }

2
internal/api2rpc/api.go
View File

@ -59,7 +59,7 @@ func rpcString(v interface{}) string {
} }
type baseResp struct { type baseResp struct {
ErrCode int32 `json:"errCode"` ErrCode int `json:"errCode"`
ErrMsg string `json:"errMsg"` ErrMsg string `json:"errMsg"`
ErrDtl string `json:"errDtl"` ErrDtl string `json:"errDtl"`
Data interface{} `json:"data"` Data interface{} `json:"data"`

40
internal/api2rpc/rpc1.go
View File

@ -1,6 +1,7 @@
package api2rpc package api2rpc
import ( import (
"OpenIM/pkg/errs"
"context" "context"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"google.golang.org/grpc" "google.golang.org/grpc"
@ -8,7 +9,7 @@ import (
type rpcFunc[E, C, D any] func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error) type rpcFunc[E, C, D any] func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)
func Rpc[A, B, C, D any, E any](apiReq *A, apiResp *B, rpc func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)) RpcCall[A, B, C, D, E] { func New[A, B, C, D any, E any](apiReq *A, apiResp *B, rpc func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)) RpcCall[A, B, C, D, E] {
return &rpcCall[A, B, C, D, E]{ return &rpcCall[A, B, C, D, E]{
apiReq: apiReq, apiReq: apiReq,
apiResp: apiResp, apiResp: apiResp,
@ -19,9 +20,7 @@ func Rpc[A, B, C, D any, E any](apiReq *A, apiResp *B, rpc func(client E, ctx co
type rpcCall[A, B, C, D any, E any] struct { type rpcCall[A, B, C, D any, E any] struct {
apiReq *A apiReq *A
apiResp *B apiResp *B
client func() (E, error)
rpcFn func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error) rpcFn func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)
api Api
before func(apiReq *A, rpcReq *C, bind func() error) error before func(apiReq *A, rpcReq *C, bind func() error) error
after func(rpcResp *D, apiResp *B, bind func() error) error after func(rpcResp *D, apiResp *B, bind func() error) error
} }
@ -36,14 +35,22 @@ func (r *rpcCall[A, B, C, D, E]) After(fn func(rpcResp *D, apiResp *B, bind func
return r return r
} }
func (r *rpcCall[A, B, C, D, E]) Must(c *gin.Context, client func() (E, error)) RpcCall[A, B, C, D, E] { func (r *rpcCall[A, B, C, D, E]) Call(c *gin.Context, client func() (E, error)) {
r.api = NewGin1(c) var resp baseResp
r.client = client err := r.call(c, client)
return r if err == nil {
} resp.Data = r.apiResp
} else {
func (r *rpcCall[A, B, C, D, E]) Call() { cerr, ok := err.(errs.Coderr)
r.api.Resp(r.apiResp, r.call()) if ok {
resp.ErrCode = cerr.Code()
resp.ErrMsg = cerr.Msg()
resp.ErrDtl = cerr.Detail()
} else {
resp.ErrCode = 10000
resp.ErrMsg = err.Error()
}
}
} }
func (r *rpcCall[A, B, C, D, E]) defaultCopyReq(rpcReq *C) error { func (r *rpcCall[A, B, C, D, E]) defaultCopyReq(rpcReq *C) error {
@ -60,8 +67,8 @@ func (r *rpcCall[A, B, C, D, E]) defaultCopyResp(rpcResp *D) error {
return nil return nil
} }
func (r *rpcCall[A, B, C, D, E]) call() error { func (r *rpcCall[A, B, C, D, E]) call(c *gin.Context, client func() (E, error)) error {
if err := r.api.Bind(r.apiReq); err != nil { if err := c.BindJSON(r.apiReq); err != nil {
return err return err
} }
var err error var err error
@ -74,11 +81,11 @@ func (r *rpcCall[A, B, C, D, E]) call() error {
if err != nil { if err != nil {
return err return err
} }
client, err := r.client() cli, err := client()
if err != nil { if err != nil {
return err return err
} }
rpcResp, err := r.rpcFn(client, r.api.Context(), &rpcReq) rpcResp, err := r.rpcFn(cli, c, &rpcReq)
if err != nil { if err != nil {
return err return err
} }
@ -93,6 +100,5 @@ func (r *rpcCall[A, B, C, D, E]) call() error {
type RpcCall[A, B, C, D, E any] interface { type RpcCall[A, B, C, D, E any] interface {
Before(fn func(apiReq *A, rpcReq *C, bind func() error) error) RpcCall[A, B, C, D, E] Before(fn func(apiReq *A, rpcReq *C, bind func() error) error) RpcCall[A, B, C, D, E]
After(fn func(rpcResp *D, apiResp *B, bind func() error) error) RpcCall[A, B, C, D, E] After(fn func(rpcResp *D, apiResp *B, bind func() error) error) RpcCall[A, B, C, D, E]
Must(c *gin.Context, client func() (E, error)) RpcCall[A, B, C, D, E] Call(c *gin.Context, client func() (E, error))
Call()
} }