kpt-tmr-group/module/backend/mock/kptservice.go

// Code generated by MockGen. DO NOT EDIT.
// Source: kpt-tmr-group/module/backend (interfaces: KptService)

// 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"
)

// MockKptService is a mock of KptService interface.
type MockKptService struct {
	ctrl     *gomock.Controller
	recorder *MockKptServiceMockRecorder
}

// MockKptServiceMockRecorder is the mock recorder for MockKptService.
type MockKptServiceMockRecorder struct {
	mock *MockKptService
}

// NewMockKptService creates a new mock instance.
func NewMockKptService(ctrl *gomock.Controller) *MockKptService {
	mock := &MockKptService{ctrl: ctrl}
	mock.recorder = &MockKptServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockKptService) EXPECT() *MockKptServiceMockRecorder {
	return m.recorder
}

// AddCattleCategory mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) AddCattleCategory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCattleCategory", reflect.TypeOf((*MockKptService)(nil).AddCattleCategory), arg0, arg1)
}

// AddForageCategory mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) AddForageCategory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddForageCategory", reflect.TypeOf((*MockKptService)(nil).AddForageCategory), arg0, arg1)
}

// AnalysisMixedSprinkleDetail mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) AnalysisMixedSprinkleDetail(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnalysisMixedSprinkleDetail", reflect.TypeOf((*MockKptService)(nil).AnalysisMixedSprinkleDetail), arg0, arg1)
}

// Auth mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) Auth(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Auth", reflect.TypeOf((*MockKptService)(nil).Auth), arg0, arg1)
}

// CategoryDeleteData mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CategoryDeleteData(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CategoryDeleteData", reflect.TypeOf((*MockKptService)(nil).CategoryDeleteData), arg0, arg1)
}

// CategorySyncData mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CategorySyncData(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CategorySyncData", reflect.TypeOf((*MockKptService)(nil).CategorySyncData), arg0, arg1)
}

// CowsAnalysis mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CowsAnalysis(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowsAnalysis", reflect.TypeOf((*MockKptService)(nil).CowsAnalysis), arg0, arg1)
}

// CreateFeedFormula mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CreateFeedFormula(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFeedFormula", reflect.TypeOf((*MockKptService)(nil).CreateFeedFormula), arg0, arg1)
}

// CreateForage mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CreateForage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateForage", reflect.TypeOf((*MockKptService)(nil).CreateForage), arg0, arg1)
}

// CreateGroupPasture mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CreateGroupPasture(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroupPasture", reflect.TypeOf((*MockKptService)(nil).CreateGroupPasture), arg0, arg1)
}

// CreateSystemMenu mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CreateSystemMenu(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSystemMenu", reflect.TypeOf((*MockKptService)(nil).CreateSystemMenu), arg0, arg1)
}

// CreateSystemRole mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CreateSystemRole(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSystemRole", reflect.TypeOf((*MockKptService)(nil).CreateSystemRole), arg0, arg1)
}

// CreateSystemUser mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) CreateSystemUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSystemUser", reflect.TypeOf((*MockKptService)(nil).CreateSystemUser), arg0, arg1)
}

// DeleteCattleCategory mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DeleteCattleCategory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCattleCategory", reflect.TypeOf((*MockKptService)(nil).DeleteCattleCategory), arg0, arg1)
}

// DeleteFeedFormula mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DeleteFeedFormula(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFeedFormula", reflect.TypeOf((*MockKptService)(nil).DeleteFeedFormula), arg0, arg1)
}

// DeleteForageCategory mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DeleteForageCategory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteForageCategory", reflect.TypeOf((*MockKptService)(nil).DeleteForageCategory), arg0, arg1)
}

// DeleteForageList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DeleteForageList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteForageList", reflect.TypeOf((*MockKptService)(nil).DeleteForageList), arg0, arg1)
}

// DeleteGroupPasture mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DeleteGroupPasture(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupPasture", reflect.TypeOf((*MockKptService)(nil).DeleteGroupPasture), arg0, arg1)
}

// DeleteSystemMenu mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DeleteSystemMenu(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSystemMenu", reflect.TypeOf((*MockKptService)(nil).DeleteSystemMenu), arg0, arg1)
}

