Create & Init Project...

app/service/main/coin/api/gorpc/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["coin_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = ["//app/service/main/coin/model:go_default_library"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "coin.go",
+        "mock.go",
+    ],
+    importpath = "go-common/app/service/main/coin/api/gorpc",
+    tags = ["automanaged"],
+    deps = [
+        "//app/service/main/coin/model:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//vendor/github.com/golang/mock/gomock:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/coin/api/gorpc/coin.go

@@ -0,0 +1,104 @@
+package coin
+
+import (
+	"context"
+
+	"go-common/app/service/main/coin/model"
+	"go-common/library/net/rpc"
+)
+
+const (
+	_addCoins         = "RPC.AddCoins"
+	_archiveUserCoins = "RPC.ArchiveUserCoins"
+	_userCoins        = "RPC.UserCoins"
+	_modifyCoin       = "RPC.ModifyCoin"
+	_list             = "RPC.List"
+	_userLog          = "RPC.UserLog"
+	_addUserCoinExp   = "RPC.AddUserCoinExp"
+	_updateAddCoin    = "RPC.UpdateAddCoin"
+	_todayExp         = "RPC.TodayExp"
+)
+
+const (
+	_appid = "community.service.coin"
+)
+
+var (
+	_noRes = &struct{}{}
+)
+
+// Service rpc service.
+type Service struct {
+	client *rpc.Client2
+}
+
+//go:generate mockgen -source coin.go  -destination mock.go -package coin
+
+// RPC coin rpc
+type RPC interface {
+	AddCoins(c context.Context, arg *model.ArgAddCoin) (err error)
+	ArchiveUserCoins(c context.Context, arg *model.ArgCoinInfo) (res *model.ArchiveUserCoins, err error)
+	UserCoins(c context.Context, arg *model.ArgCoinInfo) (count float64, err error)
+}
+
+// New new service.
+func New(c *rpc.ClientConfig) (s *Service) {
+	s = &Service{}
+	s.client = rpc.NewDiscoveryCli(_appid, c)
+	return
+}
+
+// AddCoins coin to archive.
+func (s *Service) AddCoins(c context.Context, arg *model.ArgAddCoin) (err error) {
+	err = s.client.Call(c, _addCoins, arg, _noRes)
+	return
+}
+
+// ArchiveUserCoins get archive User added coins.
+func (s *Service) ArchiveUserCoins(c context.Context, arg *model.ArgCoinInfo) (res *model.ArchiveUserCoins, err error) {
+	res = &model.ArchiveUserCoins{}
+	err = s.client.Call(c, _archiveUserCoins, arg, res)
+	return
+}
+
+// UserCoins get user coins.
+func (s *Service) UserCoins(c context.Context, arg *model.ArgCoinInfo) (count float64, err error) {
+	err = s.client.Call(c, _userCoins, arg, &count)
+	return
+}
+
+// ModifyCoin modify user coin.
+func (s *Service) ModifyCoin(c context.Context, arg *model.ArgModifyCoin) (count float64, err error) {
+	err = s.client.Call(c, _modifyCoin, arg, &count)
+	return
+}
+
+// List coin added list.
+func (s *Service) List(c context.Context, arg *model.ArgList) (list []*model.List, err error) {
+	err = s.client.Call(c, _list, arg, &list)
+	return
+}
+
+// UserLog user log
+func (s *Service) UserLog(c context.Context, arg *model.ArgLog) (logs []*model.Log, err error) {
+	err = s.client.Call(c, _userLog, arg, &logs)
+	return
+}
+
+// AddUserCoinExp add user coin exp
+func (s *Service) AddUserCoinExp(c context.Context, arg *model.ArgAddUserCoinExp) (err error) {
+	err = s.client.Call(c, _addUserCoinExp, arg, _noRes)
+	return
+}
+
+// UpdateAddCoin update db after add coin for job.
+func (s *Service) UpdateAddCoin(c context.Context, arg *model.Record) (err error) {
+	err = s.client.Call(c, _updateAddCoin, arg, _noRes)
+	return
+}
+
+// TodayExp get today exp
+func (s *Service) TodayExp(c context.Context, arg *model.ArgMid) (number int64, err error) {
+	err = s.client.Call(c, _todayExp, arg, &number)
+	return
+}

app/service/main/coin/api/gorpc/coin_test.go

@@ -0,0 +1,38 @@
+package coin
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	coin "go-common/app/service/main/coin/model"
+)
+
+const (
+	mid    = 23675773
+	aid    = 1
+	realIP = "127.0.0.1"
+)
+
+func TestCoin(t *testing.T) {
+	s := New(nil)
+	time.Sleep(1 * time.Second)
+
+	// coin
+	testAddCoins(t, s)
+	testArchiveUserCoins(t, s)
+}
+
+func testAddCoins(t *testing.T, s *Service) {
+	arg := coin.ArgAddCoin{Mid: mid, Aid: aid, Multiply: 1, RealIP: realIP}
+	if err := s.AddCoins(context.TODO(), &arg); err != nil {
+		t.Logf("call.AddCoins error(%v)", err)
+	}
+}
+
+func testArchiveUserCoins(t *testing.T, s *Service) {
+	arg := coin.ArgCoinInfo{Mid: mid, Aid: aid, RealIP: realIP}
+	if res, err := s.ArchiveUserCoins(context.TODO(), &arg); err != nil && res != nil {
+		t.Logf("call.ArchiveUserCoins error(%v)", err)
+	}
+}

