mock: update

model/neck_active_habit.go

@@ -124,8 +124,6 @@ func (n NeckActiveHabitSlice) ToPB(curveName, startDateTime, endDateTime string)
 		EventList:        make(map[string][]string),
 		EventMap:         make(map[pasturePb.EventType_Kind]string),
 	}
-
-	//dayTimeRange, _ := util.GetDaysBetween(startDateTime, endDateTime)
 	initFrameId := int32(0)
 	dateFrameMap := make(map[string][]int32)
 	for _, v := range n {
@@ -186,14 +184,12 @@ func (n NeckActiveHabitSlice) ToPB(curveName, startDateTime, endDateTime string)
 		case "chew": // 咀嚼
 			res.OriginalDateList = append(res.OriginalDateList, v.FilterChew)
 			res.ChangeDateList = append(res.ChangeDateList, v.ChangeChew)
-			res.SumDateList = append(res.SumDateList, 0)
 		case "immobility": // 静止
 			res.OriginalDateList = append(res.OriginalDateList, 120-v.Active)
 			res.SumDateList = append(res.SumDateList, 60*24-v.SumActive)
 		}
 		initFrameId++
 	}
-
 	return res
 }
 

module/backend/cow.go

@@ -169,8 +169,7 @@ func (s *StoreEntry) BehaviorCurve(ctx context.Context, req *pasturePb.CowBehavi
 	if err = s.DB.Table(new(model.NeckActiveHabit).TableName()).
 		Where("neck_ring_number = ?", cowInfo.NeckRingNumber).
 		Where("pasture_id = ?", currentUser.PastureId).
-		Where("heat_date >= ?", startDataTime).
-		Where("heat_date <= ?", endDataTime).
+		Where("heat_date BETWEEN ? AND ?", startDataTime, endDataTime).
 		Order("heat_date, frameid").
 		Find(&neckActiveHabitList).Error; err != nil {
 		return nil, xerr.WithStack(err)
@@ -182,8 +181,7 @@ func (s *StoreEntry) BehaviorCurve(ctx context.Context, req *pasturePb.CowBehavi
 	if err = s.DB.Table(eventLog.TableName()).
 		Where("cow_id = ?", cowInfo.Id).
 		Where("pasture_id = ?", currentUser.PastureId).
-		Where("event_at >= ?", nowDayZero-(30*86400)).
-		Where("event_at <= ?", nowDayZero+86400).
+		Where("event_at BETWEEN ? AND ?", nowDayZero-(30*86400), nowDayZero+86400).
 		Order("event_at").
 		Find(&eventLogList).Error; err != nil {
 		return nil, xerr.WithStack(err)

module/backend/mock/AnalyseService.go

@@ -0,0 +1,217 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: AnalyseService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	model "kpt-pasture/model"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockAnalyseService is a mock of AnalyseService interface.
+type MockAnalyseService struct {
+	ctrl     *gomock.Controller
+	recorder *MockAnalyseServiceMockRecorder
+}
+
+// MockAnalyseServiceMockRecorder is the mock recorder for MockAnalyseService.
+type MockAnalyseServiceMockRecorder struct {
+	mock *MockAnalyseService
+}
+
+// NewMockAnalyseService creates a new mock instance.
+func NewMockAnalyseService(ctrl *gomock.Controller) *MockAnalyseService {
+	mock := &MockAnalyseService{ctrl: ctrl}
+	mock.recorder = &MockAnalyseServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockAnalyseService) EXPECT() *MockAnalyseServiceMockRecorder {
+	return m.recorder
+}
+
+// AbortionRate mocks base method.
+func (m *MockAnalyseService) AbortionRate(arg0 context.Context, arg1 *cowPb.AbortionRateRequest) (*cowPb.AbortionRateResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AbortionRate", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.AbortionRateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AbortionRate indicates an expected call of AbortionRate.
+func (mr *MockAnalyseServiceMockRecorder) AbortionRate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionRate", reflect.TypeOf((*MockAnalyseService)(nil).AbortionRate), arg0, arg1)
+}
+
+// CalvingReport mocks base method.
+func (m *MockAnalyseService) CalvingReport(arg0 context.Context, arg1 *cowPb.CalvingReportRequest) (*cowPb.CalvingReportResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CalvingReport", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.CalvingReportResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CalvingReport indicates an expected call of CalvingReport.
+func (mr *MockAnalyseServiceMockRecorder) CalvingReport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalvingReport", reflect.TypeOf((*MockAnalyseService)(nil).CalvingReport), arg0, arg1)
+}
+
+// DiseaseCureReport mocks base method.
+func (m *MockAnalyseService) DiseaseCureReport(arg0 context.Context, arg1 *cowPb.DiseaseCureRateRequest) (*cowPb.DiseaseCureRateResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DiseaseCureReport", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.DiseaseCureRateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DiseaseCureReport indicates an expected call of DiseaseCureReport.
+func (mr *MockAnalyseServiceMockRecorder) DiseaseCureReport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseCureReport", reflect.TypeOf((*MockAnalyseService)(nil).DiseaseCureReport), arg0, arg1)
+}
+
+// GrowthCurve mocks base method.
+func (m *MockAnalyseService) GrowthCurve(arg0 context.Context, arg1 *cowPb.SearchGrowthCurvesRequest) (*cowPb.GrowthCurvesResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GrowthCurve", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.GrowthCurvesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GrowthCurve indicates an expected call of GrowthCurve.
+func (mr *MockAnalyseServiceMockRecorder) GrowthCurve(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrowthCurve", reflect.TypeOf((*MockAnalyseService)(nil).GrowthCurve), arg0, arg1)
+}
+
+// MatingTimely mocks base method.
+func (m *MockAnalyseService) MatingTimely(arg0 context.Context, arg1 *cowPb.MatingTimelyRequest) (*model.MatingTimelyResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MatingTimely", arg0, arg1)
+	ret0, _ := ret[0].(*model.MatingTimelyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MatingTimely indicates an expected call of MatingTimely.
+func (mr *MockAnalyseServiceMockRecorder) MatingTimely(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatingTimely", reflect.TypeOf((*MockAnalyseService)(nil).MatingTimely), arg0, arg1)
+}
+
+// MultipleFactorAnalysis mocks base method.
+func (m *MockAnalyseService) MultipleFactorAnalysis(arg0 context.Context, arg1 *cowPb.MultiFactorPregnancyRateRequest) (*model.MultiFactorPregnancyRateResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MultipleFactorAnalysis", arg0, arg1)
+	ret0, _ := ret[0].(*model.MultiFactorPregnancyRateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MultipleFactorAnalysis indicates an expected call of MultipleFactorAnalysis.
+func (mr *MockAnalyseServiceMockRecorder) MultipleFactorAnalysis(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultipleFactorAnalysis", reflect.TypeOf((*MockAnalyseService)(nil).MultipleFactorAnalysis), arg0, arg1)
+}
+
+// PenWeight mocks base method.
+func (m *MockAnalyseService) PenWeight(arg0 context.Context, arg1 *cowPb.PenWeightRequest, arg2 *cowPb.PaginationModel) (*cowPb.PenWeightResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PenWeight", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.PenWeightResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PenWeight indicates an expected call of PenWeight.
+func (mr *MockAnalyseServiceMockRecorder) PenWeight(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PenWeight", reflect.TypeOf((*MockAnalyseService)(nil).PenWeight), arg0, arg1, arg2)
+}
+
+// PregnancyReport mocks base method.
+func (m *MockAnalyseService) PregnancyReport(arg0 context.Context, arg1 *cowPb.PregnancyReportRequest, arg2 *cowPb.PaginationModel) (*cowPb.PregnancyReportResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PregnancyReport", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.PregnancyReportResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PregnancyReport indicates an expected call of PregnancyReport.
+func (mr *MockAnalyseServiceMockRecorder) PregnancyReport(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnancyReport", reflect.TypeOf((*MockAnalyseService)(nil).PregnancyReport), arg0, arg1, arg2)
+}
+
+// SaleCowReport mocks base method.
+func (m *MockAnalyseService) SaleCowReport(arg0 context.Context, arg1 *cowPb.SaleCowReportRequest) (*cowPb.SaleCowReportResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SaleCowReport", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.SaleCowReportResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SaleCowReport indicates an expected call of SaleCowReport.
+func (mr *MockAnalyseServiceMockRecorder) SaleCowReport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaleCowReport", reflect.TypeOf((*MockAnalyseService)(nil).SaleCowReport), arg0, arg1)
+}
+
+// SingleFactorInfantSurvivalRateAnalysis mocks base method.
+func (m *MockAnalyseService) SingleFactorInfantSurvivalRateAnalysis(arg0 context.Context, arg1 *cowPb.SingleFactorPregnancyRateRequest) (*cowPb.SingleFactorPregnancyRateResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SingleFactorInfantSurvivalRateAnalysis", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.SingleFactorPregnancyRateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SingleFactorInfantSurvivalRateAnalysis indicates an expected call of SingleFactorInfantSurvivalRateAnalysis.
+func (mr *MockAnalyseServiceMockRecorder) SingleFactorInfantSurvivalRateAnalysis(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SingleFactorInfantSurvivalRateAnalysis", reflect.TypeOf((*MockAnalyseService)(nil).SingleFactorInfantSurvivalRateAnalysis), arg0, arg1)
+}
+
+// TwentyOnePregnantRate mocks base method.
+func (m *MockAnalyseService) TwentyOnePregnantRate(arg0 context.Context, arg1 *cowPb.TwentyOnePregnantRateRequest) (*cowPb.TwentyOnePregnantRateResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TwentyOnePregnantRate", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.TwentyOnePregnantRateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TwentyOnePregnantRate indicates an expected call of TwentyOnePregnantRate.
+func (mr *MockAnalyseServiceMockRecorder) TwentyOnePregnantRate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TwentyOnePregnantRate", reflect.TypeOf((*MockAnalyseService)(nil).TwentyOnePregnantRate), arg0, arg1)
+}
+
+// WeightRange mocks base method.
+func (m *MockAnalyseService) WeightRange(arg0 context.Context, arg1 *cowPb.WeightRangeRequest) (*cowPb.WeightRangeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WeightRange", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.WeightRangeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WeightRange indicates an expected call of WeightRange.
+func (mr *MockAnalyseServiceMockRecorder) WeightRange(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeightRange", reflect.TypeOf((*MockAnalyseService)(nil).WeightRange), arg0, arg1)
+}

module/backend/mock/ConfigDataService.go

@@ -0,0 +1,231 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: ConfigDataService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockConfigDataService is a mock of ConfigDataService interface.
+type MockConfigDataService struct {
+	ctrl     *gomock.Controller
+	recorder *MockConfigDataServiceMockRecorder
+}
+
+// MockConfigDataServiceMockRecorder is the mock recorder for MockConfigDataService.
+type MockConfigDataServiceMockRecorder struct {
+	mock *MockConfigDataService
+}
+
+// NewMockConfigDataService creates a new mock instance.
+func NewMockConfigDataService(ctrl *gomock.Controller) *MockConfigDataService {
+	mock := &MockConfigDataService{ctrl: ctrl}
+	mock.recorder = &MockConfigDataServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockConfigDataService) EXPECT() *MockConfigDataServiceMockRecorder {
+	return m.recorder
+}
+
+// BarnListOptions mocks base method.
+func (m *MockConfigDataService) BarnListOptions(arg0 context.Context, arg1 int, arg2 string) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BarnListOptions", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BarnListOptions indicates an expected call of BarnListOptions.
+func (mr *MockConfigDataServiceMockRecorder) BarnListOptions(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BarnListOptions", reflect.TypeOf((*MockConfigDataService)(nil).BarnListOptions), arg0, arg1, arg2)
+}
+
+// BarnTypeOptions mocks base method.
+func (m *MockConfigDataService) BarnTypeOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BarnTypeOptions", arg0)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BarnTypeOptions indicates an expected call of BarnTypeOptions.
+func (mr *MockConfigDataServiceMockRecorder) BarnTypeOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BarnTypeOptions", reflect.TypeOf((*MockConfigDataService)(nil).BarnTypeOptions), arg0)
+}
+
+// BreedStatusOptions mocks base method.
+func (m *MockConfigDataService) BreedStatusOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BreedStatusOptions", arg0)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BreedStatusOptions indicates an expected call of BreedStatusOptions.
+func (mr *MockConfigDataServiceMockRecorder) BreedStatusOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BreedStatusOptions", reflect.TypeOf((*MockConfigDataService)(nil).BreedStatusOptions), arg0)
+}
+
+// BullOptions mocks base method.
+func (m *MockConfigDataService) BullOptions(arg0 context.Context) (*cowPb.BullOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BullOptions", arg0)
+	ret0, _ := ret[0].(*cowPb.BullOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BullOptions indicates an expected call of BullOptions.
+func (mr *MockConfigDataServiceMockRecorder) BullOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BullOptions", reflect.TypeOf((*MockConfigDataService)(nil).BullOptions), arg0)
+}
+
+// CowKindOptions mocks base method.
+func (m *MockConfigDataService) CowKindOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowKindOptions", arg0)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowKindOptions indicates an expected call of CowKindOptions.
+func (mr *MockConfigDataServiceMockRecorder) CowKindOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowKindOptions", reflect.TypeOf((*MockConfigDataService)(nil).CowKindOptions), arg0)
+}
+
+// CowSourceOptions mocks base method.
+func (m *MockConfigDataService) CowSourceOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowSourceOptions", arg0)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowSourceOptions indicates an expected call of CowSourceOptions.
+func (mr *MockConfigDataServiceMockRecorder) CowSourceOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowSourceOptions", reflect.TypeOf((*MockConfigDataService)(nil).CowSourceOptions), arg0)
+}
+
+// CowTransferPenReasonOptions mocks base method.
+func (m *MockConfigDataService) CowTransferPenReasonOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowTransferPenReasonOptions", arg0)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowTransferPenReasonOptions indicates an expected call of CowTransferPenReasonOptions.
+func (mr *MockConfigDataServiceMockRecorder) CowTransferPenReasonOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowTransferPenReasonOptions", reflect.TypeOf((*MockConfigDataService)(nil).CowTransferPenReasonOptions), arg0)
+}
+
+// CowTypeOptions mocks base method.
+func (m *MockConfigDataService) CowTypeOptions(arg0 context.Context, arg1, arg2 string) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowTypeOptions", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowTypeOptions indicates an expected call of CowTypeOptions.
+func (mr *MockConfigDataServiceMockRecorder) CowTypeOptions(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowTypeOptions", reflect.TypeOf((*MockConfigDataService)(nil).CowTypeOptions), arg0, arg1, arg2)
+}
+
+// DiseaseOptions mocks base method.
+func (m *MockConfigDataService) DiseaseOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DiseaseOptions", arg0)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DiseaseOptions indicates an expected call of DiseaseOptions.
+func (mr *MockConfigDataServiceMockRecorder) DiseaseOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseOptions", reflect.TypeOf((*MockConfigDataService)(nil).DiseaseOptions), arg0)
+}
+
+// DiseaseTypeOptions mocks base method.
+func (m *MockConfigDataService) DiseaseTypeOptions(arg0 context.Context, arg1 string) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DiseaseTypeOptions", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DiseaseTypeOptions indicates an expected call of DiseaseTypeOptions.
+func (mr *MockConfigDataServiceMockRecorder) DiseaseTypeOptions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseTypeOptions", reflect.TypeOf((*MockConfigDataService)(nil).DiseaseTypeOptions), arg0, arg1)
+}
+
+// PrescriptionOptions mocks base method.
+func (m *MockConfigDataService) PrescriptionOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrescriptionOptions", arg0)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PrescriptionOptions indicates an expected call of PrescriptionOptions.
+func (mr *MockConfigDataServiceMockRecorder) PrescriptionOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrescriptionOptions", reflect.TypeOf((*MockConfigDataService)(nil).PrescriptionOptions), arg0)
+}
+
+// SystemBaseConfigOptions mocks base method.
+func (m *MockConfigDataService) SystemBaseConfigOptions(arg0 context.Context, arg1, arg2 string) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemBaseConfigOptions", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SystemBaseConfigOptions indicates an expected call of SystemBaseConfigOptions.
+func (mr *MockConfigDataServiceMockRecorder) SystemBaseConfigOptions(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemBaseConfigOptions", reflect.TypeOf((*MockConfigDataService)(nil).SystemBaseConfigOptions), arg0, arg1, arg2)
+}
+
+// SystemUserOptions mocks base method.
+func (m *MockConfigDataService) SystemUserOptions(arg0 context.Context, arg1 int) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemUserOptions", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SystemUserOptions indicates an expected call of SystemUserOptions.
+func (mr *MockConfigDataServiceMockRecorder) SystemUserOptions(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemUserOptions", reflect.TypeOf((*MockConfigDataService)(nil).SystemUserOptions), arg0, arg1)
+}

module/backend/mock/CowService.go

@@ -0,0 +1,97 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: CowService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	model "kpt-pasture/model"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockCowService is a mock of CowService interface.
+type MockCowService struct {
+	ctrl     *gomock.Controller
+	recorder *MockCowServiceMockRecorder
+}
+
+// MockCowServiceMockRecorder is the mock recorder for MockCowService.
+type MockCowServiceMockRecorder struct {
+	mock *MockCowService
+}
+
+// NewMockCowService creates a new mock instance.
+func NewMockCowService(ctrl *gomock.Controller) *MockCowService {
+	mock := &MockCowService{ctrl: ctrl}
+	mock.recorder = &MockCowServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCowService) EXPECT() *MockCowServiceMockRecorder {
+	return m.recorder
+}
+
+// BehaviorCurve mocks base method.
+func (m *MockCowService) BehaviorCurve(arg0 context.Context, arg1 *cowPb.CowBehaviorCurveRequest) (*model.CowBehaviorCurveResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BehaviorCurve", arg0, arg1)
+	ret0, _ := ret[0].(*model.CowBehaviorCurveResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BehaviorCurve indicates an expected call of BehaviorCurve.
+func (mr *MockCowServiceMockRecorder) BehaviorCurve(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BehaviorCurve", reflect.TypeOf((*MockCowService)(nil).BehaviorCurve), arg0, arg1)
+}
+
+// CowGrowthCurve mocks base method.
+func (m *MockCowService) CowGrowthCurve(arg0 context.Context, arg1 *cowPb.CowGrowthCurveRequest) (*cowPb.CowGrowthCurveResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowGrowthCurve", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.CowGrowthCurveResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowGrowthCurve indicates an expected call of CowGrowthCurve.
+func (mr *MockCowServiceMockRecorder) CowGrowthCurve(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowGrowthCurve", reflect.TypeOf((*MockCowService)(nil).CowGrowthCurve), arg0, arg1)
+}
+
+// EventList mocks base method.
+func (m *MockCowService) EventList(arg0 context.Context, arg1 *cowPb.SearchCowEventListRequest, arg2 *cowPb.PaginationModel) (*cowPb.CowEventListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EventList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.CowEventListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EventList indicates an expected call of EventList.
+func (mr *MockCowServiceMockRecorder) EventList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventList", reflect.TypeOf((*MockCowService)(nil).EventList), arg0, arg1, arg2)
+}
+
+// List mocks base method.
+func (m *MockCowService) List(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchCowListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchCowListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockCowServiceMockRecorder) List(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockCowService)(nil).List), arg0, arg1, arg2)
+}

module/backend/mock/DashboardService.go

@@ -0,0 +1,51 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: DashboardService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockDashboardService is a mock of DashboardService interface.
+type MockDashboardService struct {
+	ctrl     *gomock.Controller
+	recorder *MockDashboardServiceMockRecorder
+}
+
+// MockDashboardServiceMockRecorder is the mock recorder for MockDashboardService.
+type MockDashboardServiceMockRecorder struct {
+	mock *MockDashboardService
+}
+
+// NewMockDashboardService creates a new mock instance.
+func NewMockDashboardService(ctrl *gomock.Controller) *MockDashboardService {
+	mock := &MockDashboardService{ctrl: ctrl}
+	mock.recorder = &MockDashboardServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDashboardService) EXPECT() *MockDashboardServiceMockRecorder {
+	return m.recorder
+}
+
+// Bar mocks base method.
+func (m *MockDashboardService) Bar(arg0 context.Context) (*cowPb.BarCowStructResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Bar", arg0)
+	ret0, _ := ret[0].(*cowPb.BarCowStructResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Bar indicates an expected call of Bar.
+func (mr *MockDashboardServiceMockRecorder) Bar(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bar", reflect.TypeOf((*MockDashboardService)(nil).Bar), arg0)
+}

module/backend/mock/EventService.go

@@ -0,0 +1,482 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: EventService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	model "kpt-pasture/model"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockEventService is a mock of EventService interface.
+type MockEventService struct {
+	ctrl     *gomock.Controller
+	recorder *MockEventServiceMockRecorder
+}
+
+// MockEventServiceMockRecorder is the mock recorder for MockEventService.
+type MockEventServiceMockRecorder struct {
+	mock *MockEventService
+}
+
+// NewMockEventService creates a new mock instance.
+func NewMockEventService(ctrl *gomock.Controller) *MockEventService {
+	mock := &MockEventService{ctrl: ctrl}
+	mock.recorder = &MockEventServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockEventService) EXPECT() *MockEventServiceMockRecorder {
+	return m.recorder
+}
+
+// AbortionCreate mocks base method.
+func (m *MockEventService) AbortionCreate(arg0 context.Context, arg1 *cowPb.EventAbortionRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AbortionCreate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AbortionCreate indicates an expected call of AbortionCreate.
+func (mr *MockEventServiceMockRecorder) AbortionCreate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionCreate", reflect.TypeOf((*MockEventService)(nil).AbortionCreate), arg0, arg1)
+}
+
+// AbortionCreateBatch mocks base method.
+func (m *MockEventService) AbortionCreateBatch(arg0 context.Context, arg1 *cowPb.EventAbortionBatch) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AbortionCreateBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AbortionCreateBatch indicates an expected call of AbortionCreateBatch.
+func (mr *MockEventServiceMockRecorder) AbortionCreateBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionCreateBatch", reflect.TypeOf((*MockEventService)(nil).AbortionCreateBatch), arg0, arg1)
+}
+
+// AbortionList mocks base method.
+func (m *MockEventService) AbortionList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.EventAbortionResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AbortionList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.EventAbortionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AbortionList indicates an expected call of AbortionList.
+func (mr *MockEventServiceMockRecorder) AbortionList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionList", reflect.TypeOf((*MockEventService)(nil).AbortionList), arg0, arg1, arg2)
+}
+
+// BodyScoreList mocks base method.
+func (m *MockEventService) BodyScoreList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBodyScoreEventResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BodyScoreList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBodyScoreEventResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BodyScoreList indicates an expected call of BodyScoreList.
+func (mr *MockEventServiceMockRecorder) BodyScoreList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BodyScoreList", reflect.TypeOf((*MockEventService)(nil).BodyScoreList), arg0, arg1, arg2)
+}
+
+// CalvingCreate mocks base method.
+func (m *MockEventService) CalvingCreate(arg0 context.Context, arg1 *cowPb.EventCalving) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CalvingCreate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CalvingCreate indicates an expected call of CalvingCreate.
+func (mr *MockEventServiceMockRecorder) CalvingCreate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalvingCreate", reflect.TypeOf((*MockEventService)(nil).CalvingCreate), arg0, arg1)
+}
+
+// CalvingList mocks base method.
+func (m *MockEventService) CalvingList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchLavingEventResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CalvingList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchLavingEventResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CalvingList indicates an expected call of CalvingList.
+func (mr *MockEventServiceMockRecorder) CalvingList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalvingList", reflect.TypeOf((*MockEventService)(nil).CalvingList), arg0, arg1, arg2)
+}
+
+// CowDiseaseCreate mocks base method.
+func (m *MockEventService) CowDiseaseCreate(arg0 context.Context, arg1 *cowPb.EventCowDiseaseRequest, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowDiseaseCreate", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CowDiseaseCreate indicates an expected call of CowDiseaseCreate.
+func (mr *MockEventServiceMockRecorder) CowDiseaseCreate(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseCreate", reflect.TypeOf((*MockEventService)(nil).CowDiseaseCreate), arg0, arg1, arg2)
+}
+
+// CowDiseaseCurable mocks base method.
+func (m *MockEventService) CowDiseaseCurable(arg0 context.Context, arg1 *cowPb.EventCowCurableRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowDiseaseCurable", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CowDiseaseCurable indicates an expected call of CowDiseaseCurable.
+func (mr *MockEventServiceMockRecorder) CowDiseaseCurable(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseCurable", reflect.TypeOf((*MockEventService)(nil).CowDiseaseCurable), arg0, arg1)
+}
+
+// CowDiseaseDiagnose mocks base method.
+func (m *MockEventService) CowDiseaseDiagnose(arg0 context.Context, arg1 *cowPb.CowDiagnosedRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowDiseaseDiagnose", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CowDiseaseDiagnose indicates an expected call of CowDiseaseDiagnose.
+func (mr *MockEventServiceMockRecorder) CowDiseaseDiagnose(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseDiagnose", reflect.TypeOf((*MockEventService)(nil).CowDiseaseDiagnose), arg0, arg1)
+}
+
+// CowDiseaseTreatment mocks base method.
+func (m *MockEventService) CowDiseaseTreatment(arg0 context.Context, arg1 *cowPb.CowTreatmentRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowDiseaseTreatment", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CowDiseaseTreatment indicates an expected call of CowDiseaseTreatment.
+func (mr *MockEventServiceMockRecorder) CowDiseaseTreatment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseTreatment", reflect.TypeOf((*MockEventService)(nil).CowDiseaseTreatment), arg0, arg1)
+}
+
+// CowDiseaseTreatmentDetail mocks base method.
+func (m *MockEventService) CowDiseaseTreatmentDetail(arg0 context.Context, arg1 *cowPb.EventCowTreatmentDetailRequest, arg2 *cowPb.PaginationModel) (*cowPb.EventCowTreatmentDetailResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowDiseaseTreatmentDetail", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.EventCowTreatmentDetailResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowDiseaseTreatmentDetail indicates an expected call of CowDiseaseTreatmentDetail.
+func (mr *MockEventServiceMockRecorder) CowDiseaseTreatmentDetail(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseTreatmentDetail", reflect.TypeOf((*MockEventService)(nil).CowDiseaseTreatmentDetail), arg0, arg1, arg2)
+}
+
+// CowEarNumberUpdate mocks base method.
+func (m *MockEventService) CowEarNumberUpdate(arg0 context.Context, arg1 *cowPb.EventReplaceEarNumber) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowEarNumberUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CowEarNumberUpdate indicates an expected call of CowEarNumberUpdate.
+func (mr *MockEventServiceMockRecorder) CowEarNumberUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowEarNumberUpdate", reflect.TypeOf((*MockEventService)(nil).CowEarNumberUpdate), arg0, arg1)
+}
+
+// CreateBodyScore mocks base method.
+func (m *MockEventService) CreateBodyScore(arg0 context.Context, arg1 *cowPb.BodyScoreEventRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateBodyScore", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateBodyScore indicates an expected call of CreateBodyScore.
+func (mr *MockEventServiceMockRecorder) CreateBodyScore(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBodyScore", reflect.TypeOf((*MockEventService)(nil).CreateBodyScore), arg0, arg1)
+}
+
+// CreateEnter mocks base method.
+func (m *MockEventService) CreateEnter(arg0 context.Context, arg1 *cowPb.EventEnterRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateEnter", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateEnter indicates an expected call of CreateEnter.
+func (mr *MockEventServiceMockRecorder) CreateEnter(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEnter", reflect.TypeOf((*MockEventService)(nil).CreateEnter), arg0, arg1)
+}
+
+// CreateGroupTransfer mocks base method.
+func (m *MockEventService) CreateGroupTransfer(arg0 context.Context, arg1 *cowPb.TransferGroupEventRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateGroupTransfer", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateGroupTransfer indicates an expected call of CreateGroupTransfer.
+func (mr *MockEventServiceMockRecorder) CreateGroupTransfer(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroupTransfer", reflect.TypeOf((*MockEventService)(nil).CreateGroupTransfer), arg0, arg1)
+}
+
+// DepartureBatch mocks base method.
+func (m *MockEventService) DepartureBatch(arg0 context.Context, arg1 *cowPb.EventDepartureBatch) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DepartureBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DepartureBatch indicates an expected call of DepartureBatch.
+func (mr *MockEventServiceMockRecorder) DepartureBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DepartureBatch", reflect.TypeOf((*MockEventService)(nil).DepartureBatch), arg0, arg1)
+}
+
+// DiseaseSuggestPrescription mocks base method.
+func (m *MockEventService) DiseaseSuggestPrescription(arg0 context.Context, arg1 int64) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DiseaseSuggestPrescription", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DiseaseSuggestPrescription indicates an expected call of DiseaseSuggestPrescription.
+func (mr *MockEventServiceMockRecorder) DiseaseSuggestPrescription(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseSuggestPrescription", reflect.TypeOf((*MockEventService)(nil).DiseaseSuggestPrescription), arg0, arg1)
+}
+
+// EnterList mocks base method.
+func (m *MockEventService) EnterList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchEnterEventResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EnterList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchEnterEventResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EnterList indicates an expected call of EnterList.
+func (mr *MockEventServiceMockRecorder) EnterList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterList", reflect.TypeOf((*MockEventService)(nil).EnterList), arg0, arg1, arg2)
+}
+
+// EstrusBatchMating mocks base method.
+func (m *MockEventService) EstrusBatchMating(arg0 context.Context, arg1 *cowPb.EventEstrus) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EstrusBatchMating", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// EstrusBatchMating indicates an expected call of EstrusBatchMating.
+func (mr *MockEventServiceMockRecorder) EstrusBatchMating(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstrusBatchMating", reflect.TypeOf((*MockEventService)(nil).EstrusBatchMating), arg0, arg1)
+}
+
+// GroupTransferList mocks base method.
+func (m *MockEventService) GroupTransferList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchTransferGroupEventResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GroupTransferList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchTransferGroupEventResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GroupTransferList indicates an expected call of GroupTransferList.
+func (mr *MockEventServiceMockRecorder) GroupTransferList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupTransferList", reflect.TypeOf((*MockEventService)(nil).GroupTransferList), arg0, arg1, arg2)
+}
+
+// MatingCreate mocks base method.
+func (m *MockEventService) MatingCreate(arg0 context.Context, arg1 *cowPb.EventMating) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MatingCreate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// MatingCreate indicates an expected call of MatingCreate.
+func (mr *MockEventServiceMockRecorder) MatingCreate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatingCreate", reflect.TypeOf((*MockEventService)(nil).MatingCreate), arg0, arg1)
+}
+
+// MatingList mocks base method.
+func (m *MockEventService) MatingList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.MatingEventResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MatingList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.MatingEventResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MatingList indicates an expected call of MatingList.
+func (mr *MockEventServiceMockRecorder) MatingList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatingList", reflect.TypeOf((*MockEventService)(nil).MatingList), arg0, arg1, arg2)
+}
+
+// PregnantCheckCreateBatch mocks base method.
+func (m *MockEventService) PregnantCheckCreateBatch(arg0 context.Context, arg1 *cowPb.EventPregnantCheckBatch) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PregnantCheckCreateBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PregnantCheckCreateBatch indicates an expected call of PregnantCheckCreateBatch.
+func (mr *MockEventServiceMockRecorder) PregnantCheckCreateBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnantCheckCreateBatch", reflect.TypeOf((*MockEventService)(nil).PregnantCheckCreateBatch), arg0, arg1)
+}
+
+// PregnantCheckList mocks base method.
+func (m *MockEventService) PregnantCheckList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.PregnantCheckEventResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PregnantCheckList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.PregnantCheckEventResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PregnantCheckList indicates an expected call of PregnantCheckList.
+func (mr *MockEventServiceMockRecorder) PregnantCheckList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnantCheckList", reflect.TypeOf((*MockEventService)(nil).PregnantCheckList), arg0, arg1, arg2)
+}
+
+// SameTimeBatch mocks base method.
+func (m *MockEventService) SameTimeBatch(arg0 context.Context, arg1 *cowPb.EventSameTimeBatch) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SameTimeBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SameTimeBatch indicates an expected call of SameTimeBatch.
+func (mr *MockEventServiceMockRecorder) SameTimeBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeBatch", reflect.TypeOf((*MockEventService)(nil).SameTimeBatch), arg0, arg1)
+}
+
+// SameTimeCreate mocks base method.
+func (m *MockEventService) SameTimeCreate(arg0 context.Context, arg1 *cowPb.EventSameTime) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SameTimeCreate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SameTimeCreate indicates an expected call of SameTimeCreate.
+func (mr *MockEventServiceMockRecorder) SameTimeCreate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeCreate", reflect.TypeOf((*MockEventService)(nil).SameTimeCreate), arg0, arg1)
+}
+
+// SameTimeList mocks base method.
+func (m *MockEventService) SameTimeList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchSameTimeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SameTimeList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchSameTimeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SameTimeList indicates an expected call of SameTimeList.
+func (mr *MockEventServiceMockRecorder) SameTimeList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeList", reflect.TypeOf((*MockEventService)(nil).SameTimeList), arg0, arg1, arg2)
+}
+
+// SubmitEventLog mocks base method.
+func (m *MockEventService) SubmitEventLog(arg0 context.Context, arg1 *model.SystemUser, arg2 *model.Cow, arg3 cowPb.EventType_Kind, arg4 cowPb.ExposeEstrusType_Kind, arg5 interface{}) *model.EventCowLog {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubmitEventLog", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*model.EventCowLog)
+	return ret0
+}
+
+// SubmitEventLog indicates an expected call of SubmitEventLog.
+func (mr *MockEventServiceMockRecorder) SubmitEventLog(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitEventLog", reflect.TypeOf((*MockEventService)(nil).SubmitEventLog), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// WeaningBatch mocks base method.
+func (m *MockEventService) WeaningBatch(arg0 context.Context, arg1 *cowPb.EventWeaningBatchRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WeaningBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WeaningBatch indicates an expected call of WeaningBatch.
+func (mr *MockEventServiceMockRecorder) WeaningBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeaningBatch", reflect.TypeOf((*MockEventService)(nil).WeaningBatch), arg0, arg1)
+}
+
+// WeightBatch mocks base method.
+func (m *MockEventService) WeightBatch(arg0 context.Context, arg1 *cowPb.EventWeight) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WeightBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WeightBatch indicates an expected call of WeightBatch.
+func (mr *MockEventServiceMockRecorder) WeightBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeightBatch", reflect.TypeOf((*MockEventService)(nil).WeightBatch), arg0, arg1)
+}
+
+// WeightList mocks base method.
+func (m *MockEventService) WeightList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchWeightEventResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WeightList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchWeightEventResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WeightList indicates an expected call of WeightList.
+func (mr *MockEventServiceMockRecorder) WeightList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeightList", reflect.TypeOf((*MockEventService)(nil).WeightList), arg0, arg1, arg2)
+}