// DeleteSystemRole mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DeleteSystemRole(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSystemRole", reflect.TypeOf((*MockKptService)(nil).DeleteSystemRole), arg0, arg1)
}

// DeleteSystemUser mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DeleteSystemUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSystemUser", reflect.TypeOf((*MockKptService)(nil).DeleteSystemUser), arg0, arg1)
}

// DetailsSystemUser mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DetailsSystemUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetailsSystemUser", reflect.TypeOf((*MockKptService)(nil).DetailsSystemUser), arg0, arg1)
}

// DistributeFeedFormula mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) DistributeFeedFormula(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DistributeFeedFormula", reflect.TypeOf((*MockKptService)(nil).DistributeFeedFormula), arg0, arg1)
}

// EditCattleCategory mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EditCattleCategory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditCattleCategory", reflect.TypeOf((*MockKptService)(nil).EditCattleCategory), arg0, arg1)
}

// EditFeedFormula mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EditFeedFormula(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditFeedFormula", reflect.TypeOf((*MockKptService)(nil).EditFeedFormula), arg0, arg1)
}

// EditForage mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EditForage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditForage", reflect.TypeOf((*MockKptService)(nil).EditForage), arg0, arg1)
}

// EditForageCategory mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EditForageCategory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditForageCategory", reflect.TypeOf((*MockKptService)(nil).EditForageCategory), arg0, arg1)
}

// EditGroupPasture mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EditGroupPasture(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditGroupPasture", reflect.TypeOf((*MockKptService)(nil).EditGroupPasture), arg0, arg1)
}

// EditSystemMenu mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EditSystemMenu(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditSystemMenu", reflect.TypeOf((*MockKptService)(nil).EditSystemMenu), arg0, arg1)
}

// EditSystemRole mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EditSystemRole(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditSystemRole", reflect.TypeOf((*MockKptService)(nil).EditSystemRole), arg0, arg1)
}

// EditSystemUser mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EditSystemUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditSystemUser", reflect.TypeOf((*MockKptService)(nil).EditSystemUser), arg0, arg1)
}

// EncodeNumber mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) EncodeNumber(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncodeNumber", reflect.TypeOf((*MockKptService)(nil).EncodeNumber), arg0)
}

// ExcelExportFeedFormula mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ExcelExportFeedFormula(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelExportFeedFormula", reflect.TypeOf((*MockKptService)(nil).ExcelExportFeedFormula), arg0, arg1)
}

// ExcelExportForage mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ExcelExportForage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelExportForage", reflect.TypeOf((*MockKptService)(nil).ExcelExportForage), arg0, arg1)
}

// ExcelImportFeedFormula mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ExcelImportFeedFormula(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelImportFeedFormula", reflect.TypeOf((*MockKptService)(nil).ExcelImportFeedFormula), arg0, arg1)
}

// ExcelImportForage mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ExcelImportForage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelImportForage", reflect.TypeOf((*MockKptService)(nil).ExcelImportForage), arg0, arg1)
}

// ExcelTemplateFeedFormula mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ExcelTemplateFeedFormula(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelTemplateFeedFormula", reflect.TypeOf((*MockKptService)(nil).ExcelTemplateFeedFormula), arg0)
}

// ExcelTemplateForage mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ExcelTemplateForage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExcelTemplateForage", reflect.TypeOf((*MockKptService)(nil).ExcelTemplateForage), arg0)
}

// ExecutionTime mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ExecutionTime(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutionTime", reflect.TypeOf((*MockKptService)(nil).ExecutionTime), arg0, arg1)
}

// FeedChartStatistics mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) FeedChartStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedChartStatistics", reflect.TypeOf((*MockKptService)(nil).FeedChartStatistics), arg0, arg1)
}

// FeedFormulaSyncData mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) FeedFormulaSyncData(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaSyncData", reflect.TypeOf((*MockKptService)(nil).FeedFormulaSyncData), arg0, arg1)
}