app/service/main/coin/api/gorpc/mock.go

@@ -0,0 +1,73 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: coin.go
+
+// Package coin is a generated GoMock package.
+package coin
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	model "go-common/app/service/main/coin/model"
+	reflect "reflect"
+)
+
+// MockRPC is a mock of RPC interface
+type MockRPC struct {
+	ctrl     *gomock.Controller
+	recorder *MockRPCMockRecorder
+}
+
+// MockRPCMockRecorder is the mock recorder for MockRPC
+type MockRPCMockRecorder struct {
+	mock *MockRPC
+}
+
+// NewMockRPC creates a new mock instance
+func NewMockRPC(ctrl *gomock.Controller) *MockRPC {
+	mock := &MockRPC{ctrl: ctrl}
+	mock.recorder = &MockRPCMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockRPC) EXPECT() *MockRPCMockRecorder {
+	return m.recorder
+}
+
+// AddCoins mocks base method
+func (m *MockRPC) AddCoins(c context.Context, arg *model.ArgAddCoin) error {
+	ret := m.ctrl.Call(m, "AddCoins", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddCoins indicates an expected call of AddCoins
+func (mr *MockRPCMockRecorder) AddCoins(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCoins", reflect.TypeOf((*MockRPC)(nil).AddCoins), c, arg)
+}
+
+// ArchiveUserCoins mocks base method
+func (m *MockRPC) ArchiveUserCoins(c context.Context, arg *model.ArgCoinInfo) (*model.ArchiveUserCoins, error) {
+	ret := m.ctrl.Call(m, "ArchiveUserCoins", c, arg)
+	ret0, _ := ret[0].(*model.ArchiveUserCoins)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ArchiveUserCoins indicates an expected call of ArchiveUserCoins
+func (mr *MockRPCMockRecorder) ArchiveUserCoins(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArchiveUserCoins", reflect.TypeOf((*MockRPC)(nil).ArchiveUserCoins), c, arg)
+}
+
+// UserCoins mocks base method
+func (m *MockRPC) UserCoins(c context.Context, arg *model.ArgCoinInfo) (float64, error) {
+	ret := m.ctrl.Call(m, "UserCoins", c, arg)
+	ret0, _ := ret[0].(float64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UserCoins indicates an expected call of UserCoins
+func (mr *MockRPCMockRecorder) UserCoins(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserCoins", reflect.TypeOf((*MockRPC)(nil).UserCoins), c, arg)
+}