module/backend/mock/GoodsService.go

@@ -0,0 +1,224 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: GoodsService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockGoodsService is a mock of GoodsService interface.
+type MockGoodsService struct {
+	ctrl     *gomock.Controller
+	recorder *MockGoodsServiceMockRecorder
+}
+
+// MockGoodsServiceMockRecorder is the mock recorder for MockGoodsService.
+type MockGoodsServiceMockRecorder struct {
+	mock *MockGoodsService
+}
+
+// NewMockGoodsService creates a new mock instance.
+func NewMockGoodsService(ctrl *gomock.Controller) *MockGoodsService {
+	mock := &MockGoodsService{ctrl: ctrl}
+	mock.recorder = &MockGoodsServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockGoodsService) EXPECT() *MockGoodsServiceMockRecorder {
+	return m.recorder
+}
+
+// DrugsCreateOrUpdate mocks base method.
+func (m *MockGoodsService) DrugsCreateOrUpdate(arg0 context.Context, arg1 *cowPb.SearchDrugsList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DrugsCreateOrUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DrugsCreateOrUpdate indicates an expected call of DrugsCreateOrUpdate.
+func (mr *MockGoodsServiceMockRecorder) DrugsCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DrugsCreateOrUpdate", reflect.TypeOf((*MockGoodsService)(nil).DrugsCreateOrUpdate), arg0, arg1)
+}
+
+// DrugsList mocks base method.
+func (m *MockGoodsService) DrugsList(arg0 context.Context, arg1 *cowPb.SearchDrugsRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchDrugsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DrugsList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchDrugsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DrugsList indicates an expected call of DrugsList.
+func (mr *MockGoodsServiceMockRecorder) DrugsList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DrugsList", reflect.TypeOf((*MockGoodsService)(nil).DrugsList), arg0, arg1, arg2)
+}
+
+// FrozenSemenCreate mocks base method.
+func (m *MockGoodsService) FrozenSemenCreate(arg0 context.Context, arg1 *cowPb.SearchFrozenSemenList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FrozenSemenCreate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FrozenSemenCreate indicates an expected call of FrozenSemenCreate.
+func (mr *MockGoodsServiceMockRecorder) FrozenSemenCreate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FrozenSemenCreate", reflect.TypeOf((*MockGoodsService)(nil).FrozenSemenCreate), arg0, arg1)
+}
+
+// FrozenSemenList mocks base method.
+func (m *MockGoodsService) FrozenSemenList(arg0 context.Context, arg1 *cowPb.FrozenSemenRequest, arg2 *cowPb.PaginationModel) (*cowPb.FrozenSemenResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FrozenSemenList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.FrozenSemenResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FrozenSemenList indicates an expected call of FrozenSemenList.
+func (mr *MockGoodsServiceMockRecorder) FrozenSemenList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FrozenSemenList", reflect.TypeOf((*MockGoodsService)(nil).FrozenSemenList), arg0, arg1, arg2)
+}
+
+// MedicalEquipmentCreateOrUpdate mocks base method.
+func (m *MockGoodsService) MedicalEquipmentCreateOrUpdate(arg0 context.Context, arg1 *cowPb.SearchMedicalEquipmentList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MedicalEquipmentCreateOrUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// MedicalEquipmentCreateOrUpdate indicates an expected call of MedicalEquipmentCreateOrUpdate.
+func (mr *MockGoodsServiceMockRecorder) MedicalEquipmentCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MedicalEquipmentCreateOrUpdate", reflect.TypeOf((*MockGoodsService)(nil).MedicalEquipmentCreateOrUpdate), arg0, arg1)
+}
+
+// MedicalEquipmentList mocks base method.
+func (m *MockGoodsService) MedicalEquipmentList(arg0 context.Context, arg1 *cowPb.SearchMedicalEquipmentRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchMedicalEquipmentResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MedicalEquipmentList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchMedicalEquipmentResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MedicalEquipmentList indicates an expected call of MedicalEquipmentList.
+func (mr *MockGoodsServiceMockRecorder) MedicalEquipmentList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MedicalEquipmentList", reflect.TypeOf((*MockGoodsService)(nil).MedicalEquipmentList), arg0, arg1, arg2)
+}
+
+// NeckRingCreateOrUpdate mocks base method.
+func (m *MockGoodsService) NeckRingCreateOrUpdate(arg0 context.Context, arg1 *cowPb.NeckRingCreateRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NeckRingCreateOrUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// NeckRingCreateOrUpdate indicates an expected call of NeckRingCreateOrUpdate.
+func (mr *MockGoodsServiceMockRecorder) NeckRingCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeckRingCreateOrUpdate", reflect.TypeOf((*MockGoodsService)(nil).NeckRingCreateOrUpdate), arg0, arg1)
+}
+
+// NeckRingList mocks base method.
+func (m *MockGoodsService) NeckRingList(arg0 context.Context, arg1 *cowPb.SearchNeckRingRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchNeckRingResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NeckRingList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchNeckRingResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NeckRingList indicates an expected call of NeckRingList.
+func (mr *MockGoodsServiceMockRecorder) NeckRingList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeckRingList", reflect.TypeOf((*MockGoodsService)(nil).NeckRingList), arg0, arg1, arg2)
+}
+
+// OutboundApply mocks base method.
+func (m *MockGoodsService) OutboundApply(arg0 context.Context, arg1 *cowPb.OutboundApplyItem) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundApply", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OutboundApply indicates an expected call of OutboundApply.
+func (mr *MockGoodsServiceMockRecorder) OutboundApply(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundApply", reflect.TypeOf((*MockGoodsService)(nil).OutboundApply), arg0, arg1)
+}
+
+// OutboundAudit mocks base method.
+func (m *MockGoodsService) OutboundAudit(arg0 context.Context, arg1 *cowPb.OutboundApplyAuditRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundAudit", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OutboundAudit indicates an expected call of OutboundAudit.
+func (mr *MockGoodsServiceMockRecorder) OutboundAudit(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundAudit", reflect.TypeOf((*MockGoodsService)(nil).OutboundAudit), arg0, arg1)
+}
+
+// OutboundDelete mocks base method.
+func (m *MockGoodsService) OutboundDelete(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundDelete", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OutboundDelete indicates an expected call of OutboundDelete.
+func (mr *MockGoodsServiceMockRecorder) OutboundDelete(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundDelete", reflect.TypeOf((*MockGoodsService)(nil).OutboundDelete), arg0, arg1)
+}
+
+// OutboundDetail mocks base method.
+func (m *MockGoodsService) OutboundDetail(arg0 context.Context, arg1 int64) (*cowPb.OutboundDetailResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundDetail", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.OutboundDetailResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// OutboundDetail indicates an expected call of OutboundDetail.
+func (mr *MockGoodsServiceMockRecorder) OutboundDetail(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundDetail", reflect.TypeOf((*MockGoodsService)(nil).OutboundDetail), arg0, arg1)
+}
+
+// OutboundList mocks base method.
+func (m *MockGoodsService) OutboundList(arg0 context.Context, arg1 *cowPb.SearchOutboundApplyRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchOutboundApplyResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchOutboundApplyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// OutboundList indicates an expected call of OutboundList.
+func (mr *MockGoodsServiceMockRecorder) OutboundList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundList", reflect.TypeOf((*MockGoodsService)(nil).OutboundList), arg0, arg1, arg2)
+}

module/backend/mock/PastureManageService.go

@@ -0,0 +1,485 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: PastureManageService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockPastureManageService is a mock of PastureManageService interface.
+type MockPastureManageService struct {
+	ctrl     *gomock.Controller
+	recorder *MockPastureManageServiceMockRecorder
+}
+
+// MockPastureManageServiceMockRecorder is the mock recorder for MockPastureManageService.
+type MockPastureManageServiceMockRecorder struct {
+	mock *MockPastureManageService
+}
+
+// NewMockPastureManageService creates a new mock instance.
+func NewMockPastureManageService(ctrl *gomock.Controller) *MockPastureManageService {
+	mock := &MockPastureManageService{ctrl: ctrl}
+	mock.recorder = &MockPastureManageServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPastureManageService) EXPECT() *MockPastureManageServiceMockRecorder {
+	return m.recorder
+}
+
+// CreateOrUpdateBarn mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateBarn(arg0 context.Context, arg1 *cowPb.SearchBarnList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateBarn", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateBarn indicates an expected call of CreateOrUpdateBarn.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateBarn(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateBarn", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateBarn), arg0, arg1)
+}
+
+// CreateOrUpdateBarnType mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateBarnType(arg0 context.Context, arg1 *cowPb.SearchBaseConfigList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateBarnType", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateBarnType indicates an expected call of CreateOrUpdateBarnType.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateBarnType(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateBarnType", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateBarnType), arg0, arg1)
+}
+
+// CreateOrUpdateBreedStatus mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateBreedStatus(arg0 context.Context, arg1 *cowPb.SearchBaseConfigList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateBreedStatus", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateBreedStatus indicates an expected call of CreateOrUpdateBreedStatus.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateBreedStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateBreedStatus", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateBreedStatus), arg0, arg1)
+}
+
+// CreateOrUpdateCowKind mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateCowKind(arg0 context.Context, arg1 *cowPb.SearchBaseConfigList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateCowKind", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateCowKind indicates an expected call of CreateOrUpdateCowKind.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateCowKind(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateCowKind", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateCowKind), arg0, arg1)
+}
+
+// CreateOrUpdateCowSource mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateCowSource(arg0 context.Context, arg1 *cowPb.SearchBaseConfigList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateCowSource", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateCowSource indicates an expected call of CreateOrUpdateCowSource.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateCowSource(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateCowSource", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateCowSource), arg0, arg1)
+}
+
+// CreateOrUpdateCowStatus mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateCowStatus(arg0 context.Context, arg1 *cowPb.SearchBaseConfigList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateCowStatus", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateCowStatus indicates an expected call of CreateOrUpdateCowStatus.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateCowStatus(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateCowStatus", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateCowStatus), arg0, arg1)
+}
+
+// CreateOrUpdateCowType mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateCowType(arg0 context.Context, arg1 *cowPb.SearchBaseConfigList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateCowType", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateCowType indicates an expected call of CreateOrUpdateCowType.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateCowType(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateCowType", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateCowType), arg0, arg1)
+}
+
+// CreateOrUpdateDisease mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateDisease(arg0 context.Context, arg1 *cowPb.SearchDiseaseList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateDisease", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateDisease indicates an expected call of CreateOrUpdateDisease.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateDisease(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateDisease", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateDisease), arg0, arg1)
+}
+
+// CreateOrUpdateDiseaseType mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateDiseaseType(arg0 context.Context, arg1 *cowPb.SearchBaseConfigList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateDiseaseType", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateDiseaseType indicates an expected call of CreateOrUpdateDiseaseType.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateDiseaseType(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateDiseaseType", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateDiseaseType), arg0, arg1)
+}
+
+// CreateOrUpdatePrescription mocks base method.
+func (m *MockPastureManageService) CreateOrUpdatePrescription(arg0 context.Context, arg1 *cowPb.PrescriptionRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdatePrescription", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdatePrescription indicates an expected call of CreateOrUpdatePrescription.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdatePrescription(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdatePrescription", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdatePrescription), arg0, arg1)
+}
+
+// CreateOrUpdateSameTime mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateSameTime(arg0 context.Context, arg1 *cowPb.SearchSameTimeList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateSameTime", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateSameTime indicates an expected call of CreateOrUpdateSameTime.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateSameTime(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateSameTime", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateSameTime), arg0, arg1)
+}
+
+// CreateOrUpdateTransferPenReason mocks base method.
+func (m *MockPastureManageService) CreateOrUpdateTransferPenReason(arg0 context.Context, arg1 *cowPb.SearchBaseConfigList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateTransferPenReason", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateTransferPenReason indicates an expected call of CreateOrUpdateTransferPenReason.
+func (mr *MockPastureManageServiceMockRecorder) CreateOrUpdateTransferPenReason(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTransferPenReason", reflect.TypeOf((*MockPastureManageService)(nil).CreateOrUpdateTransferPenReason), arg0, arg1)
+}
+
+// CreatedOrUpdateImmunization mocks base method.
+func (m *MockPastureManageService) CreatedOrUpdateImmunization(arg0 context.Context, arg1 *cowPb.ImmunizationRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatedOrUpdateImmunization", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreatedOrUpdateImmunization indicates an expected call of CreatedOrUpdateImmunization.
+func (mr *MockPastureManageServiceMockRecorder) CreatedOrUpdateImmunization(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedOrUpdateImmunization", reflect.TypeOf((*MockPastureManageService)(nil).CreatedOrUpdateImmunization), arg0, arg1)
+}
+
+// ImmunizationIsShow mocks base method.
+func (m *MockPastureManageService) ImmunizationIsShow(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImmunizationIsShow", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ImmunizationIsShow indicates an expected call of ImmunizationIsShow.
+func (mr *MockPastureManageServiceMockRecorder) ImmunizationIsShow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImmunizationIsShow", reflect.TypeOf((*MockPastureManageService)(nil).ImmunizationIsShow), arg0, arg1)
+}
+
+// ImmunizationList mocks base method.
+func (m *MockPastureManageService) ImmunizationList(arg0 context.Context, arg1 *cowPb.ImmunizationRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchImmunizationResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImmunizationList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchImmunizationResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImmunizationList indicates an expected call of ImmunizationList.
+func (mr *MockPastureManageServiceMockRecorder) ImmunizationList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImmunizationList", reflect.TypeOf((*MockPastureManageService)(nil).ImmunizationList), arg0, arg1, arg2)
+}
+
+// PrescriptionDetail mocks base method.
+func (m *MockPastureManageService) PrescriptionDetail(arg0 context.Context, arg1 int64) (*cowPb.PrescriptionDetailResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrescriptionDetail", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.PrescriptionDetailResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PrescriptionDetail indicates an expected call of PrescriptionDetail.
+func (mr *MockPastureManageServiceMockRecorder) PrescriptionDetail(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrescriptionDetail", reflect.TypeOf((*MockPastureManageService)(nil).PrescriptionDetail), arg0, arg1)
+}
+
+// SameTimeIsShow mocks base method.
+func (m *MockPastureManageService) SameTimeIsShow(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SameTimeIsShow", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SameTimeIsShow indicates an expected call of SameTimeIsShow.
+func (mr *MockPastureManageServiceMockRecorder) SameTimeIsShow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeIsShow", reflect.TypeOf((*MockPastureManageService)(nil).SameTimeIsShow), arg0, arg1)
+}
+
+// SearchBarnList mocks base method.
+func (m *MockPastureManageService) SearchBarnList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBarnResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchBarnList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBarnResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchBarnList indicates an expected call of SearchBarnList.
+func (mr *MockPastureManageServiceMockRecorder) SearchBarnList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchBarnList", reflect.TypeOf((*MockPastureManageService)(nil).SearchBarnList), arg0, arg1, arg2)
+}
+
+// SearchBarnTypeList mocks base method.
+func (m *MockPastureManageService) SearchBarnTypeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchBarnTypeList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchBarnTypeList indicates an expected call of SearchBarnTypeList.
+func (mr *MockPastureManageServiceMockRecorder) SearchBarnTypeList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchBarnTypeList", reflect.TypeOf((*MockPastureManageService)(nil).SearchBarnTypeList), arg0, arg1, arg2)
+}
+
+// SearchBreedStatusList mocks base method.
+func (m *MockPastureManageService) SearchBreedStatusList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchBreedStatusList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchBreedStatusList indicates an expected call of SearchBreedStatusList.
+func (mr *MockPastureManageServiceMockRecorder) SearchBreedStatusList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchBreedStatusList", reflect.TypeOf((*MockPastureManageService)(nil).SearchBreedStatusList), arg0, arg1, arg2)
+}
+
+// SearchCowKindList mocks base method.
+func (m *MockPastureManageService) SearchCowKindList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchCowKindList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchCowKindList indicates an expected call of SearchCowKindList.
+func (mr *MockPastureManageServiceMockRecorder) SearchCowKindList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCowKindList", reflect.TypeOf((*MockPastureManageService)(nil).SearchCowKindList), arg0, arg1, arg2)
+}
+
+// SearchCowSourceList mocks base method.
+func (m *MockPastureManageService) SearchCowSourceList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchCowSourceList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchCowSourceList indicates an expected call of SearchCowSourceList.
+func (mr *MockPastureManageServiceMockRecorder) SearchCowSourceList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCowSourceList", reflect.TypeOf((*MockPastureManageService)(nil).SearchCowSourceList), arg0, arg1, arg2)
+}
+
+// SearchCowStatusList mocks base method.
+func (m *MockPastureManageService) SearchCowStatusList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchCowStatusList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchCowStatusList indicates an expected call of SearchCowStatusList.
+func (mr *MockPastureManageServiceMockRecorder) SearchCowStatusList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCowStatusList", reflect.TypeOf((*MockPastureManageService)(nil).SearchCowStatusList), arg0, arg1, arg2)
+}
+
+// SearchCowTypeList mocks base method.
+func (m *MockPastureManageService) SearchCowTypeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchCowTypeList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchCowTypeList indicates an expected call of SearchCowTypeList.
+func (mr *MockPastureManageServiceMockRecorder) SearchCowTypeList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCowTypeList", reflect.TypeOf((*MockPastureManageService)(nil).SearchCowTypeList), arg0, arg1, arg2)
+}
+
+// SearchDiseaseList mocks base method.
+func (m *MockPastureManageService) SearchDiseaseList(arg0 context.Context, arg1 *cowPb.SearchDiseaseRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchDiseaseResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchDiseaseList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchDiseaseResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchDiseaseList indicates an expected call of SearchDiseaseList.
+func (mr *MockPastureManageServiceMockRecorder) SearchDiseaseList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchDiseaseList", reflect.TypeOf((*MockPastureManageService)(nil).SearchDiseaseList), arg0, arg1, arg2)
+}
+
+// SearchDiseaseTypeList mocks base method.
+func (m *MockPastureManageService) SearchDiseaseTypeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchDiseaseTypeList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchDiseaseTypeList indicates an expected call of SearchDiseaseTypeList.
+func (mr *MockPastureManageServiceMockRecorder) SearchDiseaseTypeList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchDiseaseTypeList", reflect.TypeOf((*MockPastureManageService)(nil).SearchDiseaseTypeList), arg0, arg1, arg2)
+}
+
+// SearchPrescriptionList mocks base method.
+func (m *MockPastureManageService) SearchPrescriptionList(arg0 context.Context, arg1 *cowPb.SearchPrescriptionRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchPrescriptionResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchPrescriptionList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchPrescriptionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchPrescriptionList indicates an expected call of SearchPrescriptionList.
+func (mr *MockPastureManageServiceMockRecorder) SearchPrescriptionList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchPrescriptionList", reflect.TypeOf((*MockPastureManageService)(nil).SearchPrescriptionList), arg0, arg1, arg2)
+}
+
+// SearchSameTimeList mocks base method.
+func (m *MockPastureManageService) SearchSameTimeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SameTimeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSameTimeList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SameTimeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSameTimeList indicates an expected call of SearchSameTimeList.
+func (mr *MockPastureManageServiceMockRecorder) SearchSameTimeList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSameTimeList", reflect.TypeOf((*MockPastureManageService)(nil).SearchSameTimeList), arg0, arg1, arg2)
+}
+
+// SearchTransferPenReasonList mocks base method.
+func (m *MockPastureManageService) SearchTransferPenReasonList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchTransferPenReasonList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchTransferPenReasonList indicates an expected call of SearchTransferPenReasonList.
+func (mr *MockPastureManageServiceMockRecorder) SearchTransferPenReasonList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransferPenReasonList", reflect.TypeOf((*MockPastureManageService)(nil).SearchTransferPenReasonList), arg0, arg1, arg2)
+}
+
+// SystemBasicEdit mocks base method.
+func (m *MockPastureManageService) SystemBasicEdit(arg0 context.Context, arg1 *cowPb.BaseDataConfigBatch) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemBasicEdit", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SystemBasicEdit indicates an expected call of SystemBasicEdit.
+func (mr *MockPastureManageServiceMockRecorder) SystemBasicEdit(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemBasicEdit", reflect.TypeOf((*MockPastureManageService)(nil).SystemBasicEdit), arg0, arg1)
+}
+
+// SystemBasicList mocks base method.
+func (m *MockPastureManageService) SystemBasicList(arg0 context.Context) (*cowPb.SearchBaseDataConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemBasicList", arg0)
+	ret0, _ := ret[0].(*cowPb.SearchBaseDataConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SystemBasicList indicates an expected call of SystemBasicList.
+func (mr *MockPastureManageServiceMockRecorder) SystemBasicList(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemBasicList", reflect.TypeOf((*MockPastureManageService)(nil).SystemBasicList), arg0)
+}

module/backend/mock/SystemService.go

@@ -0,0 +1,383 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: SystemService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	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
+}
+
+// CreateOrUpdateSystemMenu mocks base method.
+func (m *MockSystemService) CreateOrUpdateSystemMenu(arg0 context.Context, arg1 *cowPb.SearchMenuRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateOrUpdateSystemMenu", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateOrUpdateSystemMenu indicates an expected call of CreateOrUpdateSystemMenu.
+func (mr *MockSystemServiceMockRecorder) CreateOrUpdateSystemMenu(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateSystemMenu", reflect.TypeOf((*MockSystemService)(nil).CreateOrUpdateSystemMenu), 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)
+}
+
+// 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)
+}
+
+// GetRoleMenuList mocks base method.
+func (m *MockSystemService) GetRoleMenuList(arg0 context.Context, arg1 int64) (*cowPb.SystemRoleMenuResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRoleMenuList", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.SystemRoleMenuResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRoleMenuList indicates an expected call of GetRoleMenuList.
+func (mr *MockSystemServiceMockRecorder) GetRoleMenuList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoleMenuList", reflect.TypeOf((*MockSystemService)(nil).GetRoleMenuList), arg0, arg1)
+}
+
+// GetSystemUserMenu mocks base method.
+func (m *MockSystemService) GetSystemUserMenu(arg0 context.Context) (*cowPb.SystemUserMenuTreeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSystemUserMenu", arg0)
+	ret0, _ := ret[0].(*cowPb.SystemUserMenuTreeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSystemUserMenu indicates an expected call of GetSystemUserMenu.
+func (mr *MockSystemServiceMockRecorder) GetSystemUserMenu(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemUserMenu", reflect.TypeOf((*MockSystemService)(nil).GetSystemUserMenu), arg0)
+}
+
+// IsShowSystemRole mocks base method.
+func (m *MockSystemService) IsShowSystemRole(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsShowSystemRole", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IsShowSystemRole indicates an expected call of IsShowSystemRole.
+func (mr *MockSystemServiceMockRecorder) IsShowSystemRole(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowSystemRole", reflect.TypeOf((*MockSystemService)(nil).IsShowSystemRole), arg0, arg1)
+}
+
+// IsShowSystemUser mocks base method.
+func (m *MockSystemService) IsShowSystemUser(arg0 context.Context, arg1 int64) 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)
+}
+
+// Login mocks base method.
+func (m *MockSystemService) Login(arg0 context.Context, arg1 *cowPb.SearchUserRequest) (*cowPb.SystemUserResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Login", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.SystemUserResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Login indicates an expected call of Login.
+func (mr *MockSystemServiceMockRecorder) Login(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockSystemService)(nil).Login), arg0, arg1)
+}
+
+// ResetPasswordSystemUser mocks base method.
+func (m *MockSystemService) ResetPasswordSystemUser(arg0 context.Context, arg1 *cowPb.ResetUserPasswordRequest) 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)
+}
+
+// RoleMenuSave mocks base method.
+func (m *MockSystemService) RoleMenuSave(arg0 context.Context, arg1 *cowPb.SystemRoleMenuRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RoleMenuSave", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RoleMenuSave indicates an expected call of RoleMenuSave.
+func (mr *MockSystemServiceMockRecorder) RoleMenuSave(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleMenuSave", reflect.TypeOf((*MockSystemService)(nil).RoleMenuSave), arg0, arg1)
+}
+
+// SearchSystemDeptList mocks base method.
+func (m *MockSystemService) SearchSystemDeptList(arg0 context.Context, arg1 *cowPb.SearchDeptRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchDeptResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSystemDeptList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchDeptResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSystemDeptList indicates an expected call of SearchSystemDeptList.
+func (mr *MockSystemServiceMockRecorder) SearchSystemDeptList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemDeptList", reflect.TypeOf((*MockSystemService)(nil).SearchSystemDeptList), arg0, arg1, arg2)
+}
+
+// SearchSystemMenuList mocks base method.
+func (m *MockSystemService) SearchSystemMenuList(arg0 context.Context, arg1 *cowPb.SearchMenuRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchMenuResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSystemMenuList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchMenuResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSystemMenuList indicates an expected call of SearchSystemMenuList.
+func (mr *MockSystemServiceMockRecorder) SearchSystemMenuList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemMenuList", reflect.TypeOf((*MockSystemService)(nil).SearchSystemMenuList), arg0, arg1, arg2)
+}
+
+// SearchSystemRoleList mocks base method.
+func (m *MockSystemService) SearchSystemRoleList(arg0 context.Context, arg1 *cowPb.SearchRoleRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchRoleResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSystemRoleList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchRoleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSystemRoleList indicates an expected call of SearchSystemRoleList.
+func (mr *MockSystemServiceMockRecorder) SearchSystemRoleList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemRoleList", reflect.TypeOf((*MockSystemService)(nil).SearchSystemRoleList), arg0, arg1, arg2)
+}
+
+// SearchSystemUserList mocks base method.
+func (m *MockSystemService) SearchSystemUserList(arg0 context.Context, arg1 *cowPb.SearchUserRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchUserResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SearchSystemUserList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchUserResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SearchSystemUserList indicates an expected call of SearchSystemUserList.
+func (mr *MockSystemServiceMockRecorder) SearchSystemUserList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSystemUserList", reflect.TypeOf((*MockSystemService)(nil).SearchSystemUserList), arg0, arg1, arg2)
+}
+
+// SystemDepDelete mocks base method.
+func (m *MockSystemService) SystemDepDelete(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemDepDelete", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SystemDepDelete indicates an expected call of SystemDepDelete.
+func (mr *MockSystemServiceMockRecorder) SystemDepDelete(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemDepDelete", reflect.TypeOf((*MockSystemService)(nil).SystemDepDelete), arg0, arg1)
+}
+
+// SystemDeptCreateOrUpdate mocks base method.
+func (m *MockSystemService) SystemDeptCreateOrUpdate(arg0 context.Context, arg1 *cowPb.SearchDeptRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemDeptCreateOrUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SystemDeptCreateOrUpdate indicates an expected call of SystemDeptCreateOrUpdate.
+func (mr *MockSystemServiceMockRecorder) SystemDeptCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemDeptCreateOrUpdate", reflect.TypeOf((*MockSystemService)(nil).SystemDeptCreateOrUpdate), arg0, arg1)
+}
+
+// SystemMenuTree mocks base method.
+func (m *MockSystemService) SystemMenuTree(arg0 context.Context) (*cowPb.SystemMenuTreeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemMenuTree", arg0)
+	ret0, _ := ret[0].(*cowPb.SystemMenuTreeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SystemMenuTree indicates an expected call of SystemMenuTree.
+func (mr *MockSystemServiceMockRecorder) SystemMenuTree(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemMenuTree", reflect.TypeOf((*MockSystemService)(nil).SystemMenuTree), arg0)
+}
+
+// SystemRoleCreateOrUpdate mocks base method.
+func (m *MockSystemService) SystemRoleCreateOrUpdate(arg0 context.Context, arg1 *cowPb.SearchRoleRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemRoleCreateOrUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SystemRoleCreateOrUpdate indicates an expected call of SystemRoleCreateOrUpdate.
+func (mr *MockSystemServiceMockRecorder) SystemRoleCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemRoleCreateOrUpdate", reflect.TypeOf((*MockSystemService)(nil).SystemRoleCreateOrUpdate), arg0, arg1)
+}
+
+// SystemRoleList mocks base method.
+func (m *MockSystemService) SystemRoleList(arg0 context.Context) (*cowPb.GetRoleListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemRoleList", arg0)
+	ret0, _ := ret[0].(*cowPb.GetRoleListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SystemRoleList indicates an expected call of SystemRoleList.
+func (mr *MockSystemServiceMockRecorder) SystemRoleList(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemRoleList", reflect.TypeOf((*MockSystemService)(nil).SystemRoleList), arg0)
+}
+
+// SystemUserCreateOrUpdate mocks base method.
+func (m *MockSystemService) SystemUserCreateOrUpdate(arg0 context.Context, arg1 *cowPb.SearchUserRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemUserCreateOrUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SystemUserCreateOrUpdate indicates an expected call of SystemUserCreateOrUpdate.
+func (mr *MockSystemServiceMockRecorder) SystemUserCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemUserCreateOrUpdate", reflect.TypeOf((*MockSystemService)(nil).SystemUserCreateOrUpdate), arg0, arg1)
+}
+
+// SystemUserRole mocks base method.
+func (m *MockSystemService) SystemUserRole(arg0 context.Context, arg1 int64) (*cowPb.SystemUserRoleResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemUserRole", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.SystemUserRoleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SystemUserRole indicates an expected call of SystemUserRole.
+func (mr *MockSystemServiceMockRecorder) SystemUserRole(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemUserRole", reflect.TypeOf((*MockSystemService)(nil).SystemUserRole), arg0, arg1)
+}
+
+// SystemUserRoleSave mocks base method.
+func (m *MockSystemService) SystemUserRoleSave(arg0 context.Context, arg1 *cowPb.SystemUserRoleRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemUserRoleSave", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SystemUserRoleSave indicates an expected call of SystemUserRoleSave.
+func (mr *MockSystemServiceMockRecorder) SystemUserRoleSave(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemUserRoleSave", reflect.TypeOf((*MockSystemService)(nil).SystemUserRoleSave), arg0, arg1)
+}

module/backend/mock/WorkService.go

@@ -0,0 +1,259 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: kpt-pasture/module/backend (interfaces: WorkService)
+
+// Package kptservicemock is a generated GoMock package.
+package kptservicemock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockWorkService is a mock of WorkService interface.
+type MockWorkService struct {
+	ctrl     *gomock.Controller
+	recorder *MockWorkServiceMockRecorder
+}
+
+// MockWorkServiceMockRecorder is the mock recorder for MockWorkService.
+type MockWorkServiceMockRecorder struct {
+	mock *MockWorkService
+}
+
+// NewMockWorkService creates a new mock instance.
+func NewMockWorkService(ctrl *gomock.Controller) *MockWorkService {
+	mock := &MockWorkService{ctrl: ctrl}
+	mock.recorder = &MockWorkServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockWorkService) EXPECT() *MockWorkServiceMockRecorder {
+	return m.recorder
+}
+
+// CalendarList mocks base method.
+func (m *MockWorkService) CalendarList(arg0 context.Context, arg1 *cowPb.CalendarRequest) (*cowPb.CalendarResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CalendarList", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.CalendarResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CalendarList indicates an expected call of CalendarList.
+func (mr *MockWorkServiceMockRecorder) CalendarList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalendarList", reflect.TypeOf((*MockWorkService)(nil).CalendarList), arg0, arg1)
+}
+
+// CalendarTableDetail mocks base method.
+func (m *MockWorkService) CalendarTableDetail(arg0 context.Context, arg1 *cowPb.CalendarTableRequest, arg2 *cowPb.PaginationModel) (interface{}, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CalendarTableDetail", arg0, arg1, arg2)
+	ret0, _ := ret[0].(interface{})
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CalendarTableDetail indicates an expected call of CalendarTableDetail.
+func (mr *MockWorkServiceMockRecorder) CalendarTableDetail(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalendarTableDetail", reflect.TypeOf((*MockWorkService)(nil).CalendarTableDetail), arg0, arg1, arg2)
+}
+
+// CalendarToDoList mocks base method.
+func (m *MockWorkService) CalendarToDoList(arg0 context.Context, arg1 *cowPb.CalendarToDoRequest, arg2 *cowPb.PaginationModel) (*cowPb.CalendarToDoResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CalendarToDoList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.CalendarToDoResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CalendarToDoList indicates an expected call of CalendarToDoList.
+func (mr *MockWorkServiceMockRecorder) CalendarToDoList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalendarToDoList", reflect.TypeOf((*MockWorkService)(nil).CalendarToDoList), arg0, arg1, arg2)
+}
+
+// CalvingCowList mocks base method.
+func (m *MockWorkService) CalvingCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.CalvingItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CalvingCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.CalvingItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CalvingCowList indicates an expected call of CalvingCowList.
+func (mr *MockWorkServiceMockRecorder) CalvingCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalvingCowList", reflect.TypeOf((*MockWorkService)(nil).CalvingCowList), arg0, arg1, arg2)
+}
+
+// CowDiseaseList mocks base method.
+func (m *MockWorkService) CowDiseaseList(arg0 context.Context, arg1 *cowPb.SearchEventCowTreatmentRequest, arg2 *cowPb.PaginationModel) (*cowPb.EventCowDiseaseResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowDiseaseList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.EventCowDiseaseResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowDiseaseList indicates an expected call of CowDiseaseList.
+func (mr *MockWorkServiceMockRecorder) CowDiseaseList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseList", reflect.TypeOf((*MockWorkService)(nil).CowDiseaseList), arg0, arg1, arg2)
+}
+
+// EstrusList mocks base method.
+func (m *MockWorkService) EstrusList(arg0 context.Context, arg1 *cowPb.EstrusItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.EstrusItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EstrusList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.EstrusItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EstrusList indicates an expected call of EstrusList.
+func (mr *MockWorkServiceMockRecorder) EstrusList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstrusList", reflect.TypeOf((*MockWorkService)(nil).EstrusList), arg0, arg1, arg2)
+}
+
+// ImmunisationCowList mocks base method.
+func (m *MockWorkService) ImmunisationCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.ImmunizationItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImmunisationCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.ImmunizationItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImmunisationCowList indicates an expected call of ImmunisationCowList.
+func (mr *MockWorkServiceMockRecorder) ImmunisationCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImmunisationCowList", reflect.TypeOf((*MockWorkService)(nil).ImmunisationCowList), arg0, arg1, arg2)
+}
+
+// MatingCowList mocks base method.
+func (m *MockWorkService) MatingCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.MatingItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MatingCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.MatingItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MatingCowList indicates an expected call of MatingCowList.
+func (mr *MockWorkServiceMockRecorder) MatingCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatingCowList", reflect.TypeOf((*MockWorkService)(nil).MatingCowList), arg0, arg1, arg2)
+}
+
+// OrderCreateOrUpdate mocks base method.
+func (m *MockWorkService) OrderCreateOrUpdate(arg0 context.Context, arg1 *cowPb.WorkOrderList) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrderCreateOrUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OrderCreateOrUpdate indicates an expected call of OrderCreateOrUpdate.
+func (mr *MockWorkServiceMockRecorder) OrderCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderCreateOrUpdate", reflect.TypeOf((*MockWorkService)(nil).OrderCreateOrUpdate), arg0, arg1)
+}
+
+// OrderIsShow mocks base method.
+func (m *MockWorkService) OrderIsShow(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrderIsShow", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OrderIsShow indicates an expected call of OrderIsShow.
+func (mr *MockWorkServiceMockRecorder) OrderIsShow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderIsShow", reflect.TypeOf((*MockWorkService)(nil).OrderIsShow), arg0, arg1)
+}
+
+// OrderList mocks base method.
+func (m *MockWorkService) OrderList(arg0 context.Context, arg1 *cowPb.SearchWorkOrderRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchWorkOrderResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OrderList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchWorkOrderResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// OrderList indicates an expected call of OrderList.
+func (mr *MockWorkServiceMockRecorder) OrderList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderList", reflect.TypeOf((*MockWorkService)(nil).OrderList), arg0, arg1, arg2)
+}
+
+// PregnancyCheckCowList mocks base method.
+func (m *MockWorkService) PregnancyCheckCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.PregnancyCheckItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PregnancyCheckCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.PregnancyCheckItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PregnancyCheckCowList indicates an expected call of PregnancyCheckCowList.
+func (mr *MockWorkServiceMockRecorder) PregnancyCheckCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnancyCheckCowList", reflect.TypeOf((*MockWorkService)(nil).PregnancyCheckCowList), arg0, arg1, arg2)
+}
+
+// SameTimeCowList mocks base method.
+func (m *MockWorkService) SameTimeCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.SameTimeItemResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SameTimeCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SameTimeItemResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SameTimeCowList indicates an expected call of SameTimeCowList.
+func (mr *MockWorkServiceMockRecorder) SameTimeCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeCowList", reflect.TypeOf((*MockWorkService)(nil).SameTimeCowList), arg0, arg1, arg2)
+}
+
+// UserWorkOrderList mocks base method.
+func (m *MockWorkService) UserWorkOrderList(arg0 context.Context, arg1 cowPb.WorkOrderStatus_Kind, arg2 *cowPb.PaginationModel) (*cowPb.UserWorkOrderResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UserWorkOrderList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.UserWorkOrderResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UserWorkOrderList indicates an expected call of UserWorkOrderList.
+func (mr *MockWorkServiceMockRecorder) UserWorkOrderList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserWorkOrderList", reflect.TypeOf((*MockWorkService)(nil).UserWorkOrderList), arg0, arg1, arg2)
+}
+
+// WeaningCowList mocks base method.
+func (m *MockWorkService) WeaningCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.WeaningItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WeaningCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.WeaningItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WeaningCowList indicates an expected call of WeaningCowList.
+func (mr *MockWorkServiceMockRecorder) WeaningCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeaningCowList", reflect.TypeOf((*MockWorkService)(nil).WeaningCowList), arg0, arg1, arg2)
+}

module/backend/mock/kptservice.go

@@ -50,18 +50,18 @@ func (mr *MockKptServiceMockRecorder) AbortionCreate(arg0, arg1 interface{}) *go
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionCreate", reflect.TypeOf((*MockKptService)(nil).AbortionCreate), arg0, arg1)
 }
 
-// AbortionCreateSlice mocks base method.
-func (m *MockKptService) AbortionCreateSlice(arg0 context.Context, arg1 *cowPb.EventAbortionSlice) error {
+// AbortionCreateBatch mocks base method.
+func (m *MockKptService) AbortionCreateBatch(arg0 context.Context, arg1 *cowPb.EventAbortionBatch) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AbortionCreateSlice", arg0, arg1)
+	ret := m.ctrl.Call(m, "AbortionCreateBatch", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// AbortionCreateSlice indicates an expected call of AbortionCreateSlice.
-func (mr *MockKptServiceMockRecorder) AbortionCreateSlice(arg0, arg1 interface{}) *gomock.Call {
+// AbortionCreateBatch indicates an expected call of AbortionCreateBatch.
+func (mr *MockKptServiceMockRecorder) AbortionCreateBatch(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionCreateSlice", reflect.TypeOf((*MockKptService)(nil).AbortionCreateSlice), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionCreateBatch", reflect.TypeOf((*MockKptService)(nil).AbortionCreateBatch), arg0, arg1)
 }
 
 // AbortionList mocks base method.
@@ -139,6 +139,21 @@ func (mr *MockKptServiceMockRecorder) BarnTypeOptions(arg0 interface{}) *gomock.
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BarnTypeOptions", reflect.TypeOf((*MockKptService)(nil).BarnTypeOptions), arg0)
 }
 
+// BehaviorCurve mocks base method.
+func (m *MockKptService) BehaviorCurve(arg0 context.Context, arg1 *cowPb.CowBehaviorCurveRequest) (*model.CowBehaviorCurveResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BehaviorCurve", arg0, arg1)
+	ret0, _ := ret[0].(*model.CowBehaviorCurveResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BehaviorCurve indicates an expected call of BehaviorCurve.
+func (mr *MockKptServiceMockRecorder) BehaviorCurve(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BehaviorCurve", reflect.TypeOf((*MockKptService)(nil).BehaviorCurve), arg0, arg1)
+}
+
 // BodyScoreList mocks base method.
 func (m *MockKptService) BodyScoreList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBodyScoreEventResponse, error) {
 	m.ctrl.T.Helper()
@@ -229,6 +244,21 @@ func (mr *MockKptServiceMockRecorder) CalendarToDoList(arg0, arg1, arg2 interfac
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalendarToDoList", reflect.TypeOf((*MockKptService)(nil).CalendarToDoList), arg0, arg1, arg2)
 }
 
+// CalvingCowList mocks base method.
+func (m *MockKptService) CalvingCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.CalvingItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CalvingCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.CalvingItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CalvingCowList indicates an expected call of CalvingCowList.
+func (mr *MockKptServiceMockRecorder) CalvingCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalvingCowList", reflect.TypeOf((*MockKptService)(nil).CalvingCowList), arg0, arg1, arg2)
+}
+
 // CalvingCreate mocks base method.
 func (m *MockKptService) CalvingCreate(arg0 context.Context, arg1 *cowPb.EventCalving) error {
 	m.ctrl.T.Helper()
@@ -274,17 +304,17 @@ func (mr *MockKptServiceMockRecorder) CalvingReport(arg0, arg1 interface{}) *gom
 }
 
 // CowDiseaseCreate mocks base method.
-func (m *MockKptService) CowDiseaseCreate(arg0 context.Context, arg1 *cowPb.EventCowDiseaseRequest) error {
+func (m *MockKptService) CowDiseaseCreate(arg0 context.Context, arg1 *cowPb.EventCowDiseaseRequest, arg2 string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CowDiseaseCreate", arg0, arg1)
+	ret := m.ctrl.Call(m, "CowDiseaseCreate", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // CowDiseaseCreate indicates an expected call of CowDiseaseCreate.
-func (mr *MockKptServiceMockRecorder) CowDiseaseCreate(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockKptServiceMockRecorder) CowDiseaseCreate(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseCreate", reflect.TypeOf((*MockKptService)(nil).CowDiseaseCreate), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseCreate", reflect.TypeOf((*MockKptService)(nil).CowDiseaseCreate), arg0, arg1, arg2)
 }
 
 // CowDiseaseCurable mocks base method.
@@ -359,6 +389,35 @@ func (mr *MockKptServiceMockRecorder) CowDiseaseTreatmentDetail(arg0, arg1, arg2
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseTreatmentDetail", reflect.TypeOf((*MockKptService)(nil).CowDiseaseTreatmentDetail), arg0, arg1, arg2)
 }
 
+// CowEarNumberUpdate mocks base method.
+func (m *MockKptService) CowEarNumberUpdate(arg0 context.Context, arg1 *cowPb.EventReplaceEarNumber) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowEarNumberUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CowEarNumberUpdate indicates an expected call of CowEarNumberUpdate.
+func (mr *MockKptServiceMockRecorder) CowEarNumberUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowEarNumberUpdate", reflect.TypeOf((*MockKptService)(nil).CowEarNumberUpdate), arg0, arg1)
+}
+
+// CowGrowthCurve mocks base method.
+func (m *MockKptService) CowGrowthCurve(arg0 context.Context, arg1 *cowPb.CowGrowthCurveRequest) (*cowPb.CowGrowthCurveResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowGrowthCurve", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.CowGrowthCurveResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CowGrowthCurve indicates an expected call of CowGrowthCurve.
+func (mr *MockKptServiceMockRecorder) CowGrowthCurve(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowGrowthCurve", reflect.TypeOf((*MockKptService)(nil).CowGrowthCurve), arg0, arg1)
+}
+
 // CowKindOptions mocks base method.
 func (m *MockKptService) CowKindOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
@@ -374,19 +433,18 @@ func (mr *MockKptServiceMockRecorder) CowKindOptions(arg0 interface{}) *gomock.C
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowKindOptions", reflect.TypeOf((*MockKptService)(nil).CowKindOptions), arg0)
 }
 
-// CowList mocks base method.
-func (m *MockKptService) CowList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchCowListResponse, error) {
+// CowNeckRingNumberBound mocks base method.
+func (m *MockKptService) CowNeckRingNumberBound(arg0 context.Context, arg1 *cowPb.PaginationModel) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CowList", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*cowPb.SearchCowListResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
+	ret := m.ctrl.Call(m, "CowNeckRingNumberBound", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
 }
 
-// CowList indicates an expected call of CowList.
-func (mr *MockKptServiceMockRecorder) CowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+// CowNeckRingNumberBound indicates an expected call of CowNeckRingNumberBound.
+func (mr *MockKptServiceMockRecorder) CowNeckRingNumberBound(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowList", reflect.TypeOf((*MockKptService)(nil).CowList), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowNeckRingNumberBound", reflect.TypeOf((*MockKptService)(nil).CowNeckRingNumberBound), arg0, arg1)
 }
 
 // CowSourceOptions mocks base method.
@@ -714,6 +772,20 @@ func (mr *MockKptServiceMockRecorder) DeleteSystemUser(arg0, arg1 interface{}) *
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSystemUser", reflect.TypeOf((*MockKptService)(nil).DeleteSystemUser), arg0, arg1)
 }
 
+// DepartureBatch mocks base method.
+func (m *MockKptService) DepartureBatch(arg0 context.Context, arg1 *cowPb.EventDepartureBatch) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DepartureBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DepartureBatch indicates an expected call of DepartureBatch.
+func (mr *MockKptServiceMockRecorder) DepartureBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DepartureBatch", reflect.TypeOf((*MockKptService)(nil).DepartureBatch), arg0, arg1)
+}
+
 // DiseaseCureReport mocks base method.
 func (m *MockKptService) DiseaseCureReport(arg0 context.Context, arg1 *cowPb.DiseaseCureRateRequest) (*cowPb.DiseaseCureRateResponse, error) {
 	m.ctrl.T.Helper()
@@ -744,6 +816,21 @@ func (mr *MockKptServiceMockRecorder) DiseaseOptions(arg0 interface{}) *gomock.C
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseOptions", reflect.TypeOf((*MockKptService)(nil).DiseaseOptions), arg0)
 }
 
+// DiseaseSuggestPrescription mocks base method.
+func (m *MockKptService) DiseaseSuggestPrescription(arg0 context.Context, arg1 int64) (*cowPb.ConfigOptionsListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DiseaseSuggestPrescription", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DiseaseSuggestPrescription indicates an expected call of DiseaseSuggestPrescription.
+func (mr *MockKptServiceMockRecorder) DiseaseSuggestPrescription(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseSuggestPrescription", reflect.TypeOf((*MockKptService)(nil).DiseaseSuggestPrescription), arg0, arg1)
+}
+
 // DiseaseTypeOptions mocks base method.
 func (m *MockKptService) DiseaseTypeOptions(arg0 context.Context, arg1 string) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
@@ -803,25 +890,25 @@ func (mr *MockKptServiceMockRecorder) EnterList(arg0, arg1, arg2 interface{}) *g
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterList", reflect.TypeOf((*MockKptService)(nil).EnterList), arg0, arg1, arg2)
 }
 
-// EstrusCreate mocks base method.
-func (m *MockKptService) EstrusCreate(arg0 context.Context, arg1 *cowPb.EventEstrus) error {
+// EstrusBatchMating mocks base method.
+func (m *MockKptService) EstrusBatchMating(arg0 context.Context, arg1 *cowPb.EventEstrus) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EstrusCreate", arg0, arg1)
+	ret := m.ctrl.Call(m, "EstrusBatchMating", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// EstrusCreate indicates an expected call of EstrusCreate.
-func (mr *MockKptServiceMockRecorder) EstrusCreate(arg0, arg1 interface{}) *gomock.Call {
+// EstrusBatchMating indicates an expected call of EstrusBatchMating.
+func (mr *MockKptServiceMockRecorder) EstrusBatchMating(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstrusCreate", reflect.TypeOf((*MockKptService)(nil).EstrusCreate), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstrusBatchMating", reflect.TypeOf((*MockKptService)(nil).EstrusBatchMating), arg0, arg1)
 }
 
 // EstrusList mocks base method.
-func (m *MockKptService) EstrusList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.EstrusEventResponse, error) {
+func (m *MockKptService) EstrusList(arg0 context.Context, arg1 *cowPb.EstrusItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.EstrusItemsResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EstrusList", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*cowPb.EstrusEventResponse)
+	ret0, _ := ret[0].(*cowPb.EstrusItemsResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -832,6 +919,21 @@ func (mr *MockKptServiceMockRecorder) EstrusList(arg0, arg1, arg2 interface{}) *
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstrusList", reflect.TypeOf((*MockKptService)(nil).EstrusList), arg0, arg1, arg2)
 }
 
+// EventList mocks base method.
+func (m *MockKptService) EventList(arg0 context.Context, arg1 *cowPb.SearchCowEventListRequest, arg2 *cowPb.PaginationModel) (*cowPb.CowEventListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EventList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.CowEventListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EventList indicates an expected call of EventList.
+func (mr *MockKptServiceMockRecorder) EventList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventList", reflect.TypeOf((*MockKptService)(nil).EventList), arg0, arg1, arg2)
+}
+
 // FrozenSemenCreate mocks base method.
 func (m *MockKptService) FrozenSemenCreate(arg0 context.Context, arg1 *cowPb.SearchFrozenSemenList) error {
 	m.ctrl.T.Helper()
@@ -936,6 +1038,21 @@ func (mr *MockKptServiceMockRecorder) GrowthCurve(arg0, arg1 interface{}) *gomoc
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrowthCurve", reflect.TypeOf((*MockKptService)(nil).GrowthCurve), arg0, arg1)
 }
 
+// ImmunisationCowList mocks base method.
+func (m *MockKptService) ImmunisationCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.ImmunizationItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ImmunisationCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.ImmunizationItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ImmunisationCowList indicates an expected call of ImmunisationCowList.
+func (mr *MockKptServiceMockRecorder) ImmunisationCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImmunisationCowList", reflect.TypeOf((*MockKptService)(nil).ImmunisationCowList), arg0, arg1, arg2)
+}
+
 // ImmunizationIsShow mocks base method.
 func (m *MockKptService) ImmunizationIsShow(arg0 context.Context, arg1 int64) error {
 	m.ctrl.T.Helper()
@@ -993,6 +1110,21 @@ func (mr *MockKptServiceMockRecorder) IsShowSystemUser(arg0, arg1 interface{}) *
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsShowSystemUser", reflect.TypeOf((*MockKptService)(nil).IsShowSystemUser), arg0, arg1)
 }
 
+// List mocks base method.
+func (m *MockKptService) List(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchCowListResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchCowListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockKptServiceMockRecorder) List(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockKptService)(nil).List), arg0, arg1, arg2)
+}
+
 // Login mocks base method.
 func (m *MockKptService) Login(arg0 context.Context, arg1 *cowPb.SearchUserRequest) (*cowPb.SystemUserResponse, error) {
 	m.ctrl.T.Helper()
@@ -1008,6 +1140,21 @@ func (mr *MockKptServiceMockRecorder) Login(arg0, arg1 interface{}) *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockKptService)(nil).Login), arg0, arg1)
 }
 