// FeedFormulaUsage mocks base method.
func (m *MockKptService) FeedFormulaUsage(arg0 context.Context, arg1 *operationPb.FeedFormulaUsageRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FeedFormulaUsage", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// FeedFormulaUsage indicates an expected call of FeedFormulaUsage.
func (mr *MockKptServiceMockRecorder) FeedFormulaUsage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedFormulaUsage", reflect.TypeOf((*MockKptService)(nil).FeedFormulaUsage), arg0, arg1)
}

// FeedMixedAndTmrName mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) FeedMixedAndTmrName(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeedMixedAndTmrName", reflect.TypeOf((*MockKptService)(nil).FeedMixedAndTmrName), arg0, arg1)
}

// ForageEnumList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ForageEnumList(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForageEnumList", reflect.TypeOf((*MockKptService)(nil).ForageEnumList), arg0)
}

// ForageListSort mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ForageListSort(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForageListSort", reflect.TypeOf((*MockKptService)(nil).ForageListSort), arg0, arg1)
}

// GetDataByName mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) GetDataByName(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataByName", reflect.TypeOf((*MockKptService)(nil).GetDataByName), arg0, arg1)
}

// GetOpenId mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) GetOpenId(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenId", reflect.TypeOf((*MockKptService)(nil).GetOpenId), arg0, arg1)
}

// GetRolePermissions mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) GetRolePermissions(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolePermissions", reflect.TypeOf((*MockKptService)(nil).GetRolePermissions), arg0, arg1)
}

// GetSystemUserPermissions mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) GetSystemUserPermissions(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemUserPermissions", reflect.TypeOf((*MockKptService)(nil).GetSystemUserPermissions), arg0, arg1)
}

// GetTrainNumber mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) GetTrainNumber(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrainNumber", reflect.TypeOf((*MockKptService)(nil).GetTrainNumber), arg0, arg1)
}

// GetUserInfo mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) GetUserInfo(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserInfo", reflect.TypeOf((*MockKptService)(nil).GetUserInfo), arg0, arg1)
}

// InventoryStatisticsExcelExport mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) InventoryStatisticsExcelExport(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InventoryStatisticsExcelExport", reflect.TypeOf((*MockKptService)(nil).InventoryStatisticsExcelExport), arg0, arg1)
}

// IsShowCattleCategory mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) IsShowCattleCategory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowCattleCategory", reflect.TypeOf((*MockKptService)(nil).IsShowCattleCategory), arg0, arg1)
}

// IsShowFeedFormula mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) IsShowFeedFormula(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowFeedFormula", reflect.TypeOf((*MockKptService)(nil).IsShowFeedFormula), arg0, arg1)
}

// IsShowForage mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) IsShowForage(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowForage", reflect.TypeOf((*MockKptService)(nil).IsShowForage), arg0, arg1)
}

// IsShowForageCategory mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) IsShowForageCategory(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowForageCategory", reflect.TypeOf((*MockKptService)(nil).IsShowForageCategory), arg0, arg1)
}

// IsShowGroupPasture mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) IsShowGroupPasture(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowGroupPasture", reflect.TypeOf((*MockKptService)(nil).IsShowGroupPasture), arg0, arg1)
}

// IsShowSystemMenu mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) IsShowSystemMenu(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowSystemMenu", reflect.TypeOf((*MockKptService)(nil).IsShowSystemMenu), arg0, arg1)
}

// IsShowSystemUser mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) IsShowSystemUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowSystemUser", reflect.TypeOf((*MockKptService)(nil).IsShowSystemUser), arg0, arg1)
}

// ResetPasswordGroupPasture mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ResetPasswordGroupPasture(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPasswordGroupPasture", reflect.TypeOf((*MockKptService)(nil).ResetPasswordGroupPasture), arg0, arg1)
}

// ResetPasswordSystemUser mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) ResetPasswordSystemUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPasswordSystemUser", reflect.TypeOf((*MockKptService)(nil).ResetPasswordSystemUser), arg0, arg1)
}

// SearchAccuracyAggStatistics mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchAccuracyAggStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchAccuracyAggStatistics", reflect.TypeOf((*MockKptService)(nil).SearchAccuracyAggStatistics), arg0, arg1)
}

