From 08fdac83fc2ddb8973e38b2825c8e9d93dfd924f Mon Sep 17 00:00:00 2001
From: withchao <993506633@qq.com>
Date: Mon, 27 Feb 2023 09:53:17 +0800
Subject: [PATCH] api2rpc

---
 internal/api/group/group1.go      | 14 ++++-------
 internal/api/group/group1_test.go |  1 +
 internal/api2rpc/api.go           |  2 +-
 internal/api2rpc/rpc1.go          | 40 ++++++++++++++++++-------------
 4 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/internal/api/group/group1.go b/internal/api/group/group1.go
index 07ce95105..3bd76e6d2 100644
--- a/internal/api/group/group1.go
+++ b/internal/api/group/group1.go
@@ -22,14 +22,10 @@ func (g *Group) getGroupClient() (group.GroupClient, error) {
 }
 
 func (g *Group) KickGroupMember(c *gin.Context) {
-	api2rpc.Rpc(
-		&apistruct.KickGroupMemberReq{},
-		&apistruct.KickGroupMemberResp{},
-		group.GroupClient.KickGroupMember,
-	).Must(c, g.getGroupClient).Call()
+	var fn = group.GroupClient.KickGroupMember
+	api2rpc.New(&apistruct.KickGroupMemberReq{}, &apistruct.KickGroupMemberResp{}, fn).Call(c, g.getGroupClient)
 }
 
-//func (g *Group) KickGroupMember1(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.Rpc(&apistruct.KickGroupMemberReq{}, &apistruct.KickGroupMemberResp{}, fn).Must(c, g.getGroupClient).Call()
-//}
+func (g *Group) GetGroupMembersInfo(c *gin.Context) {
+	api2rpc.New(&apistruct.GetGroupMembersInfoReq{}, &apistruct.GetGroupMembersInfoResp{}, group.GroupClient.GetGroupMembersInfo).Call(c, g.getGroupClient)
+}
diff --git a/internal/api/group/group1_test.go b/internal/api/group/group1_test.go
index 38a10af8c..bfa6a8d9d 100644
--- a/internal/api/group/group1_test.go
+++ b/internal/api/group/group1_test.go
@@ -6,5 +6,6 @@ func TestName(t *testing.T) {
 	var g Group
 
 	g.KickGroupMember(nil)
+	g.GetGroupMembersInfo(nil)
 
 }
diff --git a/internal/api2rpc/api.go b/internal/api2rpc/api.go
index 2e6ee02e5..271e722f3 100644
--- a/internal/api2rpc/api.go
+++ b/internal/api2rpc/api.go
@@ -59,7 +59,7 @@ func rpcString(v interface{}) string {
 }
 
 type baseResp struct {
-	ErrCode int32       `json:"errCode"`
+	ErrCode int         `json:"errCode"`
 	ErrMsg  string      `json:"errMsg"`
 	ErrDtl  string      `json:"errDtl"`
 	Data    interface{} `json:"data"`
diff --git a/internal/api2rpc/rpc1.go b/internal/api2rpc/rpc1.go
index cccdb23f7..8fcb76e56 100644
--- a/internal/api2rpc/rpc1.go
+++ b/internal/api2rpc/rpc1.go
@@ -1,6 +1,7 @@
 package api2rpc
 
 import (
+	"OpenIM/pkg/errs"
 	"context"
 	"github.com/gin-gonic/gin"
 	"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)
 
-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]{
 		apiReq:  apiReq,
 		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 {
 	apiReq  *A
 	apiResp *B
-	client  func() (E, 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
 	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
 }
 
-func (r *rpcCall[A, B, C, D, E]) Must(c *gin.Context, client func() (E, error)) RpcCall[A, B, C, D, E] {
-	r.api = NewGin1(c)
-	r.client = client
-	return r
-}
-
-func (r *rpcCall[A, B, C, D, E]) Call() {
-	r.api.Resp(r.apiResp, r.call())
+func (r *rpcCall[A, B, C, D, E]) Call(c *gin.Context, client func() (E, error)) {
+	var resp baseResp
+	err := r.call(c, client)
+	if err == nil {
+		resp.Data = r.apiResp
+	} else {
+		cerr, ok := err.(errs.Coderr)
+		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 {
@@ -60,8 +67,8 @@ func (r *rpcCall[A, B, C, D, E]) defaultCopyResp(rpcResp *D) error {
 	return nil
 }
 
-func (r *rpcCall[A, B, C, D, E]) call() error {
-	if err := r.api.Bind(r.apiReq); err != nil {
+func (r *rpcCall[A, B, C, D, E]) call(c *gin.Context, client func() (E, error)) error {
+	if err := c.BindJSON(r.apiReq); err != nil {
 		return err
 	}
 	var err error
@@ -74,11 +81,11 @@ func (r *rpcCall[A, B, C, D, E]) call() error {
 	if err != nil {
 		return err
 	}
-	client, err := r.client()
+	cli, err := client()
 	if err != nil {
 		return err
 	}
-	rpcResp, err := r.rpcFn(client, r.api.Context(), &rpcReq)
+	rpcResp, err := r.rpcFn(cli, c, &rpcReq)
 	if err != nil {
 		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 {
 	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]
-	Must(c *gin.Context, client func() (E, error)) RpcCall[A, B, C, D, E]
-	Call()
+	Call(c *gin.Context, client func() (E, error))
 }