+// MatingCowList mocks base method.
+func (m *MockKptService) MatingCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.MatingItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MatingCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.MatingItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MatingCowList indicates an expected call of MatingCowList.
+func (mr *MockKptServiceMockRecorder) MatingCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatingCowList", reflect.TypeOf((*MockKptService)(nil).MatingCowList), arg0, arg1, arg2)
+}
+
 // MatingCreate mocks base method.
 func (m *MockKptService) MatingCreate(arg0 context.Context, arg1 *cowPb.EventMating) error {
 	m.ctrl.T.Helper()
@@ -1082,10 +1229,10 @@ func (mr *MockKptServiceMockRecorder) MedicalEquipmentList(arg0, arg1, arg2 inte
 }
 
 // MultipleFactorAnalysis mocks base method.
-func (m *MockKptService) MultipleFactorAnalysis(arg0 context.Context, arg1 *cowPb.MultiFactorPregnancyRateRequest) (*cowPb.MultiFactorPregnancyRateResponse, error) {
+func (m *MockKptService) MultipleFactorAnalysis(arg0 context.Context, arg1 *cowPb.MultiFactorPregnancyRateRequest) (*model.MultiFactorPregnancyRateResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "MultipleFactorAnalysis", arg0, arg1)
-	ret0, _ := ret[0].(*cowPb.MultiFactorPregnancyRateResponse)
+	ret0, _ := ret[0].(*model.MultiFactorPregnancyRateResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -1096,6 +1243,35 @@ func (mr *MockKptServiceMockRecorder) MultipleFactorAnalysis(arg0, arg1 interfac
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultipleFactorAnalysis", reflect.TypeOf((*MockKptService)(nil).MultipleFactorAnalysis), arg0, arg1)
 }
 
+// NeckRingCreateOrUpdate mocks base method.
+func (m *MockKptService) NeckRingCreateOrUpdate(arg0 context.Context, arg1 *cowPb.NeckRingCreateRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NeckRingCreateOrUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// NeckRingCreateOrUpdate indicates an expected call of NeckRingCreateOrUpdate.
+func (mr *MockKptServiceMockRecorder) NeckRingCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeckRingCreateOrUpdate", reflect.TypeOf((*MockKptService)(nil).NeckRingCreateOrUpdate), arg0, arg1)
+}
+
+// NeckRingList mocks base method.
+func (m *MockKptService) NeckRingList(arg0 context.Context, arg1 *cowPb.SearchNeckRingRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchNeckRingResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NeckRingList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchNeckRingResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NeckRingList indicates an expected call of NeckRingList.
+func (mr *MockKptServiceMockRecorder) NeckRingList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeckRingList", reflect.TypeOf((*MockKptService)(nil).NeckRingList), arg0, arg1, arg2)
+}
+
 // OrderCreateOrUpdate mocks base method.
 func (m *MockKptService) OrderCreateOrUpdate(arg0 context.Context, arg1 *cowPb.WorkOrderList) error {
 	m.ctrl.T.Helper()
@@ -1139,6 +1315,78 @@ func (mr *MockKptServiceMockRecorder) OrderList(arg0, arg1, arg2 interface{}) *g
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderList", reflect.TypeOf((*MockKptService)(nil).OrderList), arg0, arg1, arg2)
 }
 
+// OutboundApply mocks base method.
+func (m *MockKptService) OutboundApply(arg0 context.Context, arg1 *cowPb.OutboundApplyItem) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundApply", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OutboundApply indicates an expected call of OutboundApply.
+func (mr *MockKptServiceMockRecorder) OutboundApply(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundApply", reflect.TypeOf((*MockKptService)(nil).OutboundApply), arg0, arg1)
+}
+
+// OutboundAudit mocks base method.
+func (m *MockKptService) OutboundAudit(arg0 context.Context, arg1 *cowPb.OutboundApplyAuditRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundAudit", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OutboundAudit indicates an expected call of OutboundAudit.
+func (mr *MockKptServiceMockRecorder) OutboundAudit(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundAudit", reflect.TypeOf((*MockKptService)(nil).OutboundAudit), arg0, arg1)
+}
+
+// OutboundDelete mocks base method.
+func (m *MockKptService) OutboundDelete(arg0 context.Context, arg1 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundDelete", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OutboundDelete indicates an expected call of OutboundDelete.
+func (mr *MockKptServiceMockRecorder) OutboundDelete(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundDelete", reflect.TypeOf((*MockKptService)(nil).OutboundDelete), arg0, arg1)
+}
+
+// OutboundDetail mocks base method.
+func (m *MockKptService) OutboundDetail(arg0 context.Context, arg1 int64) (*cowPb.OutboundDetailResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundDetail", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.OutboundDetailResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// OutboundDetail indicates an expected call of OutboundDetail.
+func (mr *MockKptServiceMockRecorder) OutboundDetail(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundDetail", reflect.TypeOf((*MockKptService)(nil).OutboundDetail), arg0, arg1)
+}
+
+// OutboundList mocks base method.
+func (m *MockKptService) OutboundList(arg0 context.Context, arg1 *cowPb.SearchOutboundApplyRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchOutboundApplyResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OutboundList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SearchOutboundApplyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// OutboundList indicates an expected call of OutboundList.
+func (mr *MockKptServiceMockRecorder) OutboundList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OutboundList", reflect.TypeOf((*MockKptService)(nil).OutboundList), arg0, arg1, arg2)
+}
+
 // PenWeight mocks base method.
 func (m *MockKptService) PenWeight(arg0 context.Context, arg1 *cowPb.PenWeightRequest, arg2 *cowPb.PaginationModel) (*cowPb.PenWeightResponse, error) {
 	m.ctrl.T.Helper()
@@ -1154,6 +1402,21 @@ func (mr *MockKptServiceMockRecorder) PenWeight(arg0, arg1, arg2 interface{}) *g
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PenWeight", reflect.TypeOf((*MockKptService)(nil).PenWeight), arg0, arg1, arg2)
 }
 
+// PregnancyCheckCowList mocks base method.
+func (m *MockKptService) PregnancyCheckCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.PregnancyCheckItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PregnancyCheckCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.PregnancyCheckItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PregnancyCheckCowList indicates an expected call of PregnancyCheckCowList.
+func (mr *MockKptServiceMockRecorder) PregnancyCheckCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnancyCheckCowList", reflect.TypeOf((*MockKptService)(nil).PregnancyCheckCowList), arg0, arg1, arg2)
+}
+
 // PregnancyReport mocks base method.
 func (m *MockKptService) PregnancyReport(arg0 context.Context, arg1 *cowPb.PregnancyReportRequest, arg2 *cowPb.PaginationModel) (*cowPb.PregnancyReportResponse, error) {
 	m.ctrl.T.Helper()
@@ -1169,18 +1432,18 @@ func (mr *MockKptServiceMockRecorder) PregnancyReport(arg0, arg1, arg2 interface
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnancyReport", reflect.TypeOf((*MockKptService)(nil).PregnancyReport), arg0, arg1, arg2)
 }
 
-// PregnantCheckCreate mocks base method.
-func (m *MockKptService) PregnantCheckCreate(arg0 context.Context, arg1 *cowPb.EventPregnantCheck) error {
+// PregnantCheckCreateBatch mocks base method.
+func (m *MockKptService) PregnantCheckCreateBatch(arg0 context.Context, arg1 *cowPb.EventPregnantCheckBatch) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PregnantCheckCreate", arg0, arg1)
+	ret := m.ctrl.Call(m, "PregnantCheckCreateBatch", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// PregnantCheckCreate indicates an expected call of PregnantCheckCreate.
-func (mr *MockKptServiceMockRecorder) PregnantCheckCreate(arg0, arg1 interface{}) *gomock.Call {
+// PregnantCheckCreateBatch indicates an expected call of PregnantCheckCreateBatch.
+func (mr *MockKptServiceMockRecorder) PregnantCheckCreateBatch(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnantCheckCreate", reflect.TypeOf((*MockKptService)(nil).PregnantCheckCreate), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnantCheckCreateBatch", reflect.TypeOf((*MockKptService)(nil).PregnantCheckCreateBatch), arg0, arg1)
 }
 
 // PregnantCheckList mocks base method.
@@ -1198,6 +1461,21 @@ func (mr *MockKptServiceMockRecorder) PregnantCheckList(arg0, arg1, arg2 interfa
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PregnantCheckList", reflect.TypeOf((*MockKptService)(nil).PregnantCheckList), arg0, arg1, arg2)
 }
 
+// PrescriptionDetail mocks base method.
+func (m *MockKptService) PrescriptionDetail(arg0 context.Context, arg1 int64) (*cowPb.PrescriptionDetailResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrescriptionDetail", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.PrescriptionDetailResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PrescriptionDetail indicates an expected call of PrescriptionDetail.
+func (mr *MockKptServiceMockRecorder) PrescriptionDetail(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrescriptionDetail", reflect.TypeOf((*MockKptService)(nil).PrescriptionDetail), arg0, arg1)
+}
+
 // PrescriptionOptions mocks base method.
 func (m *MockKptService) PrescriptionOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
@@ -1241,6 +1519,50 @@ func (mr *MockKptServiceMockRecorder) RoleMenuSave(arg0, arg1 interface{}) *gomo
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleMenuSave", reflect.TypeOf((*MockKptService)(nil).RoleMenuSave), arg0, arg1)
 }
 
+// SaleCowReport mocks base method.
+func (m *MockKptService) SaleCowReport(arg0 context.Context, arg1 *cowPb.SaleCowReportRequest) (*cowPb.SaleCowReportResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SaleCowReport", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.SaleCowReportResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SaleCowReport indicates an expected call of SaleCowReport.
+func (mr *MockKptServiceMockRecorder) SaleCowReport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaleCowReport", reflect.TypeOf((*MockKptService)(nil).SaleCowReport), arg0, arg1)
+}
+
+// SameTimeBatch mocks base method.
+func (m *MockKptService) SameTimeBatch(arg0 context.Context, arg1 *cowPb.EventSameTimeBatch) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SameTimeBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SameTimeBatch indicates an expected call of SameTimeBatch.
+func (mr *MockKptServiceMockRecorder) SameTimeBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeBatch", reflect.TypeOf((*MockKptService)(nil).SameTimeBatch), arg0, arg1)
+}
+
+// SameTimeCowList mocks base method.
+func (m *MockKptService) SameTimeCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.SameTimeItemResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SameTimeCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SameTimeItemResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SameTimeCowList indicates an expected call of SameTimeCowList.
+func (mr *MockKptServiceMockRecorder) SameTimeCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeCowList", reflect.TypeOf((*MockKptService)(nil).SameTimeCowList), arg0, arg1, arg2)
+}
+
 // SameTimeCreate mocks base method.
 func (m *MockKptService) SameTimeCreate(arg0 context.Context, arg1 *cowPb.EventSameTime) error {
 	m.ctrl.T.Helper()
@@ -1539,6 +1861,20 @@ func (mr *MockKptServiceMockRecorder) SingleFactorInfantSurvivalRateAnalysis(arg
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SingleFactorInfantSurvivalRateAnalysis", reflect.TypeOf((*MockKptService)(nil).SingleFactorInfantSurvivalRateAnalysis), arg0, arg1)
 }
 
+// SubmitEventLog mocks base method.
+func (m *MockKptService) SubmitEventLog(arg0 context.Context, arg1 *model.SystemUser, arg2 *model.Cow, arg3 cowPb.EventType_Kind, arg4 cowPb.ExposeEstrusType_Kind, arg5 interface{}) *model.EventCowLog {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubmitEventLog", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*model.EventCowLog)
+	return ret0
+}
+
+// SubmitEventLog indicates an expected call of SubmitEventLog.
+func (mr *MockKptServiceMockRecorder) SubmitEventLog(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitEventLog", reflect.TypeOf((*MockKptService)(nil).SubmitEventLog), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
 // SystemBaseConfigOptions mocks base method.
 func (m *MockKptService) SystemBaseConfigOptions(arg0 context.Context, arg1, arg2 string) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
@@ -1554,6 +1890,35 @@ func (mr *MockKptServiceMockRecorder) SystemBaseConfigOptions(arg0, arg1, arg2 i
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemBaseConfigOptions", reflect.TypeOf((*MockKptService)(nil).SystemBaseConfigOptions), arg0, arg1, arg2)
 }
 
+// SystemBasicEdit mocks base method.
+func (m *MockKptService) SystemBasicEdit(arg0 context.Context, arg1 *cowPb.BaseDataConfigBatch) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemBasicEdit", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SystemBasicEdit indicates an expected call of SystemBasicEdit.
+func (mr *MockKptServiceMockRecorder) SystemBasicEdit(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemBasicEdit", reflect.TypeOf((*MockKptService)(nil).SystemBasicEdit), arg0, arg1)
+}
+
+// SystemBasicList mocks base method.
+func (m *MockKptService) SystemBasicList(arg0 context.Context) (*cowPb.SearchBaseDataConfigResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SystemBasicList", arg0)
+	ret0, _ := ret[0].(*cowPb.SearchBaseDataConfigResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SystemBasicList indicates an expected call of SystemBasicList.
+func (mr *MockKptServiceMockRecorder) SystemBasicList(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemBasicList", reflect.TypeOf((*MockKptService)(nil).SystemBasicList), arg0)
+}
+
 // SystemDepDelete mocks base method.
 func (m *MockKptService) SystemDepDelete(arg0 context.Context, arg1 int64) error {
 	m.ctrl.T.Helper()
@@ -1699,6 +2064,20 @@ func (mr *MockKptServiceMockRecorder) TwentyOnePregnantRate(arg0, arg1 interface
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TwentyOnePregnantRate", reflect.TypeOf((*MockKptService)(nil).TwentyOnePregnantRate), arg0, arg1)
 }
 
+// UpdateCowPen mocks base method.
+func (m *MockKptService) UpdateCowPen(arg0 context.Context, arg1 *cowPb.PaginationModel) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateCowPen", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateCowPen indicates an expected call of UpdateCowPen.
+func (mr *MockKptServiceMockRecorder) UpdateCowPen(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCowPen", reflect.TypeOf((*MockKptService)(nil).UpdateCowPen), arg0, arg1)
+}
+
 // UserWorkOrderList mocks base method.
 func (m *MockKptService) UserWorkOrderList(arg0 context.Context, arg1 cowPb.WorkOrderStatus_Kind, arg2 *cowPb.PaginationModel) (*cowPb.UserWorkOrderResponse, error) {
 	m.ctrl.T.Helper()
@@ -1714,18 +2093,47 @@ func (mr *MockKptServiceMockRecorder) UserWorkOrderList(arg0, arg1, arg2 interfa
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserWorkOrderList", reflect.TypeOf((*MockKptService)(nil).UserWorkOrderList), arg0, arg1, arg2)
 }
 
-// WeightCreate mocks base method.
-func (m *MockKptService) WeightCreate(arg0 context.Context, arg1 *cowPb.EventWeight) error {
+// WeaningBatch mocks base method.
+func (m *MockKptService) WeaningBatch(arg0 context.Context, arg1 *cowPb.EventWeaningBatchRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WeaningBatch", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WeaningBatch indicates an expected call of WeaningBatch.
+func (mr *MockKptServiceMockRecorder) WeaningBatch(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeaningBatch", reflect.TypeOf((*MockKptService)(nil).WeaningBatch), arg0, arg1)
+}
+
+// WeaningCowList mocks base method.
+func (m *MockKptService) WeaningCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.WeaningItemsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WeaningCowList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.WeaningItemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WeaningCowList indicates an expected call of WeaningCowList.
+func (mr *MockKptServiceMockRecorder) WeaningCowList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeaningCowList", reflect.TypeOf((*MockKptService)(nil).WeaningCowList), arg0, arg1, arg2)
+}
+
+// WeightBatch mocks base method.
+func (m *MockKptService) WeightBatch(arg0 context.Context, arg1 *cowPb.EventWeight) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WeightCreate", arg0, arg1)
+	ret := m.ctrl.Call(m, "WeightBatch", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// WeightCreate indicates an expected call of WeightCreate.
-func (mr *MockKptServiceMockRecorder) WeightCreate(arg0, arg1 interface{}) *gomock.Call {
+// WeightBatch indicates an expected call of WeightBatch.
+func (mr *MockKptServiceMockRecorder) WeightBatch(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeightCreate", reflect.TypeOf((*MockKptService)(nil).WeightCreate), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeightBatch", reflect.TypeOf((*MockKptService)(nil).WeightBatch), arg0, arg1)
 }
 
 // WeightList mocks base method.

module/crontab/neck_ring_handle.go

@@ -672,8 +672,7 @@ func (e *Entry) UpdateChangeAdJust(pastureId int64, xToday *XToday) error {
 	if err := e.DB.Model(new(model.NeckActiveHabit)).
 		Where("id BETWEEN ? AND ?", xToday.LastMaxHabitId, xToday.CurrMaxHabitId).
 		Where("pasture_id = ?", pastureId).
-		Where("is_show = ?", pasturePb.IsShow_No).
-		Update("is_show = ?", pasturePb.IsShow_Ok).Error; err != nil {
+		Update("is_show", pasturePb.IsShow_Ok).Error; err != nil {
 		zaplog.Error("UpdateChangeAdJust-2", zap.Any("error", err), zap.Any("xToday", xToday))
 	}
 	return nil