gomock: init

http/handler/default.go

@@ -1,10 +1,6 @@
 package handler
 
 import (
-	"compress/gzip"
-	"fmt"
-	"io/ioutil"
-	"kpt-tmr-group/pkg/xerr"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -17,23 +13,3 @@ func Health(c *gin.Context) {
 func Handle404(c *gin.Context) {
 	c.String(http.StatusNotFound, "404 NotFound")
 }
-
-func dumpPerfEventBody(c *gin.Context) ([]byte, error) {
-	if c.ContentType() != "application/octet-stream" {
-		return nil, fmt.Errorf("invalid Content-Type:  %s ", c.ContentType())
-	}
-	if c.GetHeader("Content-Encoding") != "gzip" {
-		return nil, fmt.Errorf("invalid Content-Encoding:  %s ", c.GetHeader("Content-Encoding"))
-	}
-	if c.Request.Body == nil || int(c.Request.ContentLength) < 1 {
-		return nil, fmt.Errorf("invalid body:  %v ", int(c.Request.ContentLength))
-	}
-
-	reader, err := gzip.NewReader(c.Request.Body)
-	if err != nil {
-		return nil, xerr.WithStack(err)
-	}
-	defer reader.Close()
-
-	return ioutil.ReadAll(reader)
-}

http/handler/feed/feed_formula.go

@@ -260,6 +260,7 @@ func MixedFeedFormula(c *gin.Context) {
 	}
 
 	if err := valid.ValidateStruct(&req,
+		valid.Field(&req.FeedFormulaId, valid.Required),
 		valid.Field(&req.Name, valid.Required),
 		valid.Field(&req.Colour, valid.Required),
 		valid.Field(&req.CattleCategoryId, valid.Required),

module/backend/feed_service.go

@@ -382,7 +382,7 @@ func (s *StoreEntry) MixedFeedFormula(ctx context.Context, req *operationPb.Mixe
 	}
 
 	tr := s.DB.Transaction(func(tx *gorm.DB) error {
-		feedFormulaData := &model.FeedFormula{
+		newFeedFormulaData := &model.FeedFormula{
 			Name:               req.Name,
 			Colour:             req.Colour,
 			EncodeNumber:       s.EncodeNumber(ctx),
@@ -398,14 +398,14 @@ func (s *StoreEntry) MixedFeedFormula(ctx context.Context, req *operationPb.Mixe
 			IsModify:           operationPb.IsShow_OK,
 			IsDelete:           operationPb.IsShow_OK,
 		}
-		if err := s.DB.Model(new(model.FeedFormula)).Create(feedFormulaData).Error; err != nil {
+		if err := s.DB.Model(new(model.FeedFormula)).Create(newFeedFormulaData).Error; err != nil {
 			return xerr.WithStack(err)
 		}
 		feedFormulaDetailList := make([]*model.FeedFormulaDetail, 0)
 		for _, v := range req.FeedList {
 			feedFormulaDetailList = append(feedFormulaDetailList, &model.FeedFormulaDetail{
 				PastureName:     "集团",
-				FeedFormulaId:   feedFormulaData.Id,
+				FeedFormulaId:   newFeedFormulaData.Id,
 				ForageId:        int64(v.ForageId),
 				ForageName:      v.ForageName,
 				ForageGroupName: v.ForageGroupName,

module/backend/interface.go

@@ -50,6 +50,7 @@ type KptService interface {
 	PastureSyncService // 牧场端数据同步
 }
 
+//go:generate mockgen -destination mock/PastureService.go -package kptservicemock kpt-tmr-group/module/backend PastureService
 type PastureService interface {
 	// CreateGroupPasture 牧场管理相关
 	CreateGroupPasture(ctx context.Context, req *operationPb.AddPastureRequest) error
@@ -110,6 +111,7 @@ type PastureService interface {
 	FeedFormulaUsage(ctx context.Context, req *operationPb.FeedFormulaUsageRequest) (*operationPb.FeedFormulaUsageResponse, error)
 }
 
+//go:generate mockgen -destination mock/SystemService.go -package kptservicemock kpt-tmr-group/module/backend SystemService
 type SystemService interface {
 	// Auth 系统用户相关
 	Auth(ctx context.Context, auth *operationPb.UserAuthData) (*operationPb.SystemToken, error)
@@ -142,6 +144,7 @@ type SystemService interface {
 	SearchMobileList(ctx context.Context, req *operationPb.SearchMobileRequest) (*operationPb.SearchMobileResponse, error)
 }
 
+//go:generate mockgen -destination mock/StatisticService.go -package kptservicemock kpt-tmr-group/module/backend StatisticService
 type StatisticService interface {
 	SearchFormulaEstimateList(ctx context.Context, req *operationPb.SearchFormulaEstimateRequest) (*model.PastureCommonResponse, error)
 	SearchInventoryStatistics(ctx context.Context, req *operationPb.SearchInventoryStatisticsRequest) (*model.PastureCommonResponse, error)
@@ -169,10 +172,12 @@ type StatisticService interface {
 	FeedMixedAndTmrName(ctx context.Context, req *operationPb.MixedCategoryTmrName) (*model.PastureCommonResponse, error)
 }
 
+//go:generate mockgen -destination mock/WxAppletService.go -package kptservicemock kpt-tmr-group/module/backend WxAppletService
 type WxAppletService interface {
 	GetOpenId(ctx context.Context, jsCode string) (*operationPb.WxOpenId, error)
 }
 
+//go:generate mockgen -destination mock/PastureSyncService.go -package kptservicemock kpt-tmr-group/module/backend PastureSyncService
 type PastureSyncService interface {
 	CategorySyncData(ctx context.Context, req *operationPb.CategorySyncRequest) error
 	CategoryDeleteData(ctx context.Context, req *operationPb.CategoryDeleteRequest) error

module/backend/mock/PastureService.go

@@ -0,0 +1,725 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-tmr-group/module/backend (interfaces: PastureService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	bytes "bytes"
+	context "context"
+	io "io"
+	model "kpt-tmr-group/model"
+	operationPb "kpt-tmr-group/proto/go/backend/operation"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockPastureService is a mock of PastureService interface.
+type MockPastureService struct {
+	ctrl     *gomock.Controller
+	recorder *MockPastureServiceMockRecorder
+}
+
+// MockPastureServiceMockRecorder is the mock recorder for MockPastureService.
+type MockPastureServiceMockRecorder struct {
+	mock *MockPastureService
+}
+
+// NewMockPastureService creates a new mock instance.
+func NewMockPastureService(ctrl *gomock.Controller) *MockPastureService {
+	mock := &MockPastureService{ctrl: ctrl}
+	mock.recorder = &MockPastureServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPastureService) EXPECT() *MockPastureServiceMockRecorder {
+	return m.recorder
+}
+
+// AddCattleCategory mocks base method.
+func (m *MockPastureService) AddCattleCategory(arg0 context.Context, arg1 *operationPb.AddCattleCategoryRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddCattleCategory", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddCattleCategory indicates an expected call of AddCattleCategory.
+func (mr *MockPastureServiceMockRecorder) AddCattleCategory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCattleCategory", reflect.TypeOf((*MockPastureService)(nil).AddCattleCategory), arg0, arg1)
+}
+
+// AddFeedByFeedFormula mocks base method.
+func (m *MockPastureService) AddFeedByFeedFormula(arg0 context.Context, arg1 *operationPb.GroupAddFeedFormulaDetail) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddFeedByFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddFeedByFeedFormula indicates an expected call of AddFeedByFeedFormula.
+func (mr *MockPastureServiceMockRecorder) AddFeedByFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFeedByFeedFormula", reflect.TypeOf((*MockPastureService)(nil).AddFeedByFeedFormula), arg0, arg1)
+}
+
+// AddForageCategory mocks base method.
+func (m *MockPastureService) AddForageCategory(arg0 context.Context, arg1 *operationPb.AddForageCategoryRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddForageCategory", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddForageCategory indicates an expected call of AddForageCategory.
+func (mr *MockPastureServiceMockRecorder) AddForageCategory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddForageCategory", reflect.TypeOf((*MockPastureService)(nil).AddForageCategory), arg0, arg1)
+}
+
+// CancelDistributeFeedFormula mocks base method.
+func (m *MockPastureService) CancelDistributeFeedFormula(arg0 context.Context, arg1 *operationPb.DistributeFeedFormulaRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CancelDistributeFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CancelDistributeFeedFormula indicates an expected call of CancelDistributeFeedFormula.
+func (mr *MockPastureServiceMockRecorder) CancelDistributeFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelDistributeFeedFormula", reflect.TypeOf((*MockPastureService)(nil).CancelDistributeFeedFormula), arg0, arg1)
+}
+
+// CreateFeedFormula mocks base method.
+func (m *MockPastureService) CreateFeedFormula(arg0 context.Context, arg1 *operationPb.AddFeedFormulaRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateFeedFormula indicates an expected call of CreateFeedFormula.
+func (mr *MockPastureServiceMockRecorder) CreateFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFeedFormula", reflect.TypeOf((*MockPastureService)(nil).CreateFeedFormula), arg0, arg1)
+}
+
+// CreateForage mocks base method.
+func (m *MockPastureService) CreateForage(arg0 context.Context, arg1 *operationPb.AddForageRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateForage", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateForage indicates an expected call of CreateForage.
+func (mr *MockPastureServiceMockRecorder) CreateForage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateForage", reflect.TypeOf((*MockPastureService)(nil).CreateForage), arg0, arg1)
+}
+
+// CreateGroupPasture mocks base method.
+func (m *MockPastureService) CreateGroupPasture(arg0 context.Context, arg1 *operationPb.AddPastureRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateGroupPasture", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateGroupPasture indicates an expected call of CreateGroupPasture.
+func (mr *MockPastureServiceMockRecorder) CreateGroupPasture(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroupPasture", reflect.TypeOf((*MockPastureService)(nil).CreateGroupPasture), arg0, arg1)
+}
+
+// DeleteCattleCategory mocks base method.
+func (m *MockPastureService) DeleteCattleCategory(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteCattleCategory", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteCattleCategory indicates an expected call of DeleteCattleCategory.
+func (mr *MockPastureServiceMockRecorder) DeleteCattleCategory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCattleCategory", reflect.TypeOf((*MockPastureService)(nil).DeleteCattleCategory), arg0, arg1)
+}
+
+// DeleteFeedFormula mocks base method.
+func (m *MockPastureService) DeleteFeedFormula(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteFeedFormula indicates an expected call of DeleteFeedFormula.
+func (mr *MockPastureServiceMockRecorder) DeleteFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFeedFormula", reflect.TypeOf((*MockPastureService)(nil).DeleteFeedFormula), arg0, arg1)
+}
+
+// DeleteFeedFormulaDetail mocks base method.
+func (m *MockPastureService) DeleteFeedFormulaDetail(arg0 context.Context, arg1 *operationPb.GroupAddFeedFormulaDetail) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteFeedFormulaDetail", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteFeedFormulaDetail indicates an expected call of DeleteFeedFormulaDetail.
+func (mr *MockPastureServiceMockRecorder) DeleteFeedFormulaDetail(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFeedFormulaDetail", reflect.TypeOf((*MockPastureService)(nil).DeleteFeedFormulaDetail), arg0, arg1)
+}
+
+// DeleteForageCategory mocks base method.
+func (m *MockPastureService) DeleteForageCategory(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteForageCategory", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteForageCategory indicates an expected call of DeleteForageCategory.
+func (mr *MockPastureServiceMockRecorder) DeleteForageCategory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteForageCategory", reflect.TypeOf((*MockPastureService)(nil).DeleteForageCategory), arg0, arg1)
+}
+
+// DeleteForageList mocks base method.
+func (m *MockPastureService) DeleteForageList(arg0 context.Context, arg1 []int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteForageList", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteForageList indicates an expected call of DeleteForageList.
+func (mr *MockPastureServiceMockRecorder) DeleteForageList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteForageList", reflect.TypeOf((*MockPastureService)(nil).DeleteForageList), arg0, arg1)
+}
+
+// DeleteGroupPasture mocks base method.
+func (m *MockPastureService) DeleteGroupPasture(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteGroupPasture", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteGroupPasture indicates an expected call of DeleteGroupPasture.
+func (mr *MockPastureServiceMockRecorder) DeleteGroupPasture(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupPasture", reflect.TypeOf((*MockPastureService)(nil).DeleteGroupPasture), arg0, arg1)
+}
+
+// DistributeFeedFormula mocks base method.
+func (m *MockPastureService) DistributeFeedFormula(arg0 context.Context, arg1 *operationPb.DistributeFeedFormulaRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DistributeFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DistributeFeedFormula indicates an expected call of DistributeFeedFormula.
+func (mr *MockPastureServiceMockRecorder) DistributeFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DistributeFeedFormula", reflect.TypeOf((*MockPastureService)(nil).DistributeFeedFormula), arg0, arg1)
+}
+
+// EditCattleCategory mocks base method.
+func (m *MockPastureService) EditCattleCategory(arg0 context.Context, arg1 *operationPb.AddCattleCategoryRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditCattleCategory", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditCattleCategory indicates an expected call of EditCattleCategory.
+func (mr *MockPastureServiceMockRecorder) EditCattleCategory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditCattleCategory", reflect.TypeOf((*MockPastureService)(nil).EditCattleCategory), arg0, arg1)
+}
+
+// EditFeedByFeedFormula mocks base method.
+func (m *MockPastureService) EditFeedByFeedFormula(arg0 context.Context, arg1 *operationPb.AddFeedFormulaDetail) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditFeedByFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditFeedByFeedFormula indicates an expected call of EditFeedByFeedFormula.
+func (mr *MockPastureServiceMockRecorder) EditFeedByFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditFeedByFeedFormula", reflect.TypeOf((*MockPastureService)(nil).EditFeedByFeedFormula), arg0, arg1)
+}
+
+// EditFeedFormula mocks base method.
+func (m *MockPastureService) EditFeedFormula(arg0 context.Context, arg1 *operationPb.AddFeedFormulaRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditFeedFormula indicates an expected call of EditFeedFormula.
+func (mr *MockPastureServiceMockRecorder) EditFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditFeedFormula", reflect.TypeOf((*MockPastureService)(nil).EditFeedFormula), arg0, arg1)
+}
+
+// EditForage mocks base method.
+func (m *MockPastureService) EditForage(arg0 context.Context, arg1 *operationPb.AddForageRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditForage", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditForage indicates an expected call of EditForage.
+func (mr *MockPastureServiceMockRecorder) EditForage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditForage", reflect.TypeOf((*MockPastureService)(nil).EditForage), arg0, arg1)
+}
+
+// EditForageCategory mocks base method.
+func (m *MockPastureService) EditForageCategory(arg0 context.Context, arg1 *operationPb.AddForageCategoryRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditForageCategory", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditForageCategory indicates an expected call of EditForageCategory.
+func (mr *MockPastureServiceMockRecorder) EditForageCategory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditForageCategory", reflect.TypeOf((*MockPastureService)(nil).EditForageCategory), arg0, arg1)
+}
+
+// EditGroupPasture mocks base method.
+func (m *MockPastureService) EditGroupPasture(arg0 context.Context, arg1 *operationPb.AddPastureRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditGroupPasture", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditGroupPasture indicates an expected call of EditGroupPasture.
+func (mr *MockPastureServiceMockRecorder) EditGroupPasture(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditGroupPasture", reflect.TypeOf((*MockPastureService)(nil).EditGroupPasture), arg0, arg1)
+}
+
+// EditRecodeFeedFormula mocks base method.
+func (m *MockPastureService) EditRecodeFeedFormula(arg0 context.Context, arg1 *operationPb.EditRecodeFeedFormulaRequest) (*operationPb.EditRecodeFeedFormulaResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditRecodeFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.EditRecodeFeedFormulaResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EditRecodeFeedFormula indicates an expected call of EditRecodeFeedFormula.
+func (mr *MockPastureServiceMockRecorder) EditRecodeFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditRecodeFeedFormula", reflect.TypeOf((*MockPastureService)(nil).EditRecodeFeedFormula), arg0, arg1)
+}
+
+// EncodeNumber mocks base method.
+func (m *MockPastureService) EncodeNumber(arg0 context.Context) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EncodeNumber", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// EncodeNumber indicates an expected call of EncodeNumber.
+func (mr *MockPastureServiceMockRecorder) EncodeNumber(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncodeNumber", reflect.TypeOf((*MockPastureService)(nil).EncodeNumber), arg0)
+}
+
+// ExcelExportFeedFormula mocks base method.
+func (m *MockPastureService) ExcelExportFeedFormula(arg0 context.Context, arg1 *operationPb.SearchFeedFormulaRequest) (*bytes.Buffer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExcelExportFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(*bytes.Buffer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExcelExportFeedFormula indicates an expected call of ExcelExportFeedFormula.
+func (mr *MockPastureServiceMockRecorder) ExcelExportFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelExportFeedFormula", reflect.TypeOf((*MockPastureService)(nil).ExcelExportFeedFormula), arg0, arg1)
+}
+
+// ExcelExportForage mocks base method.
+func (m *MockPastureService) ExcelExportForage(arg0 context.Context, arg1 *operationPb.SearchForageListRequest) (*bytes.Buffer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExcelExportForage", arg0, arg1)
+	ret0, _ := ret[0].(*bytes.Buffer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExcelExportForage indicates an expected call of ExcelExportForage.
+func (mr *MockPastureServiceMockRecorder) ExcelExportForage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelExportForage", reflect.TypeOf((*MockPastureService)(nil).ExcelExportForage), arg0, arg1)
+}
+
+// ExcelImportFeedFormula mocks base method.
+func (m *MockPastureService) ExcelImportFeedFormula(arg0 context.Context, arg1 io.Reader) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExcelImportFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ExcelImportFeedFormula indicates an expected call of ExcelImportFeedFormula.
+func (mr *MockPastureServiceMockRecorder) ExcelImportFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelImportFeedFormula", reflect.TypeOf((*MockPastureService)(nil).ExcelImportFeedFormula), arg0, arg1)
+}
+
+// ExcelImportForage mocks base method.
+func (m *MockPastureService) ExcelImportForage(arg0 context.Context, arg1 io.Reader) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExcelImportForage", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ExcelImportForage indicates an expected call of ExcelImportForage.
+func (mr *MockPastureServiceMockRecorder) ExcelImportForage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelImportForage", reflect.TypeOf((*MockPastureService)(nil).ExcelImportForage), arg0, arg1)
+}
+
+// ExcelTemplateFeedFormula mocks base method.
+func (m *MockPastureService) ExcelTemplateFeedFormula(arg0 context.Context) (*bytes.Buffer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExcelTemplateFeedFormula", arg0)
+	ret0, _ := ret[0].(*bytes.Buffer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExcelTemplateFeedFormula indicates an expected call of ExcelTemplateFeedFormula.
+func (mr *MockPastureServiceMockRecorder) ExcelTemplateFeedFormula(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelTemplateFeedFormula", reflect.TypeOf((*MockPastureService)(nil).ExcelTemplateFeedFormula), arg0)
+}
+
+// ExcelTemplateForage mocks base method.
+func (m *MockPastureService) ExcelTemplateForage(arg0 context.Context) (*bytes.Buffer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExcelTemplateForage", arg0)
+	ret0, _ := ret[0].(*bytes.Buffer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExcelTemplateForage indicates an expected call of ExcelTemplateForage.
+func (mr *MockPastureServiceMockRecorder) ExcelTemplateForage(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelTemplateForage", reflect.TypeOf((*MockPastureService)(nil).ExcelTemplateForage), arg0)
+}
+
+// FeedFormulaDetailBySort mocks base method.
+func (m *MockPastureService) FeedFormulaDetailBySort(arg0 context.Context, arg1 *operationPb.GroupAddFeedFormulaDetail) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedFormulaDetailBySort", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FeedFormulaDetailBySort indicates an expected call of FeedFormulaDetailBySort.
+func (mr *MockPastureServiceMockRecorder) FeedFormulaDetailBySort(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaDetailBySort", reflect.TypeOf((*MockPastureService)(nil).FeedFormulaDetailBySort), arg0, arg1)
+}
+
+// FeedFormulaDetailIsModify mocks base method.
+func (m *MockPastureService) FeedFormulaDetailIsModify(arg0 context.Context, arg1 *operationPb.AddFeedFormulaDetail) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedFormulaDetailIsModify", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FeedFormulaDetailIsModify indicates an expected call of FeedFormulaDetailIsModify.
+func (mr *MockPastureServiceMockRecorder) FeedFormulaDetailIsModify(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaDetailIsModify", reflect.TypeOf((*MockPastureService)(nil).FeedFormulaDetailIsModify), arg0, arg1)
+}
+
+// FeedFormulaDetailList mocks base method.
+func (m *MockPastureService) FeedFormulaDetailList(arg0 context.Context, arg1 *operationPb.FeedFormulaDetailRequest) (*operationPb.FeedFormulaDetailResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedFormulaDetailList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.FeedFormulaDetailResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FeedFormulaDetailList indicates an expected call of FeedFormulaDetailList.
+func (mr *MockPastureServiceMockRecorder) FeedFormulaDetailList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaDetailList", reflect.TypeOf((*MockPastureService)(nil).FeedFormulaDetailList), arg0, arg1)
+}
+
+// FeedFormulaUsage mocks base method.
+func (m *MockPastureService) FeedFormulaUsage(arg0 context.Context, arg1 *operationPb.FeedFormulaUsageRequest) (*operationPb.FeedFormulaUsageResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedFormulaUsage", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.FeedFormulaUsageResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FeedFormulaUsage indicates an expected call of FeedFormulaUsage.
+func (mr *MockPastureServiceMockRecorder) FeedFormulaUsage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaUsage", reflect.TypeOf((*MockPastureService)(nil).FeedFormulaUsage), arg0, arg1)
+}
+
+// ForageEnumList mocks base method.
+func (m *MockPastureService) ForageEnumList(arg0 context.Context) *operationPb.ForageEnumListResponse {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ForageEnumList", arg0)
+	ret0, _ := ret[0].(*operationPb.ForageEnumListResponse)
+	return ret0
+}
+
+// ForageEnumList indicates an expected call of ForageEnumList.
+func (mr *MockPastureServiceMockRecorder) ForageEnumList(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForageEnumList", reflect.TypeOf((*MockPastureService)(nil).ForageEnumList), arg0)
+}
+
+// ForageListSort mocks base method.
+func (m *MockPastureService) ForageListSort(arg0 context.Context, arg1 *operationPb.ForageListSortRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ForageListSort", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ForageListSort indicates an expected call of ForageListSort.
+func (mr *MockPastureServiceMockRecorder) ForageListSort(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForageListSort", reflect.TypeOf((*MockPastureService)(nil).ForageListSort), arg0, arg1)
+}
+
+// IsShowCattleCategory mocks base method.
+func (m *MockPastureService) IsShowCattleCategory(arg0 context.Context, arg1 *operationPb.IsShowCattleCategory) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsShowCattleCategory", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IsShowCattleCategory indicates an expected call of IsShowCattleCategory.
+func (mr *MockPastureServiceMockRecorder) IsShowCattleCategory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowCattleCategory", reflect.TypeOf((*MockPastureService)(nil).IsShowCattleCategory), arg0, arg1)
+}
+
+// IsShowFeedFormula mocks base method.
+func (m *MockPastureService) IsShowFeedFormula(arg0 context.Context, arg1 *operationPb.IsShowModifyFeedFormula) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsShowFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IsShowFeedFormula indicates an expected call of IsShowFeedFormula.
+func (mr *MockPastureServiceMockRecorder) IsShowFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowFeedFormula", reflect.TypeOf((*MockPastureService)(nil).IsShowFeedFormula), arg0, arg1)
+}
+
+// IsShowForage mocks base method.
+func (m *MockPastureService) IsShowForage(arg0 context.Context, arg1 *operationPb.IsShowForage) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsShowForage", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IsShowForage indicates an expected call of IsShowForage.
+func (mr *MockPastureServiceMockRecorder) IsShowForage(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowForage", reflect.TypeOf((*MockPastureService)(nil).IsShowForage), arg0, arg1)
+}
+
+// IsShowForageCategory mocks base method.
+func (m *MockPastureService) IsShowForageCategory(arg0 context.Context, arg1 *operationPb.IsShowForageCategory) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsShowForageCategory", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IsShowForageCategory indicates an expected call of IsShowForageCategory.
+func (mr *MockPastureServiceMockRecorder) IsShowForageCategory(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowForageCategory", reflect.TypeOf((*MockPastureService)(nil).IsShowForageCategory), arg0, arg1)
+}
+
+// IsShowGroupPasture mocks base method.
+func (m *MockPastureService) IsShowGroupPasture(arg0 context.Context, arg1 *operationPb.IsShowGroupPasture) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsShowGroupPasture", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IsShowGroupPasture indicates an expected call of IsShowGroupPasture.
+func (mr *MockPastureServiceMockRecorder) IsShowGroupPasture(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowGroupPasture", reflect.TypeOf((*MockPastureService)(nil).IsShowGroupPasture), arg0, arg1)
+}
+
+// MixedFeedFormula mocks base method.
+func (m *MockPastureService) MixedFeedFormula(arg0 context.Context, arg1 *operationPb.MixedFeedFormulaRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MixedFeedFormula", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// MixedFeedFormula indicates an expected call of MixedFeedFormula.
+func (mr *MockPastureServiceMockRecorder) MixedFeedFormula(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MixedFeedFormula", reflect.TypeOf((*MockPastureService)(nil).MixedFeedFormula), arg0, arg1)
+}
+
+// ResetPasswordGroupPasture mocks base method.
+func (m *MockPastureService) ResetPasswordGroupPasture(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResetPasswordGroupPasture", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ResetPasswordGroupPasture indicates an expected call of ResetPasswordGroupPasture.
+func (mr *MockPastureServiceMockRecorder) ResetPasswordGroupPasture(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPasswordGroupPasture", reflect.TypeOf((*MockPastureService)(nil).ResetPasswordGroupPasture), arg0, arg1)
+}
+
+// SearchCattleCategoryList mocks base method.
+func (m *MockPastureService) SearchCattleCategoryList(arg0 context.Context, arg1 *operationPb.SearchCattleCategoryRequest) (*operationPb.SearchCattleCategoryResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchCattleCategoryList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchCattleCategoryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchCattleCategoryList indicates an expected call of SearchCattleCategoryList.
+func (mr *MockPastureServiceMockRecorder) SearchCattleCategoryList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCattleCategoryList", reflect.TypeOf((*MockPastureService)(nil).SearchCattleCategoryList), arg0, arg1)
+}
+
+// SearchFeedFormulaDetail mocks base method.
+func (m *MockPastureService) SearchFeedFormulaDetail(arg0 context.Context, arg1 *operationPb.AddFeedFormulaDetail) (*operationPb.FeedFormulaDetailResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchFeedFormulaDetail", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.FeedFormulaDetailResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchFeedFormulaDetail indicates an expected call of SearchFeedFormulaDetail.
+func (mr *MockPastureServiceMockRecorder) SearchFeedFormulaDetail(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchFeedFormulaDetail", reflect.TypeOf((*MockPastureService)(nil).SearchFeedFormulaDetail), arg0, arg1)
+}
+
+// SearchFeedFormulaList mocks base method.
+func (m *MockPastureService) SearchFeedFormulaList(arg0 context.Context, arg1 *operationPb.SearchFeedFormulaRequest) (*operationPb.SearchFeedFormulaListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchFeedFormulaList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchFeedFormulaListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchFeedFormulaList indicates an expected call of SearchFeedFormulaList.
+func (mr *MockPastureServiceMockRecorder) SearchFeedFormulaList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchFeedFormulaList", reflect.TypeOf((*MockPastureService)(nil).SearchFeedFormulaList), arg0, arg1)
+}
+
+// SearchForageCategoryList mocks base method.
+func (m *MockPastureService) SearchForageCategoryList(arg0 context.Context, arg1 *operationPb.SearchForageCategoryRequest) (*operationPb.SearchForageCategoryResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchForageCategoryList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchForageCategoryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchForageCategoryList indicates an expected call of SearchForageCategoryList.
+func (mr *MockPastureServiceMockRecorder) SearchForageCategoryList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchForageCategoryList", reflect.TypeOf((*MockPastureService)(nil).SearchForageCategoryList), arg0, arg1)
+}
+
+// SearchForageList mocks base method.
+func (m *MockPastureService) SearchForageList(arg0 context.Context, arg1 *operationPb.SearchForageListRequest) (*operationPb.SearchForageListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchForageList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchForageListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchForageList indicates an expected call of SearchForageList.
+func (mr *MockPastureServiceMockRecorder) SearchForageList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchForageList", reflect.TypeOf((*MockPastureService)(nil).SearchForageList), arg0, arg1)
+}
+
+// SearchGroupPastureList mocks base method.
+func (m *MockPastureService) SearchGroupPastureList(arg0 context.Context, arg1 *operationPb.SearchPastureRequest) (*operationPb.SearchPastureResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchGroupPastureList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchPastureResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchGroupPastureList indicates an expected call of SearchGroupPastureList.
+func (mr *MockPastureServiceMockRecorder) SearchGroupPastureList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchGroupPastureList", reflect.TypeOf((*MockPastureService)(nil).SearchGroupPastureList), arg0, arg1)
+}
+
+// SmallMaterial mocks base method.
+func (m *MockPastureService) SmallMaterial(arg0 context.Context, arg1 *operationPb.SmallMaterialRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SmallMaterial", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SmallMaterial indicates an expected call of SmallMaterial.
+func (mr *MockPastureServiceMockRecorder) SmallMaterial(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SmallMaterial", reflect.TypeOf((*MockPastureService)(nil).SmallMaterial), arg0, arg1)
+}

module/backend/mock/PastureSyncService.go

@@ -0,0 +1,106 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-tmr-group/module/backend (interfaces: PastureSyncService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	operationPb "kpt-tmr-group/proto/go/backend/operation"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockPastureSyncService is a mock of PastureSyncService interface.
+type MockPastureSyncService struct {
+	ctrl     *gomock.Controller
+	recorder *MockPastureSyncServiceMockRecorder
+}
+
+// MockPastureSyncServiceMockRecorder is the mock recorder for MockPastureSyncService.
+type MockPastureSyncServiceMockRecorder struct {
+	mock *MockPastureSyncService
+}
+
+// NewMockPastureSyncService creates a new mock instance.
+func NewMockPastureSyncService(ctrl *gomock.Controller) *MockPastureSyncService {
+	mock := &MockPastureSyncService{ctrl: ctrl}
+	mock.recorder = &MockPastureSyncServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPastureSyncService) EXPECT() *MockPastureSyncServiceMockRecorder {
+	return m.recorder
+}
+
+// CategoryDeleteData mocks base method.
+func (m *MockPastureSyncService) CategoryDeleteData(arg0 context.Context, arg1 *operationPb.CategoryDeleteRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CategoryDeleteData", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CategoryDeleteData indicates an expected call of CategoryDeleteData.
+func (mr *MockPastureSyncServiceMockRecorder) CategoryDeleteData(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CategoryDeleteData", reflect.TypeOf((*MockPastureSyncService)(nil).CategoryDeleteData), arg0, arg1)
+}
+
+// CategorySyncData mocks base method.
+func (m *MockPastureSyncService) CategorySyncData(arg0 context.Context, arg1 *operationPb.CategorySyncRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CategorySyncData", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CategorySyncData indicates an expected call of CategorySyncData.
+func (mr *MockPastureSyncServiceMockRecorder) CategorySyncData(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CategorySyncData", reflect.TypeOf((*MockPastureSyncService)(nil).CategorySyncData), arg0, arg1)
+}
+
+// FeedFormulaDetailListSyncData mocks base method.
+func (m *MockPastureSyncService) FeedFormulaDetailListSyncData(arg0 context.Context, arg1 *operationPb.FeedFormulaSyncRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedFormulaDetailListSyncData", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FeedFormulaDetailListSyncData indicates an expected call of FeedFormulaDetailListSyncData.
+func (mr *MockPastureSyncServiceMockRecorder) FeedFormulaDetailListSyncData(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaDetailListSyncData", reflect.TypeOf((*MockPastureSyncService)(nil).FeedFormulaDetailListSyncData), arg0, arg1)
+}
+
+// FeedFormulaSyncData mocks base method.
+func (m *MockPastureSyncService) FeedFormulaSyncData(arg0 context.Context, arg1 *operationPb.FeedFormulaSyncRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedFormulaSyncData", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FeedFormulaSyncData indicates an expected call of FeedFormulaSyncData.
+func (mr *MockPastureSyncServiceMockRecorder) FeedFormulaSyncData(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaSyncData", reflect.TypeOf((*MockPastureSyncService)(nil).FeedFormulaSyncData), arg0, arg1)
+}
+
+// FeedSyncData mocks base method.
+func (m *MockPastureSyncService) FeedSyncData(arg0 context.Context, arg1 *operationPb.FeedFormulaSyncRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedSyncData", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FeedSyncData indicates an expected call of FeedSyncData.
+func (mr *MockPastureSyncServiceMockRecorder) FeedSyncData(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedSyncData", reflect.TypeOf((*MockPastureSyncService)(nil).FeedSyncData), arg0, arg1)
+}

module/backend/mock/StatisticService.go

@@ -0,0 +1,353 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-tmr-group/module/backend (interfaces: StatisticService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	bytes "bytes"
+	context "context"
+	model "kpt-tmr-group/model"
+	operationPb "kpt-tmr-group/proto/go/backend/operation"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockStatisticService is a mock of StatisticService interface.
+type MockStatisticService struct {
+	ctrl     *gomock.Controller
+	recorder *MockStatisticServiceMockRecorder
+}
+
+// MockStatisticServiceMockRecorder is the mock recorder for MockStatisticService.
+type MockStatisticServiceMockRecorder struct {
+	mock *MockStatisticService
+}
+
+// NewMockStatisticService creates a new mock instance.
+func NewMockStatisticService(ctrl *gomock.Controller) *MockStatisticService {
+	mock := &MockStatisticService{ctrl: ctrl}
+	mock.recorder = &MockStatisticServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStatisticService) EXPECT() *MockStatisticServiceMockRecorder {
+	return m.recorder
+}
+
+// AnalysisMixedSprinkleDetail mocks base method.
+func (m *MockStatisticService) AnalysisMixedSprinkleDetail(arg0 context.Context, arg1 *operationPb.ProcessMixedSprinkleDetailRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AnalysisMixedSprinkleDetail", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AnalysisMixedSprinkleDetail indicates an expected call of AnalysisMixedSprinkleDetail.
+func (mr *MockStatisticServiceMockRecorder) AnalysisMixedSprinkleDetail(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnalysisMixedSprinkleDetail", reflect.TypeOf((*MockStatisticService)(nil).AnalysisMixedSprinkleDetail), arg0, arg1)
+}
+
+// CowsAnalysis mocks base method.
+func (m *MockStatisticService) CowsAnalysis(arg0 context.Context, arg1 *operationPb.CowsAnalysisRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowsAnalysis", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowsAnalysis indicates an expected call of CowsAnalysis.
+func (mr *MockStatisticServiceMockRecorder) CowsAnalysis(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowsAnalysis", reflect.TypeOf((*MockStatisticService)(nil).CowsAnalysis), arg0, arg1)
+}
+
+// ExecutionTime mocks base method.
+func (m *MockStatisticService) ExecutionTime(arg0 context.Context, arg1 *operationPb.SearchAnalysisAccuracyRequest) (*model.ExecTimeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecutionTime", arg0, arg1)
+	ret0, _ := ret[0].(*model.ExecTimeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecutionTime indicates an expected call of ExecutionTime.
+func (mr *MockStatisticServiceMockRecorder) ExecutionTime(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutionTime", reflect.TypeOf((*MockStatisticService)(nil).ExecutionTime), arg0, arg1)
+}
+
+// FeedChartStatistics mocks base method.
+func (m *MockStatisticService) FeedChartStatistics(arg0 context.Context, arg1 *operationPb.FeedChartStatisticsRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedChartStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FeedChartStatistics indicates an expected call of FeedChartStatistics.
+func (mr *MockStatisticServiceMockRecorder) FeedChartStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedChartStatistics", reflect.TypeOf((*MockStatisticService)(nil).FeedChartStatistics), arg0, arg1)
+}
+
+// FeedMixedAndTmrName mocks base method.
+func (m *MockStatisticService) FeedMixedAndTmrName(arg0 context.Context, arg1 *operationPb.MixedCategoryTmrName) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedMixedAndTmrName", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FeedMixedAndTmrName indicates an expected call of FeedMixedAndTmrName.
+func (mr *MockStatisticServiceMockRecorder) FeedMixedAndTmrName(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedMixedAndTmrName", reflect.TypeOf((*MockStatisticService)(nil).FeedMixedAndTmrName), arg0, arg1)
+}
+
+// GetDataByName mocks base method.
+func (m *MockStatisticService) GetDataByName(arg0 context.Context, arg1 *operationPb.GetDataByNameRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDataByName", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataByName indicates an expected call of GetDataByName.
+func (mr *MockStatisticServiceMockRecorder) GetDataByName(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataByName", reflect.TypeOf((*MockStatisticService)(nil).GetDataByName), arg0, arg1)
+}
+
+// GetTrainNumber mocks base method.
+func (m *MockStatisticService) GetTrainNumber(arg0 context.Context, arg1 *operationPb.TrainNumberRequest) (*operationPb.TrainNumberResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTrainNumber", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.TrainNumberResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTrainNumber indicates an expected call of GetTrainNumber.
+func (mr *MockStatisticServiceMockRecorder) GetTrainNumber(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrainNumber", reflect.TypeOf((*MockStatisticService)(nil).GetTrainNumber), arg0, arg1)
+}
+
+// InventoryStatisticsExcelExport mocks base method.
+func (m *MockStatisticService) InventoryStatisticsExcelExport(arg0 context.Context, arg1 *operationPb.SearchInventoryStatisticsRequest) (*bytes.Buffer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InventoryStatisticsExcelExport", arg0, arg1)
+	ret0, _ := ret[0].(*bytes.Buffer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InventoryStatisticsExcelExport indicates an expected call of InventoryStatisticsExcelExport.
+func (mr *MockStatisticServiceMockRecorder) InventoryStatisticsExcelExport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InventoryStatisticsExcelExport", reflect.TypeOf((*MockStatisticService)(nil).InventoryStatisticsExcelExport), arg0, arg1)
+}
+
+// SearchAccuracyAggStatistics mocks base method.
+func (m *MockStatisticService) SearchAccuracyAggStatistics(arg0 context.Context, arg1 *operationPb.AccuracyAggStatisticsRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchAccuracyAggStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchAccuracyAggStatistics indicates an expected call of SearchAccuracyAggStatistics.
+func (mr *MockStatisticServiceMockRecorder) SearchAccuracyAggStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchAccuracyAggStatistics", reflect.TypeOf((*MockStatisticService)(nil).SearchAccuracyAggStatistics), arg0, arg1)
+}
+
+// SearchAnalysisAccuracy mocks base method.
+func (m *MockStatisticService) SearchAnalysisAccuracy(arg0 context.Context, arg1 *operationPb.SearchAnalysisAccuracyRequest) (*model.SearchAnalysisAccuracyResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchAnalysisAccuracy", arg0, arg1)
+	ret0, _ := ret[0].(*model.SearchAnalysisAccuracyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchAnalysisAccuracy indicates an expected call of SearchAnalysisAccuracy.
+func (mr *MockStatisticServiceMockRecorder) SearchAnalysisAccuracy(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchAnalysisAccuracy", reflect.TypeOf((*MockStatisticService)(nil).SearchAnalysisAccuracy), arg0, arg1)
+}
+
+// SearchFeedStatistics mocks base method.
+func (m *MockStatisticService) SearchFeedStatistics(arg0 context.Context, arg1 *operationPb.SearchFeedStatisticsRequest) (*model.FeedStatisticsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchFeedStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*model.FeedStatisticsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchFeedStatistics indicates an expected call of SearchFeedStatistics.
+func (mr *MockStatisticServiceMockRecorder) SearchFeedStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchFeedStatistics", reflect.TypeOf((*MockStatisticService)(nil).SearchFeedStatistics), arg0, arg1)
+}
+
+// SearchFormulaEstimateList mocks base method.
+func (m *MockStatisticService) SearchFormulaEstimateList(arg0 context.Context, arg1 *operationPb.SearchFormulaEstimateRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchFormulaEstimateList", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchFormulaEstimateList indicates an expected call of SearchFormulaEstimateList.
+func (mr *MockStatisticServiceMockRecorder) SearchFormulaEstimateList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchFormulaEstimateList", reflect.TypeOf((*MockStatisticService)(nil).SearchFormulaEstimateList), arg0, arg1)
+}
+
+// SearchInventoryStatistics mocks base method.
+func (m *MockStatisticService) SearchInventoryStatistics(arg0 context.Context, arg1 *operationPb.SearchInventoryStatisticsRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchInventoryStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchInventoryStatistics indicates an expected call of SearchInventoryStatistics.
+func (mr *MockStatisticServiceMockRecorder) SearchInventoryStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchInventoryStatistics", reflect.TypeOf((*MockStatisticService)(nil).SearchInventoryStatistics), arg0, arg1)
+}
+
+// SearchMixFeedStatistics mocks base method.
+func (m *MockStatisticService) SearchMixFeedStatistics(arg0 context.Context, arg1 *operationPb.MixFeedStatisticsRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchMixFeedStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchMixFeedStatistics indicates an expected call of SearchMixFeedStatistics.
+func (mr *MockStatisticServiceMockRecorder) SearchMixFeedStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchMixFeedStatistics", reflect.TypeOf((*MockStatisticService)(nil).SearchMixFeedStatistics), arg0, arg1)
+}
+
+// SearchPriceStatistics mocks base method.
+func (m *MockStatisticService) SearchPriceStatistics(arg0 context.Context, arg1 *operationPb.SearchPriceStatisticsRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchPriceStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchPriceStatistics indicates an expected call of SearchPriceStatistics.
+func (mr *MockStatisticServiceMockRecorder) SearchPriceStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchPriceStatistics", reflect.TypeOf((*MockStatisticService)(nil).SearchPriceStatistics), arg0, arg1)
+}
+
+// SearchProcessAnalysis mocks base method.
+func (m *MockStatisticService) SearchProcessAnalysis(arg0 context.Context, arg1 *operationPb.ProcessAnalysisRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchProcessAnalysis", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchProcessAnalysis indicates an expected call of SearchProcessAnalysis.
+func (mr *MockStatisticServiceMockRecorder) SearchProcessAnalysis(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProcessAnalysis", reflect.TypeOf((*MockStatisticService)(nil).SearchProcessAnalysis), arg0, arg1)
+}
+
+// SearchSprinkleStatistics mocks base method.
+func (m *MockStatisticService) SearchSprinkleStatistics(arg0 context.Context, arg1 *operationPb.SprinkleStatisticsRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSprinkleStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSprinkleStatistics indicates an expected call of SearchSprinkleStatistics.
+func (mr *MockStatisticServiceMockRecorder) SearchSprinkleStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSprinkleStatistics", reflect.TypeOf((*MockStatisticService)(nil).SearchSprinkleStatistics), arg0, arg1)
+}
+
+// SearchUserMaterialsStatistics mocks base method.
+func (m *MockStatisticService) SearchUserMaterialsStatistics(arg0 context.Context, arg1 *operationPb.SearchUserMaterialsStatisticsRequest) (*model.PastureCommonResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchUserMaterialsStatistics", arg0, arg1)
+	ret0, _ := ret[0].(*model.PastureCommonResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchUserMaterialsStatistics indicates an expected call of SearchUserMaterialsStatistics.
+func (mr *MockStatisticServiceMockRecorder) SearchUserMaterialsStatistics(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchUserMaterialsStatistics", reflect.TypeOf((*MockStatisticService)(nil).SearchUserMaterialsStatistics), arg0, arg1)
+}
+
+// SprinkleFeedTime mocks base method.
+func (m *MockStatisticService) SprinkleFeedTime(arg0 context.Context, arg1 *operationPb.SprinkleFeedTimeRequest) (*model.SprinkleFeedTimeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SprinkleFeedTime", arg0, arg1)
+	ret0, _ := ret[0].(*model.SprinkleFeedTimeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SprinkleFeedTime indicates an expected call of SprinkleFeedTime.
+func (mr *MockStatisticServiceMockRecorder) SprinkleFeedTime(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SprinkleFeedTime", reflect.TypeOf((*MockStatisticService)(nil).SprinkleFeedTime), arg0, arg1)
+}
+
+// TopPasture mocks base method.
+func (m *MockStatisticService) TopPasture(arg0 context.Context, arg1 *operationPb.SearchAnalysisAccuracyRequest) (*model.GetPastureTopResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TopPasture", arg0, arg1)
+	ret0, _ := ret[0].(*model.GetPastureTopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TopPasture indicates an expected call of TopPasture.
+func (mr *MockStatisticServiceMockRecorder) TopPasture(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopPasture", reflect.TypeOf((*MockStatisticService)(nil).TopPasture), arg0, arg1)
+}
+
+// UserMaterialsStatisticsExcelExport mocks base method.
+func (m *MockStatisticService) UserMaterialsStatisticsExcelExport(arg0 context.Context, arg1 *operationPb.SearchUserMaterialsStatisticsRequest) (*bytes.Buffer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UserMaterialsStatisticsExcelExport", arg0, arg1)
+	ret0, _ := ret[0].(*bytes.Buffer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UserMaterialsStatisticsExcelExport indicates an expected call of UserMaterialsStatisticsExcelExport.
+func (mr *MockStatisticServiceMockRecorder) UserMaterialsStatisticsExcelExport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserMaterialsStatisticsExcelExport", reflect.TypeOf((*MockStatisticService)(nil).UserMaterialsStatisticsExcelExport), arg0, arg1)
+}

module/backend/mock/SystemService.go

@@ -0,0 +1,354 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-tmr-group/module/backend (interfaces: SystemService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	operationPb "kpt-tmr-group/proto/go/backend/operation"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockSystemService is a mock of SystemService interface.
+type MockSystemService struct {
+	ctrl     *gomock.Controller
+	recorder *MockSystemServiceMockRecorder
+}
+
+// MockSystemServiceMockRecorder is the mock recorder for MockSystemService.
+type MockSystemServiceMockRecorder struct {
+	mock *MockSystemService
+}
+
+// NewMockSystemService creates a new mock instance.
+func NewMockSystemService(ctrl *gomock.Controller) *MockSystemService {
+	mock := &MockSystemService{ctrl: ctrl}
+	mock.recorder = &MockSystemServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockSystemService) EXPECT() *MockSystemServiceMockRecorder {
+	return m.recorder
+}
+
+// Auth mocks base method.
+func (m *MockSystemService) Auth(arg0 context.Context, arg1 *operationPb.UserAuthData) (*operationPb.SystemToken, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Auth", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SystemToken)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Auth indicates an expected call of Auth.
+func (mr *MockSystemServiceMockRecorder) Auth(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Auth", reflect.TypeOf((*MockSystemService)(nil).Auth), arg0, arg1)
+}
+
+// CreateSystemMenu mocks base method.
+func (m *MockSystemService) CreateSystemMenu(arg0 context.Context, arg1 *operationPb.AddMenuRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSystemMenu", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateSystemMenu indicates an expected call of CreateSystemMenu.
+func (mr *MockSystemServiceMockRecorder) CreateSystemMenu(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSystemMenu", reflect.TypeOf((*MockSystemService)(nil).CreateSystemMenu), arg0, arg1)
+}
+
+// CreateSystemRole mocks base method.
+func (m *MockSystemService) CreateSystemRole(arg0 context.Context, arg1 *operationPb.AddRoleRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSystemRole", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateSystemRole indicates an expected call of CreateSystemRole.
+func (mr *MockSystemServiceMockRecorder) CreateSystemRole(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSystemRole", reflect.TypeOf((*MockSystemService)(nil).CreateSystemRole), arg0, arg1)
+}
+
+// CreateSystemUser mocks base method.
+func (m *MockSystemService) CreateSystemUser(arg0 context.Context, arg1 *operationPb.AddSystemUser) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSystemUser", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateSystemUser indicates an expected call of CreateSystemUser.
+func (mr *MockSystemServiceMockRecorder) CreateSystemUser(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSystemUser", reflect.TypeOf((*MockSystemService)(nil).CreateSystemUser), arg0, arg1)
+}
+
+// DeleteSystemMenu mocks base method.
+func (m *MockSystemService) DeleteSystemMenu(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSystemMenu", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteSystemMenu indicates an expected call of DeleteSystemMenu.
+func (mr *MockSystemServiceMockRecorder) DeleteSystemMenu(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSystemMenu", reflect.TypeOf((*MockSystemService)(nil).DeleteSystemMenu), arg0, arg1)
+}
+
+// DeleteSystemRole mocks base method.
+func (m *MockSystemService) DeleteSystemRole(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSystemRole", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteSystemRole indicates an expected call of DeleteSystemRole.
+func (mr *MockSystemServiceMockRecorder) DeleteSystemRole(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSystemRole", reflect.TypeOf((*MockSystemService)(nil).DeleteSystemRole), arg0, arg1)
+}
+
+// DeleteSystemUser mocks base method.
+func (m *MockSystemService) DeleteSystemUser(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSystemUser", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteSystemUser indicates an expected call of DeleteSystemUser.
+func (mr *MockSystemServiceMockRecorder) DeleteSystemUser(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSystemUser", reflect.TypeOf((*MockSystemService)(nil).DeleteSystemUser), arg0, arg1)
+}
+
+// DetailsSystemUser mocks base method.
+func (m *MockSystemService) DetailsSystemUser(arg0 context.Context, arg1 int64) (*operationPb.UserDetails, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DetailsSystemUser", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.UserDetails)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DetailsSystemUser indicates an expected call of DetailsSystemUser.
+func (mr *MockSystemServiceMockRecorder) DetailsSystemUser(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetailsSystemUser", reflect.TypeOf((*MockSystemService)(nil).DetailsSystemUser), arg0, arg1)
+}
+
+// EditSystemMenu mocks base method.
+func (m *MockSystemService) EditSystemMenu(arg0 context.Context, arg1 *operationPb.AddMenuRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditSystemMenu", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditSystemMenu indicates an expected call of EditSystemMenu.
+func (mr *MockSystemServiceMockRecorder) EditSystemMenu(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditSystemMenu", reflect.TypeOf((*MockSystemService)(nil).EditSystemMenu), arg0, arg1)
+}
+
+// EditSystemRole mocks base method.
+func (m *MockSystemService) EditSystemRole(arg0 context.Context, arg1 *operationPb.AddRoleRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditSystemRole", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditSystemRole indicates an expected call of EditSystemRole.
+func (mr *MockSystemServiceMockRecorder) EditSystemRole(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditSystemRole", reflect.TypeOf((*MockSystemService)(nil).EditSystemRole), arg0, arg1)
+}
+
+// EditSystemUser mocks base method.
+func (m *MockSystemService) EditSystemUser(arg0 context.Context, arg1 *operationPb.AddSystemUser) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EditSystemUser", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EditSystemUser indicates an expected call of EditSystemUser.
+func (mr *MockSystemServiceMockRecorder) EditSystemUser(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditSystemUser", reflect.TypeOf((*MockSystemService)(nil).EditSystemUser), arg0, arg1)
+}
+
+// GetCurrentUserName mocks base method.
+func (m *MockSystemService) GetCurrentUserName(arg0 context.Context) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCurrentUserName", arg0)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCurrentUserName indicates an expected call of GetCurrentUserName.
+func (mr *MockSystemServiceMockRecorder) GetCurrentUserName(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentUserName", reflect.TypeOf((*MockSystemService)(nil).GetCurrentUserName), arg0)
+}
+
+// GetRolePermissions mocks base method.
+func (m *MockSystemService) GetRolePermissions(arg0 context.Context, arg1 int64) (*operationPb.RolePermissionsList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRolePermissions", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.RolePermissionsList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRolePermissions indicates an expected call of GetRolePermissions.
+func (mr *MockSystemServiceMockRecorder) GetRolePermissions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolePermissions", reflect.TypeOf((*MockSystemService)(nil).GetRolePermissions), arg0, arg1)
+}
+
+// GetSystemUserPermissions mocks base method.
+func (m *MockSystemService) GetSystemUserPermissions(arg0 context.Context, arg1 string) (*operationPb.SystemUserMenuPermissions, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSystemUserPermissions", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SystemUserMenuPermissions)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSystemUserPermissions indicates an expected call of GetSystemUserPermissions.
+func (mr *MockSystemServiceMockRecorder) GetSystemUserPermissions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemUserPermissions", reflect.TypeOf((*MockSystemService)(nil).GetSystemUserPermissions), arg0, arg1)
+}
+
+// GetUserInfo mocks base method.
+func (m *MockSystemService) GetUserInfo(arg0 context.Context, arg1 string) (*operationPb.UserAuth, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUserInfo", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.UserAuth)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUserInfo indicates an expected call of GetUserInfo.
+func (mr *MockSystemServiceMockRecorder) GetUserInfo(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserInfo", reflect.TypeOf((*MockSystemService)(nil).GetUserInfo), arg0, arg1)
+}
+
+// IsShowSystemMenu mocks base method.
+func (m *MockSystemService) IsShowSystemMenu(arg0 context.Context, arg1 *operationPb.IsShowSystemMenuRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsShowSystemMenu", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IsShowSystemMenu indicates an expected call of IsShowSystemMenu.
+func (mr *MockSystemServiceMockRecorder) IsShowSystemMenu(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowSystemMenu", reflect.TypeOf((*MockSystemService)(nil).IsShowSystemMenu), arg0, arg1)
+}
+
+// IsShowSystemUser mocks base method.
+func (m *MockSystemService) IsShowSystemUser(arg0 context.Context, arg1 *operationPb.IsShowSystemUserRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsShowSystemUser", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IsShowSystemUser indicates an expected call of IsShowSystemUser.
+func (mr *MockSystemServiceMockRecorder) IsShowSystemUser(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowSystemUser", reflect.TypeOf((*MockSystemService)(nil).IsShowSystemUser), arg0, arg1)
+}
+
+// ResetPasswordSystemUser mocks base method.
+func (m *MockSystemService) ResetPasswordSystemUser(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResetPasswordSystemUser", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ResetPasswordSystemUser indicates an expected call of ResetPasswordSystemUser.
+func (mr *MockSystemServiceMockRecorder) ResetPasswordSystemUser(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPasswordSystemUser", reflect.TypeOf((*MockSystemService)(nil).ResetPasswordSystemUser), arg0, arg1)
+}
+
+// SearchMobileList mocks base method.
+func (m *MockSystemService) SearchMobileList(arg0 context.Context, arg1 *operationPb.SearchMobileRequest) (*operationPb.SearchMobileResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchMobileList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchMobileResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchMobileList indicates an expected call of SearchMobileList.
+func (mr *MockSystemServiceMockRecorder) SearchMobileList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchMobileList", reflect.TypeOf((*MockSystemService)(nil).SearchMobileList), arg0, arg1)
+}
+
+// SearchSystemMenuList mocks base method.
+func (m *MockSystemService) SearchSystemMenuList(arg0 context.Context, arg1 *operationPb.SearchMenuRequest) (*operationPb.SearchMenuResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSystemMenuList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchMenuResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSystemMenuList indicates an expected call of SearchSystemMenuList.
+func (mr *MockSystemServiceMockRecorder) SearchSystemMenuList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemMenuList", reflect.TypeOf((*MockSystemService)(nil).SearchSystemMenuList), arg0, arg1)
+}
+
+// SearchSystemRoleList mocks base method.
+func (m *MockSystemService) SearchSystemRoleList(arg0 context.Context, arg1 *operationPb.SearchRoleRequest) (*operationPb.SearchRoleResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSystemRoleList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchRoleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSystemRoleList indicates an expected call of SearchSystemRoleList.
+func (mr *MockSystemServiceMockRecorder) SearchSystemRoleList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemRoleList", reflect.TypeOf((*MockSystemService)(nil).SearchSystemRoleList), arg0, arg1)
+}
+
+// SearchSystemUserList mocks base method.
+func (m *MockSystemService) SearchSystemUserList(arg0 context.Context, arg1 *operationPb.SearchUserRequest) (*operationPb.SearchUserResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSystemUserList", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.SearchUserResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSystemUserList indicates an expected call of SearchSystemUserList.
+func (mr *MockSystemServiceMockRecorder) SearchSystemUserList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemUserList", reflect.TypeOf((*MockSystemService)(nil).SearchSystemUserList), arg0, arg1)
+}

module/backend/mock/WxAppletService.go

@@ -0,0 +1,51 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-tmr-group/module/backend (interfaces: WxAppletService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	operationPb "kpt-tmr-group/proto/go/backend/operation"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockWxAppletService is a mock of WxAppletService interface.
+type MockWxAppletService struct {
+	ctrl     *gomock.Controller
+	recorder *MockWxAppletServiceMockRecorder
+}
+
+// MockWxAppletServiceMockRecorder is the mock recorder for MockWxAppletService.
+type MockWxAppletServiceMockRecorder struct {
+	mock *MockWxAppletService
+}
+
+// NewMockWxAppletService creates a new mock instance.
+func NewMockWxAppletService(ctrl *gomock.Controller) *MockWxAppletService {
+	mock := &MockWxAppletService{ctrl: ctrl}
+	mock.recorder = &MockWxAppletServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockWxAppletService) EXPECT() *MockWxAppletServiceMockRecorder {
+	return m.recorder
+}
+
+// GetOpenId mocks base method.
+func (m *MockWxAppletService) GetOpenId(arg0 context.Context, arg1 string) (*operationPb.WxOpenId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetOpenId", arg0, arg1)
+	ret0, _ := ret[0].(*operationPb.WxOpenId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOpenId indicates an expected call of GetOpenId.
+func (mr *MockWxAppletServiceMockRecorder) GetOpenId(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenId", reflect.TypeOf((*MockWxAppletService)(nil).GetOpenId), arg0, arg1)
+}

module/backend/mock/kptservice.go

@@ -693,6 +693,20 @@ func (mr *MockKptServiceMockRecorder) FeedFormulaDetailBySort(arg0, arg1 interfa
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaDetailBySort", reflect.TypeOf((*MockKptService)(nil).FeedFormulaDetailBySort), arg0, arg1)
 }
 
+// FeedFormulaDetailIsModify mocks base method.
+func (m *MockKptService) FeedFormulaDetailIsModify(arg0 context.Context, arg1 *operationPb.AddFeedFormulaDetail) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FeedFormulaDetailIsModify", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FeedFormulaDetailIsModify indicates an expected call of FeedFormulaDetailIsModify.
+func (mr *MockKptServiceMockRecorder) FeedFormulaDetailIsModify(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaDetailIsModify", reflect.TypeOf((*MockKptService)(nil).FeedFormulaDetailIsModify), arg0, arg1)
+}
+
 // FeedFormulaDetailList mocks base method.
 func (m *MockKptService) FeedFormulaDetailList(arg0 context.Context, arg1 *operationPb.FeedFormulaDetailRequest) (*operationPb.FeedFormulaDetailResponse, error) {
 	m.ctrl.T.Helper()