// SearchAnalysisAccuracy mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchAnalysisAccuracy(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchAnalysisAccuracy", reflect.TypeOf((*MockKptService)(nil).SearchAnalysisAccuracy), arg0, arg1)
}

// SearchCattleCategoryList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchCattleCategoryList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCattleCategoryList", reflect.TypeOf((*MockKptService)(nil).SearchCattleCategoryList), arg0, arg1)
}

// SearchFeedFormulaList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchFeedFormulaList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchFeedFormulaList", reflect.TypeOf((*MockKptService)(nil).SearchFeedFormulaList), arg0, arg1)
}

// SearchFeedStatistics mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchFeedStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchFeedStatistics", reflect.TypeOf((*MockKptService)(nil).SearchFeedStatistics), arg0, arg1)
}

// SearchForageCategoryList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchForageCategoryList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchForageCategoryList", reflect.TypeOf((*MockKptService)(nil).SearchForageCategoryList), arg0, arg1)
}

// SearchForageList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchForageList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchForageList", reflect.TypeOf((*MockKptService)(nil).SearchForageList), arg0, arg1)
}

// SearchFormulaEstimateList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchFormulaEstimateList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchFormulaEstimateList", reflect.TypeOf((*MockKptService)(nil).SearchFormulaEstimateList), arg0, arg1)
}

// SearchGroupPastureList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchGroupPastureList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchGroupPastureList", reflect.TypeOf((*MockKptService)(nil).SearchGroupPastureList), arg0, arg1)
}

// SearchInventoryStatistics mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchInventoryStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchInventoryStatistics", reflect.TypeOf((*MockKptService)(nil).SearchInventoryStatistics), arg0, arg1)
}

// SearchMixFeedStatistics mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchMixFeedStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchMixFeedStatistics", reflect.TypeOf((*MockKptService)(nil).SearchMixFeedStatistics), arg0, arg1)
}

// SearchMobileList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchMobileList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchMobileList", reflect.TypeOf((*MockKptService)(nil).SearchMobileList), arg0, arg1)
}

// SearchPriceStatistics mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchPriceStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchPriceStatistics", reflect.TypeOf((*MockKptService)(nil).SearchPriceStatistics), arg0, arg1)
}

// SearchProcessAnalysis mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchProcessAnalysis(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProcessAnalysis", reflect.TypeOf((*MockKptService)(nil).SearchProcessAnalysis), arg0, arg1)
}

// SearchSprinkleStatistics mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchSprinkleStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSprinkleStatistics", reflect.TypeOf((*MockKptService)(nil).SearchSprinkleStatistics), arg0, arg1)
}

// SearchSystemMenuList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchSystemMenuList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemMenuList", reflect.TypeOf((*MockKptService)(nil).SearchSystemMenuList), arg0, arg1)
}

// SearchSystemRoleList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchSystemRoleList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemRoleList", reflect.TypeOf((*MockKptService)(nil).SearchSystemRoleList), arg0, arg1)
}

// SearchSystemUserList mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchSystemUserList(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemUserList", reflect.TypeOf((*MockKptService)(nil).SearchSystemUserList), arg0, arg1)
}

// SearchUserMaterialsStatistics mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SearchUserMaterialsStatistics(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchUserMaterialsStatistics", reflect.TypeOf((*MockKptService)(nil).SearchUserMaterialsStatistics), arg0, arg1)
}

// SmallMaterial mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SmallMaterial(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SmallMaterial", reflect.TypeOf((*MockKptService)(nil).SmallMaterial), arg0, arg1)
}

// SprinkleFeedTime mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) SprinkleFeedTime(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SprinkleFeedTime", reflect.TypeOf((*MockKptService)(nil).SprinkleFeedTime), arg0, arg1)
}

// TopPasture mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) TopPasture(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopPasture", reflect.TypeOf((*MockKptService)(nil).TopPasture), arg0, arg1)
}

// UserMaterialsStatisticsExcelExport mocks base method.
func (m *MockKptService) 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 *MockKptServiceMockRecorder) UserMaterialsStatisticsExcelExport(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserMaterialsStatisticsExcelExport", reflect.TypeOf((*MockKptService)(nil).UserMaterialsStatisticsExcelExport), arg0, arg1)
}