Create & Init Project...

app/interface/openplatform/article/rpc/client/BUILD

@@ -0,0 +1,36 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "article.go",
+        "mock.go",
+    ],
+    importpath = "go-common/app/interface/openplatform/article/rpc/client",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/openplatform/article/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/interface/openplatform/article/rpc/client/article.go

@@ -0,0 +1,317 @@
+package client
+
+import (
+	"context"
+
+	"go-common/app/interface/openplatform/article/model"
+	"go-common/library/net/rpc"
+)
+
+const (
+	_addArticle              = "RPC.AddArticle"
+	_updateArticle           = "RPC.UpdateArticle"
+	_delArticle              = "RPC.DelArticle"
+	_creationUpperArticles   = "RPC.CreationUpperArticles"
+	_creationArticle         = "RPC.CreationArticle"
+	_categories              = "RPC.Categories"
+	_categoriesMap           = "RPC.CategoriesMap"
+	_setStat                 = "RPC.SetStat"
+	_addArticleCache         = "RPC.AddArticleCache"
+	_updateArticleCache      = "RPC.UpdateArticleCache"
+	_delArticleCache         = "RPC.DelArticleCache"
+	_upsArtMetas             = "RPC.UpsArtMetas"
+	_artMetas                = "RPC.ArticleMetas"
+	_updateRecommends        = "RPC.UpdateRecommends"
+	_recommends              = "RPC.Recommends"
+	_creationWithdrawArticle = "RPC.CreationWithdrawArticle"
+	_upArtMetas              = "RPC.UpArtMetas"
+	_addArtDraft             = "RPC.AddArtDraft"
+	_delArtDraft             = "RPC.DelArtDraft"
+	_artDraft                = "RPC.ArtDraft"
+	_upperDrafts             = "RPC.UpperDrafts"
+	_articleRemainCount      = "RPC.ArticleRemainCount"
+	_delRecommendArtCache    = "RPC.DelRecommendArtCache"
+	_favorites               = "RPC.Favorites"
+	_updateAuthorCache       = "RPC.UpdateAuthorCache"
+	_updateSortCache         = "RPC.UpdateSortCache"
+	_isAuthor                = "RPC.IsAuthor"
+	_newArticleCount         = "RPC.NewArticleCount"
+	_hadLikesByMid           = "RPC.HadLikesByMid"
+	_upMoreArts              = "RPC.UpMoreArts"
+	_creationUpStat          = "RPC.CreationUpStat"
+	_creationUpThirtyDayStat = "RPC.CreationUpThirtyDayStat"
+	_upLists                 = "RPC.UpLists"
+	_rebuildAllRC            = "RPC.RebuildAllListReadCount"
+	_updateHotspots          = "RPC.UpdateHotspots"
+)
+
+const (
+	_appid = "article.service"
+)
+
+var (
+	_noArg   = &struct{}{}
+	_noReply = &struct{}{}
+)
+
+// Service struct info.
+type Service struct {
+	client *rpc.Client2
+}
+
+//go:generate mockgen -source article.go  -destination mock.go -package client
+
+// ArticleRPC article rpc.
+type ArticleRPC interface {
+	AddArticle(c context.Context, arg *model.ArgArticle) (id int64, err error)
+	AddArticleCache(c context.Context, arg *model.ArgAid) (err error)
+	UpdateArticleCache(c context.Context, arg *model.ArgAidCid) (err error)
+	DelArticleCache(c context.Context, arg *model.ArgAidMid) (err error)
+	UpdateArticle(c context.Context, arg *model.ArgArticle) (err error)
+	CreationWithdrawArticle(c context.Context, arg *model.ArgAidMid) (err error)
+	DelArticle(c context.Context, arg *model.ArgAidMid) (err error)
+	CreationArticle(c context.Context, arg *model.ArgAidMid) (res *model.Article, err error)
+	CreationUpperArticles(c context.Context, arg *model.ArgCreationArts) (res *model.CreationArts, err error)
+	Categories(c context.Context, arg *model.ArgIP) (res *model.Categories, err error)
+	CategoriesMap(c context.Context, arg *model.ArgIP) (res map[int64]*model.Category, err error)
+	SetStat(c context.Context, arg *model.ArgStats) (err error)
+	UpsArtMetas(c context.Context, arg *model.ArgUpsArts) (res map[int64][]*model.Meta, err error)
+	ArticleMetas(c context.Context, arg *model.ArgAids) (res map[int64]*model.Meta, err error)
+	UpdateRecommends(c context.Context) (err error)
+	Recommends(c context.Context, arg *model.ArgRecommends) (res []*model.Meta, err error)
+	UpArtMetas(c context.Context, arg *model.ArgUpArts) (res *model.UpArtMetas, err error)
+	AddArtDraft(c context.Context, arg *model.ArgArticle) (id int64, err error)
+	UpdateArtDraft(c context.Context, arg *model.ArgAidMid) (err error)
+	DelArtDraft(c context.Context, arg *model.ArgAidMid) (err error)
+	ArtDraft(c context.Context, arg *model.ArgAidMid) (res *model.Draft, err error)
+	UpperDrafts(c context.Context, arg *model.ArgUpDraft) (res *model.Drafts, err error)
+	ArticleRemainCount(c context.Context, arg *model.ArgMid) (res int, err error)
+	DelRecommendArtCache(c context.Context, arg *model.ArgAidCid) (err error)
+	Favorites(c context.Context, arg *model.ArgFav) (res []*model.Favorite, err error)
+	UpdateAuthorCache(c context.Context, arg *model.ArgAuthor) (err error)
+	UpdateSortCache(c context.Context, arg *model.ArgSort) (err error)
+	IsAuthor(c context.Context, arg *model.ArgMid) (res bool, err error)
+	NewArticleCount(c context.Context, arg *model.ArgNewArt) (res int64, err error)
+	HadLikesByMid(c context.Context, arg *model.ArgMidAids) (res map[int64]int, err error)
+	UpMoreArts(c context.Context, arg *model.ArgAid) (res []*model.Meta, err error)
+	CreationUpStat(c context.Context, arg *model.ArgMid) (res model.UpStat, err error)
+	CreationUpThirtyDayStat(c context.Context, arg *model.ArgMid) (res []*model.ThirtyDayArticle, err error)
+	UpLists(c context.Context, arg *model.ArgMid) (res model.UpLists, err error)
+}
+
+// New new service instance and return.
+func New(c *rpc.ClientConfig) (s *Service) {
+	s = &Service{}
+	s.client = rpc.NewDiscoveryCli(_appid, c)
+	return
+}
+
+// AddArticle adds article when article passed. purge cache.
+func (s *Service) AddArticle(c context.Context, arg *model.ArgArticle) (id int64, err error) {
+	err = s.client.Call(c, _addArticle, arg, &id)
+	return
+}
+
+// AddArticleCache adds article when article passed. purge cache.
+func (s *Service) AddArticleCache(c context.Context, arg *model.ArgAid) (err error) {
+	err = s.client.Call(c, _addArticleCache, arg, _noReply)
+	return
+}
+
+// UpdateArticleCache adds article when article passed. purge cache.
+func (s *Service) UpdateArticleCache(c context.Context, arg *model.ArgAidCid) (err error) {
+	err = s.client.Call(c, _updateArticleCache, arg, _noReply)
+	return
+}
+
+// DelArticleCache adds article when article passed. purge cache.
+func (s *Service) DelArticleCache(c context.Context, arg *model.ArgAidMid) (err error) {
+	err = s.client.Call(c, _delArticleCache, arg, _noReply)
+	return
+}
+
+// UpdateArticle updates article when article passed. purge cache.
+func (s *Service) UpdateArticle(c context.Context, arg *model.ArgArticle) (err error) {
+	err = s.client.Call(c, _updateArticle, arg, _noReply)
+	return
+}
+
+// CreationWithdrawArticle author withdraw article.
+func (s *Service) CreationWithdrawArticle(c context.Context, arg *model.ArgAidMid) (err error) {
+	err = s.client.Call(c, _creationWithdrawArticle, arg, _noReply)
+	return
+}
+
+// DelArticle drops article when article not passed. purge cache.
+func (s *Service) DelArticle(c context.Context, arg *model.ArgAidMid) (err error) {
+	err = s.client.Call(c, _delArticle, arg, _noReply)
+	return
+}
+
+// CreationArticle gets article's meta.
+func (s *Service) CreationArticle(c context.Context, arg *model.ArgAidMid) (res *model.Article, err error) {
+	err = s.client.Call(c, _creationArticle, arg, &res)
+	return
+}
+
+// CreationUpperArticles gets article's meta.
+func (s *Service) CreationUpperArticles(c context.Context, arg *model.ArgCreationArts) (res *model.CreationArts, err error) {
+	err = s.client.Call(c, _creationUpperArticles, arg, &res)
+	return
+}
+
+// Categories list categories of article
+func (s *Service) Categories(c context.Context, arg *model.ArgIP) (res *model.Categories, err error) {
+	err = s.client.Call(c, _categories, arg, &res)
+	return
+}
+
+// CategoriesMap list categories of article map
+func (s *Service) CategoriesMap(c context.Context, arg *model.ArgIP) (res map[int64]*model.Category, err error) {
+	err = s.client.Call(c, _categoriesMap, arg, &res)
+	return
+}
+
+// SetStat updates article's stat cache.
+func (s *Service) SetStat(c context.Context, arg *model.ArgStats) (err error) {
+	err = s.client.Call(c, _setStat, arg, _noReply)
+	return
+}
+
+// UpsArtMetas list passed article meta of ups
+func (s *Service) UpsArtMetas(c context.Context, arg *model.ArgUpsArts) (res map[int64][]*model.Meta, err error) {
+	err = s.client.Call(c, _upsArtMetas, arg, &res)
+	return
+}
+
+// ArticleMetas get article metas by aids
+func (s *Service) ArticleMetas(c context.Context, arg *model.ArgAids) (res map[int64]*model.Meta, err error) {
+	err = s.client.Call(c, _artMetas, arg, &res)
+	return
+}
+
+// UpdateRecommends updates recommended articles.
+func (s *Service) UpdateRecommends(c context.Context) (err error) {
+	err = s.client.Call(c, _updateRecommends, _noArg, _noReply)
+	return
+}
+
+// Recommends list recommend articles
+func (s *Service) Recommends(c context.Context, arg *model.ArgRecommends) (res []*model.Meta, err error) {
+	err = s.client.Call(c, _recommends, arg, &res)
+	return
+}
+
+// UpArtMetas list up's article list
+func (s *Service) UpArtMetas(c context.Context, arg *model.ArgUpArts) (res *model.UpArtMetas, err error) {
+	err = s.client.Call(c, _upArtMetas, arg, &res)
+	return
+}
+
+// AddArtDraft add article draft.
+func (s *Service) AddArtDraft(c context.Context, arg *model.ArgArticle) (id int64, err error) {
+	err = s.client.Call(c, _addArtDraft, arg, &id)
+	return
+}
+
+// DelArtDraft deletes draft.
+func (s *Service) DelArtDraft(c context.Context, arg *model.ArgAidMid) (err error) {
+	err = s.client.Call(c, _delArtDraft, arg, _noReply)
+	return
+}
+
+// ArtDraft get article draft by id
+func (s *Service) ArtDraft(c context.Context, arg *model.ArgAidMid) (res *model.Draft, err error) {
+	err = s.client.Call(c, _artDraft, arg, &res)
+	return
+}
+
+// UpperDrafts get article drafts by mid
+func (s *Service) UpperDrafts(c context.Context, arg *model.ArgUpDraft) (res *model.Drafts, err error) {
+	err = s.client.Call(c, _upperDrafts, arg, &res)
+	return
+}
+
+// ArticleRemainCount returns the number that user could be use to posting new articles.
+func (s *Service) ArticleRemainCount(c context.Context, arg *model.ArgMid) (res int, err error) {
+	err = s.client.Call(c, _articleRemainCount, arg, &res)
+	return
+}
+
+// DelRecommendArtCache del recommend article cache
+func (s *Service) DelRecommendArtCache(c context.Context, arg *model.ArgAidCid) (err error) {
+	err = s.client.Boardcast(c, _delRecommendArtCache, arg, _noReply)
+	return
+}
+
+// Favorites list user's favorite articles
+func (s *Service) Favorites(c context.Context, arg *model.ArgFav) (res []*model.Favorite, err error) {
+	err = s.client.Call(c, _favorites, arg, &res)
+	return
+}
+
+// UpdateAuthorCache update author cache
+func (s *Service) UpdateAuthorCache(c context.Context, arg *model.ArgAuthor) (err error) {
+	err = s.client.Call(c, _updateAuthorCache, arg, _noReply)
+	return
+}
+
+// UpdateSortCache update sort cache
+func (s *Service) UpdateSortCache(c context.Context, arg *model.ArgSort) (err error) {
+	err = s.client.Call(c, _updateSortCache, arg, _noReply)
+	return
+}
+
+// IsAuthor checks that whether user has permission to write model.
+func (s *Service) IsAuthor(c context.Context, arg *model.ArgMid) (res bool, err error) {
+	err = s.client.Call(c, _isAuthor, arg, &res)
+	return
+}
+
+// NewArticleCount get new article count since given pubtime
+func (s *Service) NewArticleCount(c context.Context, arg *model.ArgNewArt) (res int64, err error) {
+	err = s.client.Call(c, _newArticleCount, arg, &res)
+	return
+}
+
+// HadLikesByMid check user if has liked articles
+func (s *Service) HadLikesByMid(c context.Context, arg *model.ArgMidAids) (res map[int64]int, err error) {
+	err = s.client.Call(c, _hadLikesByMid, arg, &res)
+	return
+}
+
+// UpMoreArts get upper more arts
+func (s *Service) UpMoreArts(c context.Context, arg *model.ArgAid) (res []*model.Meta, err error) {
+	err = s.client.Call(c, _upMoreArts, arg, &res)
+	return
+}
+
+// CreationUpStat creation up stat
+func (s *Service) CreationUpStat(c context.Context, arg *model.ArgMid) (res model.UpStat, err error) {
+	err = s.client.Call(c, _creationUpStat, arg, &res)
+	return
+}
+
+// CreationUpThirtyDayStat creation up thirty day stat
+func (s *Service) CreationUpThirtyDayStat(c context.Context, arg *model.ArgMid) (res []*model.ThirtyDayArticle, err error) {
+	err = s.client.Call(c, _creationUpThirtyDayStat, arg, &res)
+	return
+}
+
+// UpLists get upper article lists
+func (s *Service) UpLists(c context.Context, arg *model.ArgMid) (res model.UpLists, err error) {
+	err = s.client.Call(c, _upLists, arg, &res)
+	return
+}
+
+// RebuildAllListReadCount rebuild all list read count
+func (s *Service) RebuildAllListReadCount(c context.Context) (err error) {
+	err = s.client.Call(c, _rebuildAllRC, _noArg, _noReply)
+	return
+}
+
+// UpdateHotspots update hotspots
+func (s *Service) UpdateHotspots(c context.Context, arg *model.ArgForce) (err error) {
+	err = s.client.Call(c, _updateHotspots, arg, _noReply)
+	return
+}

app/interface/openplatform/article/rpc/client/mock.go

@@ -0,0 +1,488 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: article.go
+
+// Package client is a generated GoMock package.
+package client
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	model "go-common/app/interface/openplatform/article/model"
+	reflect "reflect"
+)
+
+// MockArticleRPC is a mock of ArticleRPC interface
+type MockArticleRPC struct {
+	ctrl     *gomock.Controller
+	recorder *MockArticleRPCMockRecorder
+}
+
+// MockArticleRPCMockRecorder is the mock recorder for MockArticleRPC
+type MockArticleRPCMockRecorder struct {
+	mock *MockArticleRPC
+}
+
+// NewMockArticleRPC creates a new mock instance
+func NewMockArticleRPC(ctrl *gomock.Controller) *MockArticleRPC {
+	mock := &MockArticleRPC{ctrl: ctrl}
+	mock.recorder = &MockArticleRPCMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockArticleRPC) EXPECT() *MockArticleRPCMockRecorder {
+	return m.recorder
+}
+
+// AddArticle mocks base method
+func (m *MockArticleRPC) AddArticle(c context.Context, arg *model.ArgArticle) (int64, error) {
+	ret := m.ctrl.Call(m, "AddArticle", c, arg)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddArticle indicates an expected call of AddArticle
+func (mr *MockArticleRPCMockRecorder) AddArticle(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddArticle", reflect.TypeOf((*MockArticleRPC)(nil).AddArticle), c, arg)
+}
+
+// AddArticleCache mocks base method
+func (m *MockArticleRPC) AddArticleCache(c context.Context, arg *model.ArgAid) error {
+	ret := m.ctrl.Call(m, "AddArticleCache", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddArticleCache indicates an expected call of AddArticleCache
+func (mr *MockArticleRPCMockRecorder) AddArticleCache(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddArticleCache", reflect.TypeOf((*MockArticleRPC)(nil).AddArticleCache), c, arg)
+}
+
+// UpdateArticleCache mocks base method
+func (m *MockArticleRPC) UpdateArticleCache(c context.Context, arg *model.ArgAidCid) error {
+	ret := m.ctrl.Call(m, "UpdateArticleCache", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateArticleCache indicates an expected call of UpdateArticleCache
+func (mr *MockArticleRPCMockRecorder) UpdateArticleCache(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArticleCache", reflect.TypeOf((*MockArticleRPC)(nil).UpdateArticleCache), c, arg)
+}
+
+// DelArticleCache mocks base method
+func (m *MockArticleRPC) DelArticleCache(c context.Context, arg *model.ArgAidMid) error {
+	ret := m.ctrl.Call(m, "DelArticleCache", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DelArticleCache indicates an expected call of DelArticleCache
+func (mr *MockArticleRPCMockRecorder) DelArticleCache(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelArticleCache", reflect.TypeOf((*MockArticleRPC)(nil).DelArticleCache), c, arg)
+}
+
+// UpdateArticle mocks base method
+func (m *MockArticleRPC) UpdateArticle(c context.Context, arg *model.ArgArticle) error {
+	ret := m.ctrl.Call(m, "UpdateArticle", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateArticle indicates an expected call of UpdateArticle
+func (mr *MockArticleRPCMockRecorder) UpdateArticle(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArticle", reflect.TypeOf((*MockArticleRPC)(nil).UpdateArticle), c, arg)
+}
+
+// CreationWithdrawArticle mocks base method
+func (m *MockArticleRPC) CreationWithdrawArticle(c context.Context, arg *model.ArgAidMid) error {
+	ret := m.ctrl.Call(m, "CreationWithdrawArticle", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreationWithdrawArticle indicates an expected call of CreationWithdrawArticle
+func (mr *MockArticleRPCMockRecorder) CreationWithdrawArticle(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationWithdrawArticle", reflect.TypeOf((*MockArticleRPC)(nil).CreationWithdrawArticle), c, arg)
+}
+
+// DelArticle mocks base method
+func (m *MockArticleRPC) DelArticle(c context.Context, arg *model.ArgAidMid) error {
+	ret := m.ctrl.Call(m, "DelArticle", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DelArticle indicates an expected call of DelArticle
+func (mr *MockArticleRPCMockRecorder) DelArticle(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelArticle", reflect.TypeOf((*MockArticleRPC)(nil).DelArticle), c, arg)
+}
+
+// CreationArticle mocks base method
+func (m *MockArticleRPC) CreationArticle(c context.Context, arg *model.ArgAidMid) (*model.Article, error) {
+	ret := m.ctrl.Call(m, "CreationArticle", c, arg)
+	ret0, _ := ret[0].(*model.Article)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreationArticle indicates an expected call of CreationArticle
+func (mr *MockArticleRPCMockRecorder) CreationArticle(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationArticle", reflect.TypeOf((*MockArticleRPC)(nil).CreationArticle), c, arg)
+}
+
+// CreationUpperArticles mocks base method
+func (m *MockArticleRPC) CreationUpperArticles(c context.Context, arg *model.ArgCreationArts) (*model.CreationArts, error) {
+	ret := m.ctrl.Call(m, "CreationUpperArticles", c, arg)
+	ret0, _ := ret[0].(*model.CreationArts)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreationUpperArticles indicates an expected call of CreationUpperArticles
+func (mr *MockArticleRPCMockRecorder) CreationUpperArticles(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationUpperArticles", reflect.TypeOf((*MockArticleRPC)(nil).CreationUpperArticles), c, arg)
+}
+
+// Categories mocks base method
+func (m *MockArticleRPC) Categories(c context.Context, arg *model.ArgIP) (*model.Categories, error) {
+	ret := m.ctrl.Call(m, "Categories", c, arg)
+	ret0, _ := ret[0].(*model.Categories)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Categories indicates an expected call of Categories
+func (mr *MockArticleRPCMockRecorder) Categories(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Categories", reflect.TypeOf((*MockArticleRPC)(nil).Categories), c, arg)
+}
+
+// CategoriesMap mocks base method
+func (m *MockArticleRPC) CategoriesMap(c context.Context, arg *model.ArgIP) (map[int64]*model.Category, error) {
+	ret := m.ctrl.Call(m, "CategoriesMap", c, arg)
+	ret0, _ := ret[0].(map[int64]*model.Category)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CategoriesMap indicates an expected call of CategoriesMap
+func (mr *MockArticleRPCMockRecorder) CategoriesMap(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CategoriesMap", reflect.TypeOf((*MockArticleRPC)(nil).CategoriesMap), c, arg)
+}
+
+// SetStat mocks base method
+func (m *MockArticleRPC) SetStat(c context.Context, arg *model.ArgStats) error {
+	ret := m.ctrl.Call(m, "SetStat", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SetStat indicates an expected call of SetStat
+func (mr *MockArticleRPCMockRecorder) SetStat(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStat", reflect.TypeOf((*MockArticleRPC)(nil).SetStat), c, arg)
+}
+
+// UpsArtMetas mocks base method
+func (m *MockArticleRPC) UpsArtMetas(c context.Context, arg *model.ArgUpsArts) (map[int64][]*model.Meta, error) {
+	ret := m.ctrl.Call(m, "UpsArtMetas", c, arg)
+	ret0, _ := ret[0].(map[int64][]*model.Meta)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpsArtMetas indicates an expected call of UpsArtMetas
+func (mr *MockArticleRPCMockRecorder) UpsArtMetas(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsArtMetas", reflect.TypeOf((*MockArticleRPC)(nil).UpsArtMetas), c, arg)
+}
+
+// ArticleMetas mocks base method
+func (m *MockArticleRPC) ArticleMetas(c context.Context, arg *model.ArgAids) (map[int64]*model.Meta, error) {
+	ret := m.ctrl.Call(m, "ArticleMetas", c, arg)
+	ret0, _ := ret[0].(map[int64]*model.Meta)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ArticleMetas indicates an expected call of ArticleMetas
+func (mr *MockArticleRPCMockRecorder) ArticleMetas(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArticleMetas", reflect.TypeOf((*MockArticleRPC)(nil).ArticleMetas), c, arg)
+}
+
+// UpdateRecommends mocks base method
+func (m *MockArticleRPC) UpdateRecommends(c context.Context) error {
+	ret := m.ctrl.Call(m, "UpdateRecommends", c)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateRecommends indicates an expected call of UpdateRecommends
+func (mr *MockArticleRPCMockRecorder) UpdateRecommends(c interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRecommends", reflect.TypeOf((*MockArticleRPC)(nil).UpdateRecommends), c)
+}
+
+// Recommends mocks base method
+func (m *MockArticleRPC) Recommends(c context.Context, arg *model.ArgRecommends) ([]*model.Meta, error) {
+	ret := m.ctrl.Call(m, "Recommends", c, arg)
+	ret0, _ := ret[0].([]*model.Meta)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Recommends indicates an expected call of Recommends
+func (mr *MockArticleRPCMockRecorder) Recommends(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recommends", reflect.TypeOf((*MockArticleRPC)(nil).Recommends), c, arg)
+}
+
+// UpArtMetas mocks base method
+func (m *MockArticleRPC) UpArtMetas(c context.Context, arg *model.ArgUpArts) (*model.UpArtMetas, error) {
+	ret := m.ctrl.Call(m, "UpArtMetas", c, arg)
+	ret0, _ := ret[0].(*model.UpArtMetas)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpArtMetas indicates an expected call of UpArtMetas
+func (mr *MockArticleRPCMockRecorder) UpArtMetas(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpArtMetas", reflect.TypeOf((*MockArticleRPC)(nil).UpArtMetas), c, arg)
+}
+
+// AddArtDraft mocks base method
+func (m *MockArticleRPC) AddArtDraft(c context.Context, arg *model.ArgArticle) (int64, error) {
+	ret := m.ctrl.Call(m, "AddArtDraft", c, arg)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddArtDraft indicates an expected call of AddArtDraft
+func (mr *MockArticleRPCMockRecorder) AddArtDraft(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddArtDraft", reflect.TypeOf((*MockArticleRPC)(nil).AddArtDraft), c, arg)
+}
+
+// UpdateArtDraft mocks base method
+func (m *MockArticleRPC) UpdateArtDraft(c context.Context, arg *model.ArgAidMid) error {
+	ret := m.ctrl.Call(m, "UpdateArtDraft", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateArtDraft indicates an expected call of UpdateArtDraft
+func (mr *MockArticleRPCMockRecorder) UpdateArtDraft(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateArtDraft", reflect.TypeOf((*MockArticleRPC)(nil).UpdateArtDraft), c, arg)
+}
+
+// DelArtDraft mocks base method
+func (m *MockArticleRPC) DelArtDraft(c context.Context, arg *model.ArgAidMid) error {
+	ret := m.ctrl.Call(m, "DelArtDraft", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DelArtDraft indicates an expected call of DelArtDraft
+func (mr *MockArticleRPCMockRecorder) DelArtDraft(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelArtDraft", reflect.TypeOf((*MockArticleRPC)(nil).DelArtDraft), c, arg)
+}
+
+// ArtDraft mocks base method
+func (m *MockArticleRPC) ArtDraft(c context.Context, arg *model.ArgAidMid) (*model.Draft, error) {
+	ret := m.ctrl.Call(m, "ArtDraft", c, arg)
+	ret0, _ := ret[0].(*model.Draft)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ArtDraft indicates an expected call of ArtDraft
+func (mr *MockArticleRPCMockRecorder) ArtDraft(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArtDraft", reflect.TypeOf((*MockArticleRPC)(nil).ArtDraft), c, arg)
+}
+
+// UpperDrafts mocks base method
+func (m *MockArticleRPC) UpperDrafts(c context.Context, arg *model.ArgUpDraft) (*model.Drafts, error) {
+	ret := m.ctrl.Call(m, "UpperDrafts", c, arg)
+	ret0, _ := ret[0].(*model.Drafts)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpperDrafts indicates an expected call of UpperDrafts
+func (mr *MockArticleRPCMockRecorder) UpperDrafts(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpperDrafts", reflect.TypeOf((*MockArticleRPC)(nil).UpperDrafts), c, arg)
+}
+
+// UpdateNewArts mocks base method
+func (m *MockArticleRPC) UpdateNewArts(c context.Context, arg *model.ArgIP) error {
+	ret := m.ctrl.Call(m, "UpdateNewArts", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateNewArts indicates an expected call of UpdateNewArts
+func (mr *MockArticleRPCMockRecorder) UpdateNewArts(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNewArts", reflect.TypeOf((*MockArticleRPC)(nil).UpdateNewArts), c, arg)
+}
+
+// ArticleRemainCount mocks base method
+func (m *MockArticleRPC) ArticleRemainCount(c context.Context, arg *model.ArgMid) (int, error) {
+	ret := m.ctrl.Call(m, "ArticleRemainCount", c, arg)
+	ret0, _ := ret[0].(int)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ArticleRemainCount indicates an expected call of ArticleRemainCount
+func (mr *MockArticleRPCMockRecorder) ArticleRemainCount(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArticleRemainCount", reflect.TypeOf((*MockArticleRPC)(nil).ArticleRemainCount), c, arg)
+}
+
+// DelRecommendArtCache mocks base method
+func (m *MockArticleRPC) DelRecommendArtCache(c context.Context, arg *model.ArgAidCid) error {
+	ret := m.ctrl.Call(m, "DelRecommendArtCache", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DelRecommendArtCache indicates an expected call of DelRecommendArtCache
+func (mr *MockArticleRPCMockRecorder) DelRecommendArtCache(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelRecommendArtCache", reflect.TypeOf((*MockArticleRPC)(nil).DelRecommendArtCache), c, arg)
+}
+
+// CheckPrivilege mocks base method
+func (m *MockArticleRPC) CheckPrivilege(c context.Context, arg *model.ArgMid) error {
+	ret := m.ctrl.Call(m, "CheckPrivilege", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CheckPrivilege indicates an expected call of CheckPrivilege
+func (mr *MockArticleRPCMockRecorder) CheckPrivilege(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckPrivilege", reflect.TypeOf((*MockArticleRPC)(nil).CheckPrivilege), c, arg)
+}
+
+// Favorites mocks base method
+func (m *MockArticleRPC) Favorites(c context.Context, arg *model.ArgFav) ([]*model.Favorite, error) {
+	ret := m.ctrl.Call(m, "Favorites", c, arg)
+	ret0, _ := ret[0].([]*model.Favorite)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Favorites indicates an expected call of Favorites
+func (mr *MockArticleRPCMockRecorder) Favorites(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Favorites", reflect.TypeOf((*MockArticleRPC)(nil).Favorites), c, arg)
+}
+
+// UpdateAuthorCache mocks base method
+func (m *MockArticleRPC) UpdateAuthorCache(c context.Context, arg *model.ArgAuthor) error {
+	ret := m.ctrl.Call(m, "UpdateAuthorCache", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateAuthorCache indicates an expected call of UpdateAuthorCache
+func (mr *MockArticleRPCMockRecorder) UpdateAuthorCache(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthorCache", reflect.TypeOf((*MockArticleRPC)(nil).UpdateAuthorCache), c, arg)
+}
+
+// UpdateSortCache mocks base method
+func (m *MockArticleRPC) UpdateSortCache(c context.Context, arg *model.ArgSort) error {
+	ret := m.ctrl.Call(m, "UpdateSortCache", c, arg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateSortCache indicates an expected call of UpdateSortCache
+func (mr *MockArticleRPCMockRecorder) UpdateSortCache(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSortCache", reflect.TypeOf((*MockArticleRPC)(nil).UpdateSortCache), c, arg)
+}
+
+// IsAuthor mocks base method
+func (m *MockArticleRPC) IsAuthor(c context.Context, arg *model.ArgMid) (bool, error) {
+	ret := m.ctrl.Call(m, "IsAuthor", c, arg)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// IsAuthor indicates an expected call of IsAuthor
+func (mr *MockArticleRPCMockRecorder) IsAuthor(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAuthor", reflect.TypeOf((*MockArticleRPC)(nil).IsAuthor), c, arg)
+}
+
+// NewArticleCount mocks base method
+func (m *MockArticleRPC) NewArticleCount(c context.Context, arg *model.ArgNewArt) (int64, error) {
+	ret := m.ctrl.Call(m, "NewArticleCount", c, arg)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NewArticleCount indicates an expected call of NewArticleCount
+func (mr *MockArticleRPCMockRecorder) NewArticleCount(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewArticleCount", reflect.TypeOf((*MockArticleRPC)(nil).NewArticleCount), c, arg)
+}
+
+// HadLikesByMid mocks base method
+func (m *MockArticleRPC) HadLikesByMid(c context.Context, arg *model.ArgMidAids) (map[int64]int, error) {
+	ret := m.ctrl.Call(m, "HadLikesByMid", c, arg)
+	ret0, _ := ret[0].(map[int64]int)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HadLikesByMid indicates an expected call of HadLikesByMid
+func (mr *MockArticleRPCMockRecorder) HadLikesByMid(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HadLikesByMid", reflect.TypeOf((*MockArticleRPC)(nil).HadLikesByMid), c, arg)
+}
+
+// UpMoreArts mocks base method
+func (m *MockArticleRPC) UpMoreArts(c context.Context, arg *model.ArgAid) ([]*model.Meta, error) {
+	ret := m.ctrl.Call(m, "UpMoreArts", c, arg)
+	ret0, _ := ret[0].([]*model.Meta)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpMoreArts indicates an expected call of UpMoreArts
+func (mr *MockArticleRPCMockRecorder) UpMoreArts(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpMoreArts", reflect.TypeOf((*MockArticleRPC)(nil).UpMoreArts), c, arg)
+}
+
+// CreationUpStat mocks base method
+func (m *MockArticleRPC) CreationUpStat(c context.Context, arg *model.ArgMid) (model.UpStat, error) {
+	ret := m.ctrl.Call(m, "CreationUpStat", c, arg)
+	ret0, _ := ret[0].(model.UpStat)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreationUpStat indicates an expected call of CreationUpStat
+func (mr *MockArticleRPCMockRecorder) CreationUpStat(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationUpStat", reflect.TypeOf((*MockArticleRPC)(nil).CreationUpStat), c, arg)
+}
+
+// CreationUpThirtyDayStat mocks base method
+func (m *MockArticleRPC) CreationUpThirtyDayStat(c context.Context, arg *model.ArgMid) ([]*model.ThirtyDayArticle, error) {
+	ret := m.ctrl.Call(m, "CreationUpThirtyDayStat", c, arg)
+	ret0, _ := ret[0].([]*model.ThirtyDayArticle)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreationUpThirtyDayStat indicates an expected call of CreationUpThirtyDayStat
+func (mr *MockArticleRPCMockRecorder) CreationUpThirtyDayStat(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreationUpThirtyDayStat", reflect.TypeOf((*MockArticleRPC)(nil).CreationUpThirtyDayStat), c, arg)
+}
+
+// UpLists mocks base method
+func (m *MockArticleRPC) UpLists(c context.Context, arg *model.ArgMid) (model.UpLists, error) {
+	ret := m.ctrl.Call(m, "UpLists", c, arg)
+	ret0, _ := ret[0].(model.UpLists)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpLists indicates an expected call of UpLists
+func (mr *MockArticleRPCMockRecorder) UpLists(c, arg interface{}) *gomock.Call {
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpLists", reflect.TypeOf((*MockArticleRPC)(nil).UpLists), c, arg)
+}

app/interface/openplatform/article/rpc/server/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["rpc_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/interface/openplatform/article/rpc/client:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["rpc.go"],
+    importpath = "go-common/app/interface/openplatform/article/rpc/server",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/openplatform/article/model:go_default_library",
+        "//app/interface/openplatform/article/service:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/net/rpc:go_default_library",
+        "//library/net/rpc/context: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/interface/openplatform/article/rpc/server/rpc.go

@@ -0,0 +1,289 @@
+package server
+
+import (
+	"go-common/app/interface/openplatform/article/model"
+	"go-common/app/interface/openplatform/article/service"
+	"go-common/library/ecode"
+	"go-common/library/net/rpc"
+	"go-common/library/net/rpc/context"
+)
+
+// RPC .
+type RPC struct {
+	s *service.Service
+}
+
+// New creates rpc server.
+func New(s *service.Service) (svr *rpc.Server) {
+	r := &RPC{s: s}
+	svr = rpc.NewServer(nil)
+	if err := svr.Register(r); err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Ping checks connection success.
+func (r *RPC) Ping(c context.Context, arg *struct{}, res *struct{}) (err error) {
+	return
+}
+
+// Auth check connection success.
+func (r *RPC) Auth(c context.Context, arg *rpc.Auth, res *struct{}) (err error) {
+	return
+}
+
+// AddArticle adds article when article passed. purge cache.
+func (r *RPC) AddArticle(c context.Context, arg *model.ArgArticle, res *int64) (err error) {
+	var (
+		aid int64
+		a   = model.TransformArticle(arg)
+	)
+	if aid, err = r.s.AddArticle(c, a, arg.ActivityID, arg.ListID, arg.RealIP); err != nil {
+		return
+	}
+	*res = aid
+	return
+}
+
+// UpdateArticle updates article when article passed. purge cache.
+func (r *RPC) UpdateArticle(c context.Context, arg *model.ArgArticle, res *struct{}) (err error) {
+	var a = model.TransformArticle(arg)
+	if err = r.s.UpdateArticle(c, a, arg.ActivityID, arg.ListID, arg.RealIP); err != nil {
+		return
+	}
+	return
+}
+
+// CreationArticle gets article info.
+func (r *RPC) CreationArticle(c context.Context, arg *model.ArgAidMid, res *model.Article) (err error) {
+	var rr *model.Article
+	if rr, err = r.s.CreationArticle(c, arg.Aid, arg.Mid); err == nil {
+		*res = *rr
+	}
+	return
+}
+
+// DelArticle drops article when article not passed. purge cache.
+func (r *RPC) DelArticle(c context.Context, arg *model.ArgAidMid, res *struct{}) error {
+	return r.s.DelArticle(c, arg.Aid, arg.Mid)
+}
+
+// AddArticleCache adds article cache.
+func (r *RPC) AddArticleCache(c context.Context, arg *model.ArgAid, res *struct{}) (err error) {
+	err = r.s.AddArticleCache(c, arg.Aid)
+	return
+}
+
+// UpdateArticleCache adds article cache.
+func (r *RPC) UpdateArticleCache(c context.Context, arg *model.ArgAidCid, res *struct{}) (err error) {
+	err = r.s.UpdateArticleCache(c, arg.Aid, arg.Cid)
+	return
+}
+
+// DelArticleCache adds article cache.
+func (r *RPC) DelArticleCache(c context.Context, arg *model.ArgAidMid, res *struct{}) (err error) {
+	err = r.s.DelArticleCache(c, arg.Mid, arg.Aid)
+	return
+}
+
+// CreationWithdrawArticle author withdraw model.
+func (r *RPC) CreationWithdrawArticle(c context.Context, arg *model.ArgAidMid, res *struct{}) (err error) {
+	err = r.s.CreationWithdrawArticle(c, arg.Mid, arg.Aid)
+	return
+}
+
+// Categories list article categories
+func (r *RPC) Categories(c context.Context, arg *model.ArgIP, res *model.Categories) (err error) {
+	*res, err = r.s.ListCategories(c, arg.RealIP)
+	return
+}
+
+// CategoriesMap list article categories map
+func (r *RPC) CategoriesMap(c context.Context, arg *model.ArgIP, res *map[int64]*model.Category) (err error) {
+	*res, err = r.s.ListCategoriesMap(c, arg.RealIP)
+	return
+}
+
+// CreationUpperArticles gets upper's article list for creation center.
+func (r *RPC) CreationUpperArticles(c context.Context, arg *model.ArgCreationArts, res *model.CreationArts) (err error) {
+	var rr *model.CreationArts
+	if rr, err = r.s.CreationUpperArticlesMeta(c, arg.Mid, arg.Group, arg.Category, arg.Sort, arg.Pn, arg.Ps, arg.RealIP); err == nil {
+		*res = *rr
+	}
+	return
+}
+
+// SetStat set all stat cache(redis)
+func (r *RPC) SetStat(c context.Context, arg *model.ArgStats, res *struct{}) (err error) {
+	err = r.s.SetStat(c, arg.Aid, arg.Stats)
+	return
+}
+
+// UpsArtMetas list passed article meta of ups
+func (r *RPC) UpsArtMetas(c context.Context, arg *model.ArgUpsArts, res *map[int64][]*model.Meta) (err error) {
+	if arg.Pn < 1 {
+		arg.Pn = 1
+	}
+	var (
+		start = (arg.Pn - 1) * arg.Ps
+		end   = start + arg.Ps - 1
+	)
+	*res, err = r.s.UpsArticleMetas(c, arg.Mids, start, end)
+	return
+}
+
+// UpArtMetas list up article metas
+func (r *RPC) UpArtMetas(c context.Context, arg *model.ArgUpArts, res *model.UpArtMetas) (err error) {
+	if arg.Pn < 1 {
+		arg.Pn = 1
+	}
+	if arg.Ps <= 0 {
+		err = ecode.RequestErr
+		return
+	}
+	var rr *model.UpArtMetas
+	if rr, err = r.s.UpArticleMetas(c, arg.Mid, arg.Pn, arg.Ps, arg.Sort); err == nil {
+		*res = *rr
+	}
+	return
+}
+
+// ArticleMetas list article metas
+func (r *RPC) ArticleMetas(c context.Context, arg *model.ArgAids, res *map[int64]*model.Meta) (err error) {
+	*res, err = r.s.ArticleMetas(c, arg.Aids)
+	return
+}
+
+// UpdateRecommends refresh recommend data.
+func (r *RPC) UpdateRecommends(c context.Context, arg *model.ArgIP, res *struct{}) (err error) {
+	err = r.s.UpdateRecommends(c)
+	return
+}
+
+// Recommends list recommend articles
+func (r *RPC) Recommends(c context.Context, arg *model.ArgRecommends, res *[]*model.Meta) (err error) {
+	rs, err := r.s.Recommends(c, arg.Cid, arg.Pn, arg.Ps, arg.Aids, arg.Sort)
+	if err != nil {
+		return
+	}
+	for _, r := range rs {
+		*res = append(*res, &r.Meta)
+	}
+	return
+}
+
+// AddArtDraft adds or updates draft.
+func (r *RPC) AddArtDraft(c context.Context, arg *model.ArgArticle, res *int64) (err error) {
+	d := model.TransformDraft(arg)
+	*res, err = r.s.AddArtDraft(c, d)
+	return
+}
+
+// DelArtDraft .
+func (r *RPC) DelArtDraft(c context.Context, arg *model.ArgAidMid, res *struct{}) (err error) {
+	err = r.s.DelArtDraft(c, arg.Aid, arg.Mid)
+	return
+}
+
+// ArtDraft get article draft
+func (r *RPC) ArtDraft(c context.Context, arg *model.ArgAidMid, res *model.Draft) (err error) {
+	var v *model.Draft
+	if v, err = r.s.ArtDraft(c, arg.Aid, arg.Mid); err == nil && v != nil {
+		*res = *v
+	}
+	return
+}
+
+// UpperDrafts get article drafts by mid
+func (r *RPC) UpperDrafts(c context.Context, arg *model.ArgUpDraft, res *model.Drafts) (err error) {
+	var v *model.Drafts
+	if v, err = r.s.UpperDrafts(c, arg.Mid, arg.Pn, arg.Ps); err == nil && v != nil {
+		*res = *v
+	}
+	return
+}
+
+// ArticleRemainCount returns the number that user could be use to posting new articles.
+func (r *RPC) ArticleRemainCount(c context.Context, arg *model.ArgMid, res *int) (err error) {
+	*res, err = r.s.ArticleRemainCount(c, arg.Mid)
+	return
+}
+
+// DelRecommendArtCache del recommend article cache
+func (r *RPC) DelRecommendArtCache(c context.Context, arg *model.ArgAidCid, res *struct{}) (err error) {
+	err = r.s.DelRecommendArtCache(c, arg.Aid, arg.Cid)
+	return
+}
+
+// Favorites list user's favorite articles
+func (r *RPC) Favorites(c context.Context, arg *model.ArgFav, res *[]*model.Favorite) (err error) {
+	*res, _, err = r.s.ValidFavs(c, arg.Mid, 0, arg.Pn, arg.Ps, arg.RealIP)
+	return
+}
+
+// UpdateAuthorCache update author cache
+func (r *RPC) UpdateAuthorCache(c context.Context, arg *model.ArgAuthor, res *struct{}) (err error) {
+	err = r.s.UpdateAuthorCache(c, arg.Mid)
+	return
+}
+
+// UpdateSortCache update sort cache
+func (r *RPC) UpdateSortCache(c context.Context, arg *model.ArgSort, res *struct{}) (err error) {
+	err = r.s.UpdateSortCache(c, arg.Aid, arg.Changed, arg.RealIP)
+	return
+}
+
+// IsAuthor checks that whether user has permission to write model.
+func (r *RPC) IsAuthor(c context.Context, arg *model.ArgMid, res *bool) (err error) {
+	*res, _, err = r.s.IsAuthor(c, arg.Mid)
+	return
+}
+
+// NewArticleCount get new article count since given pubtime
+func (r *RPC) NewArticleCount(c context.Context, arg *model.ArgNewArt, res *int64) (err error) {
+	*res, err = r.s.NewArticleCount(c, arg.PubTime)
+	return
+}
+
+// HadLikesByMid check user if has liked articles
+func (r *RPC) HadLikesByMid(c context.Context, arg *model.ArgMidAids, res *map[int64]int8) (err error) {
+	*res, err = r.s.HadLikesByMid(c, arg.Mid, arg.Aids)
+	return
+}
+
+// UpMoreArts get upper more arts
+func (r *RPC) UpMoreArts(c context.Context, arg *model.ArgAid, res *[]*model.Meta) (err error) {
+	*res, err = r.s.MoreArts(c, arg.Aid)
+	return
+}
+
+// CreationUpStat creation up stat
+func (r *RPC) CreationUpStat(c context.Context, arg *model.ArgMid, res *model.UpStat) (err error) {
+	*res, err = r.s.UpStat(c, arg.Mid)
+	return
+}
+
+// CreationUpThirtyDayStat creation up thirty day stat
+func (r *RPC) CreationUpThirtyDayStat(c context.Context, arg *model.ArgMid, res *[]*model.ThirtyDayArticle) (err error) {
+	*res, err = r.s.UpThirtyDayStat(c, arg.Mid)
+	return
+}
+
+// UpLists get upper article lists
+func (r *RPC) UpLists(c context.Context, arg *model.ArgMid, res *model.UpLists) (err error) {
+	*res, err = r.s.UpLists(c, arg.Mid, model.ListSortPtime)
+	return
+}
+
+// RebuildAllListReadCount rebuild all list read count
+func (r *RPC) RebuildAllListReadCount(c context.Context, arg *struct{}, res *struct{}) (err error) {
+	r.s.RebuildAllListReadCount(c)
+	return
+}
+
+// UpdateHotspots update hotspots
+func (r *RPC) UpdateHotspots(c context.Context, arg *model.ArgForce, res *struct{}) (err error) {
+	err = r.s.UpdateHotspots(arg.Force)
+	return
+}

app/interface/openplatform/article/rpc/server/rpc_test.go

@@ -0,0 +1,31 @@
+package server
+
+import (
+	"context"
+	"testing"
+
+	artmdl "go-common/app/interface/openplatform/article/model"
+	artsrv "go-common/app/interface/openplatform/article/rpc/client"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	ctx = context.TODO()
+)
+
+func WithRPC(f func(client *artsrv.Service)) func() {
+	return func() {
+		client := artsrv.New(nil)
+		f(client)
+	}
+}
+
+func Test_ArticleRemainCount(t *testing.T) {
+	Convey("ArticleRemainCount", t, WithRPC(func(client *artsrv.Service) {
+		arg := &artmdl.ArgMid{Mid: 27515310}
+		res, err := client.ArticleRemainCount(ctx, arg)
+		So(err, ShouldBeNil)
+		t.Logf("count: %d", res)
+	}))
+}