analysis: 多维度受胎率分析

go.mod

@@ -3,7 +3,7 @@ module kpt-pasture
 go 1.17
 
 require (
-	gitee.com/xuyiping_admin/go_proto v0.0.0-20241101012151-bbf157c372ed
+	gitee.com/xuyiping_admin/go_proto v0.0.0-20241104025928-e62a2d8db6d6
 	gitee.com/xuyiping_admin/pkg v0.0.0-20241029095841-aa1fe89b557a
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/eko/gocache v1.1.0

go.sum

@@ -40,6 +40,10 @@ gitee.com/xuyiping_admin/go_proto v0.0.0-20241030093930-85784b846ab4 h1:7GYTs67b
 gitee.com/xuyiping_admin/go_proto v0.0.0-20241030093930-85784b846ab4/go.mod h1:BKrFW6YLDectlQcQk3FYKBeXvjEiodAKJ5rq7O/QiPE=
 gitee.com/xuyiping_admin/go_proto v0.0.0-20241101012151-bbf157c372ed h1:w4R1HdbIkcHhRunjPTPT8PPk4TybANIBy4OuC89Na4c=
 gitee.com/xuyiping_admin/go_proto v0.0.0-20241101012151-bbf157c372ed/go.mod h1:BKrFW6YLDectlQcQk3FYKBeXvjEiodAKJ5rq7O/QiPE=
+gitee.com/xuyiping_admin/go_proto v0.0.0-20241104023746-2df64dda0323 h1:lA3XTnnhg52VFLDM/typUJCypirbD7TmnMyIlWk5B70=
+gitee.com/xuyiping_admin/go_proto v0.0.0-20241104023746-2df64dda0323/go.mod h1:BKrFW6YLDectlQcQk3FYKBeXvjEiodAKJ5rq7O/QiPE=
+gitee.com/xuyiping_admin/go_proto v0.0.0-20241104025928-e62a2d8db6d6 h1:NqH5P8Sgm38m9RFb3cQnKIsX0qZqXefJrC7JjJUTB2g=
+gitee.com/xuyiping_admin/go_proto v0.0.0-20241104025928-e62a2d8db6d6/go.mod h1:BKrFW6YLDectlQcQk3FYKBeXvjEiodAKJ5rq7O/QiPE=
 gitee.com/xuyiping_admin/pkg v0.0.0-20241029095841-aa1fe89b557a h1:z6Pp4HmdcxEZ43avmbFoE3vwEYcWnIefqEEZZWCHfek=
 gitee.com/xuyiping_admin/pkg v0.0.0-20241029095841-aa1fe89b557a/go.mod h1:8tF25X6pE9WkFCczlNAC0K2mrjwKvhhp02I7o0HtDxY=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=

http/handler/analysis/analysis.go

@@ -250,3 +250,29 @@ func SingleFactorInfantSurvivalRate(c *gin.Context) {
 	}
 	ginutil.JSONResp(c, res)
 }
+
+func MultiFactorInfantSurvivalRate(c *gin.Context) {
+	var req pasturePb.MultiFactorPregnancyRateRequest
+	if err := ginutil.BindProto(c, &req); err != nil {
+		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
+		return
+	}
+
+	if err := valid.ValidateStruct(&req,
+		valid.Field(&req.StartDayTime, valid.Required),
+		valid.Field(&req.EndDayTime, valid.Required),
+		valid.Field(&req.CowType, valid.Required),
+		valid.Field(&req.XAxle, valid.Required),
+		valid.Field(&req.YAxle, valid.Required),
+	); err != nil {
+		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
+		return
+	}
+
+	res, err := middleware.Dependency(c).StoreEventHub.OpsService.MultipleFactorAnalysis(c, &req)
+	if err != nil {
+		apierr.ClassifiedAbort(c, err)
+		return
+	}
+	ginutil.JSONResp(c, res)
+}

http/route/analysis_api.go

@@ -23,5 +23,6 @@ func AnalysisAPI(opts ...func(engine *gin.Engine)) func(s *gin.Engine) {
 		pastureRoute.POST("/calving/report", analysis.CalvingReport)
 		pastureRoute.POST("/disease/cure/report", analysis.DiseaseCureReport)
 		pastureRoute.POST("/single/factor/pregnant/report", analysis.SingleFactorInfantSurvivalRate)
+		pastureRoute.POST("/multi/factor/pregnant/report", analysis.MultiFactorInfantSurvivalRate)
 	}
 }

model/event_cow_same_time.go

@@ -112,11 +112,14 @@ func (s EventCowSameTimeSlice) ToPB() []*pasturePb.EventSameTime {
 	res := make([]*pasturePb.EventSameTime, len(s))
 	for i, v := range s {
 		res[i] = &pasturePb.EventSameTime{
-			CowId:      fmt.Sprintf("%d", v.CowId),
-			DrugsId:    int32(v.DrugsId),
-			Usage:      v.Usage,
-			Lact:       v.Lact,
-			SameTimeId: int32(v.SameTimeId),
+			CowId:            fmt.Sprintf("%d", v.CowId),
+			PenId:            v.PenId,
+			DrugsId:          int32(v.DrugsId),
+			Usage:            v.Usage,
+			Lact:             v.Lact,
+			SameTimeId:       int32(v.SameTimeId),
+			SameTimeType:     v.SameTimeType,
+			SameTimeTypeName: "",
 		}
 	}
 	return res

module/backend/analysis_breed.go

@@ -181,19 +181,19 @@ func (s *StoreEntry) SingleFactorAnalysisMethodMonths(ctx context.Context, req *
 
 	if req.LactInterval > 0 {
 		switch req.LactInterval {
-		case pasturePb.LactIntervalSymbol_Less_Than:
+		case pasturePb.CompareSymbol_Less_Than:
 			pref.Where("lact < ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Less_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Less_Than_Or_Equal_To:
 			pref.Where("lact <= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than:
+		case pasturePb.CompareSymbol_Greater_Than:
 			pref.Where("lact > ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Greater_Than_Or_Equal_To:
 			pref.Where("lact >= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Equal_To:
+		case pasturePb.CompareSymbol_Equal_To:
 			pref.Where("lact = ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Not_Equal_To:
+		case pasturePb.CompareSymbol_Not_Equal_To:
 			pref.Where("lact != ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Between:
+		case pasturePb.CompareSymbol_Between:
 			pref.Where("lact BETWEEN ? AND ? ", req.LactIntervalStartValue, req.LactIntervalEndValue)
 		default:
 			return nil, xerr.Custom("错误的胎次区间符号")
@@ -279,19 +279,19 @@ func (s *StoreEntry) SingleFactorAnalysisMethodBreedingCompany(ctx context.Conte
 
 	if req.LactInterval > 0 {
 		switch req.LactInterval {
-		case pasturePb.LactIntervalSymbol_Less_Than:
+		case pasturePb.CompareSymbol_Less_Than:
 			pref.Where("a.lact < ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Less_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Less_Than_Or_Equal_To:
 			pref.Where("a.lact <= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than:
+		case pasturePb.CompareSymbol_Greater_Than:
 			pref.Where("a.lact > ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Greater_Than_Or_Equal_To:
 			pref.Where("a.lact >= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Equal_To:
+		case pasturePb.CompareSymbol_Equal_To:
 			pref.Where("a.lact = ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Not_Equal_To:
+		case pasturePb.CompareSymbol_Not_Equal_To:
 			pref.Where("a.lact != ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Between:
+		case pasturePb.CompareSymbol_Between:
 			pref.Where("a.lact BETWEEN ? AND ? ", req.LactIntervalStartValue, req.LactIntervalEndValue)
 		default:
 			return nil, xerr.Custom("错误的胎次区间符号")
@@ -335,19 +335,19 @@ func (s *StoreEntry) SingleFactorAnalysisMethodOperation(ctx context.Context, re
 
 	if req.LactInterval > 0 {
 		switch req.LactInterval {
-		case pasturePb.LactIntervalSymbol_Less_Than:
+		case pasturePb.CompareSymbol_Less_Than:
 			pref.Where("lact < ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Less_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Less_Than_Or_Equal_To:
 			pref.Where("lact <= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than:
+		case pasturePb.CompareSymbol_Greater_Than:
 			pref.Where("lact > ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Greater_Than_Or_Equal_To:
 			pref.Where("lact >= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Equal_To:
+		case pasturePb.CompareSymbol_Equal_To:
 			pref.Where("lact = ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Not_Equal_To:
+		case pasturePb.CompareSymbol_Not_Equal_To:
 			pref.Where("lact != ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Between:
+		case pasturePb.CompareSymbol_Between:
 			pref.Where("lact BETWEEN ? AND ? ", req.LactIntervalStartValue, req.LactIntervalEndValue)
 		default:
 			return nil, xerr.Custom("错误的胎次区间符号")
@@ -397,19 +397,19 @@ func (s *StoreEntry) SingleFactorAnalysisMethodBull(ctx context.Context, req *pa
 
 	if req.LactInterval > 0 {
 		switch req.LactInterval {
-		case pasturePb.LactIntervalSymbol_Less_Than:
+		case pasturePb.CompareSymbol_Less_Than:
 			pref.Where("lact < ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Less_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Less_Than_Or_Equal_To:
 			pref.Where("lact <= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than:
+		case pasturePb.CompareSymbol_Greater_Than:
 			pref.Where("lact > ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Greater_Than_Or_Equal_To:
 			pref.Where("lact >= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Equal_To:
+		case pasturePb.CompareSymbol_Equal_To:
 			pref.Where("lact = ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Not_Equal_To:
+		case pasturePb.CompareSymbol_Not_Equal_To:
 			pref.Where("lact != ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Between:
+		case pasturePb.CompareSymbol_Between:
 			pref.Where("lact BETWEEN ? AND ? ", req.LactIntervalStartValue, req.LactIntervalEndValue)
 		default:
 			return nil, xerr.Custom("错误的胎次区间符号")
@@ -469,19 +469,19 @@ func (s *StoreEntry) SingleFactorAnalysisMethodWeek(ctx context.Context, req *pa
 
 	if req.LactInterval > 0 {
 		switch req.LactInterval {
-		case pasturePb.LactIntervalSymbol_Less_Than:
+		case pasturePb.CompareSymbol_Less_Than:
 			pref.Where("lact < ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Less_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Less_Than_Or_Equal_To:
 			pref.Where("lact <= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than:
+		case pasturePb.CompareSymbol_Greater_Than:
 			pref.Where("lact > ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Greater_Than_Or_Equal_To:
+		case pasturePb.CompareSymbol_Greater_Than_Or_Equal_To:
 			pref.Where("lact >= ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Equal_To:
+		case pasturePb.CompareSymbol_Equal_To:
 			pref.Where("lact = ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Not_Equal_To:
+		case pasturePb.CompareSymbol_Not_Equal_To:
 			pref.Where("lact != ?", req.LactIntervalStartValue)
-		case pasturePb.LactIntervalSymbol_Between:
+		case pasturePb.CompareSymbol_Between:
 			pref.Where("lact BETWEEN ? AND ? ", req.LactIntervalStartValue, req.LactIntervalEndValue)
 		default:
 			return nil, xerr.Custom("错误的胎次区间符号")
@@ -533,3 +533,94 @@ func (s *StoreEntry) SingleFactorAnalysisMethodLact(ctx context.Context, req *pa
 
 	return res, nil
 }
+
+func (s *StoreEntry) MultipleFactorAnalysis(ctx context.Context, req *pasturePb.MultiFactorPregnancyRateRequest) (*pasturePb.MultiFactorPregnancyRateResponse, error) {
+	startTimeUnix := util.TimeParseLocalUnix(req.StartDayTime)
+	endTimeUnix := util.TimeParseLocalEndUnix(req.EndDayTime)
+	if startTimeUnix == 0 || endTimeUnix == 0 || endTimeUnix <= startTimeUnix {
+		return nil, xerr.Custom("开始时间不能大于结束时间")
+	}
+
+	if req.XAxle == req.YAxle {
+		return nil, xerr.Custom("X轴和Y轴不能相同")
+	}
+
+	if req.XAxle == 0 || req.YAxle == 0 {
+		return nil, xerr.Custom("错误的XY轴数据")
+	}
+
+	pref := s.DB.Model(new(model.EventMating)).
+		Where("status = ?", pasturePb.IsShow_Ok).
+		Where("cow_type = ?", req.CowType)
+
+	if req.LactCompareSymbol > 0 {
+		switch req.LactCompareSymbol {
+		case pasturePb.CompareSymbol_Less_Than:
+			pref.Where("lact < ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Less_Than_Or_Equal_To:
+			pref.Where("lact <= ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Greater_Than:
+			pref.Where("lact > ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Greater_Than_Or_Equal_To:
+			pref.Where("lact >= ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Equal_To:
+			pref.Where("lact = ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Not_Equal_To:
+			pref.Where("lact != ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Between:
+			pref.Where("lact BETWEEN ? AND ? ", req.LactStartValue, req.LactEndValue)
+		}
+	}
+
+	if req.MatingTimesCompareSymbol > 0 {
+		switch req.MatingTimesCompareSymbol {
+		case pasturePb.CompareSymbol_Less_Than:
+			pref.Where("mating_number < ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Less_Than_Or_Equal_To:
+			pref.Where("mating_number <= ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Greater_Than:
+			pref.Where("mating_number > ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Greater_Than_Or_Equal_To:
+			pref.Where("mating_number >= ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Equal_To:
+			pref.Where("mating_number = ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Not_Equal_To:
+			pref.Where("mating_number != ?", req.LactStartValue)
+		case pasturePb.CompareSymbol_Between:
+			pref.Where("mating_number BETWEEN ? AND ? ", req.LactStartValue, req.LactEndValue)
+		}
+	}
+
+	if req.XAxle > 0 {
+		switch req.XAxle {
+		case pasturePb.MultiFactorAnalysisMethod_Months:
+			pref.Select(`
+				DATE_FORMAT(reality_day, '%Y-%m') AS statistic_method,
+				COUNT(DISTINCT CASE WHEN mating_result = ? AND mating_result_at > 0 THEN cow_id END) AS pregnant_count, -- 怀孕头数  
+				COUNT(DISTINCT CASE WHEN mating_result = ? AND mating_result_at > 0 THEN cow_id END) AS empty_pregnant_count, -- 空怀头数  
+				COUNT(DISTINCT CASE WHEN mating_result = ? AND mating_result_at > 0 THEN cow_id END) AS abortion_count, -- 流产头数
+			`)
+
+		}
+	}
+
+	list := make([]*pasturePb.MultiFactorPregnancyRateList, 0)
+	if err := pref.Group("statistic_method").Find(&list).Error; err != nil {
+		return nil, xerr.WithStack(err)
+	}
+
+	chart := &pasturePb.MultiFactorPregnancyRateChart{
+		Headers:      make([]string, 0),
+		PregnantRate: make(map[string]*pasturePb.PregnancyRate),
+	}
+
+	return &pasturePb.MultiFactorPregnancyRateResponse{
+		Code:    http.StatusOK,
+		Message: "ok",
+		Data: &pasturePb.MultiFactorPregnancyRateData{
+			Total: int32(len(list)),
+			List:  list,
+			Chart: chart,
+		},
+	}, nil
+}

module/backend/config_data_breed.go

@@ -140,31 +140,31 @@ func (s *StoreEntry) SingleFactorAnalysisMethodEnumList(isAll string) []*pasture
 func (s *StoreEntry) LactIntervalSymbolEnumList(isAll string) []*pasturePb.ConfigOptionsList {
 	configOptions := make([]*pasturePb.ConfigOptionsList, 0)
 	configOptions = append(configOptions, &pasturePb.ConfigOptionsList{
-		Value:    int32(pasturePb.LactIntervalSymbol_Less_Than),
+		Value:    int32(pasturePb.CompareSymbol_Less_Than),
 		Label:    "<",
 		Disabled: true,
 	}, &pasturePb.ConfigOptionsList{
-		Value:    int32(pasturePb.LactIntervalSymbol_Less_Than_Or_Equal_To),
+		Value:    int32(pasturePb.CompareSymbol_Less_Than_Or_Equal_To),
 		Label:    "<=",
 		Disabled: true,
 	}, &pasturePb.ConfigOptionsList{
-		Value:    int32(pasturePb.LactIntervalSymbol_Greater_Than),
+		Value:    int32(pasturePb.CompareSymbol_Greater_Than),
 		Label:    ">",
 		Disabled: true,
 	}, &pasturePb.ConfigOptionsList{
-		Value:    int32(pasturePb.LactIntervalSymbol_Greater_Than_Or_Equal_To),
+		Value:    int32(pasturePb.CompareSymbol_Greater_Than_Or_Equal_To),
 		Label:    ">=",
 		Disabled: true,
 	}, &pasturePb.ConfigOptionsList{
-		Value:    int32(pasturePb.LactIntervalSymbol_Equal_To),
+		Value:    int32(pasturePb.CompareSymbol_Equal_To),
 		Label:    "=",
 		Disabled: true,
 	}, &pasturePb.ConfigOptionsList{
-		Value:    int32(pasturePb.LactIntervalSymbol_Not_Equal_To),
+		Value:    int32(pasturePb.CompareSymbol_Not_Equal_To),
 		Label:    "!=",
 		Disabled: true,
 	}, &pasturePb.ConfigOptionsList{
-		Value:    int32(pasturePb.LactIntervalSymbol_Between),
+		Value:    int32(pasturePb.CompareSymbol_Between),
 		Label:    "区间",
 		Disabled: true,
 	})

module/backend/cow.go

@@ -14,13 +14,18 @@ import (
 func (s *StoreEntry) CowList(ctx context.Context, req *pasturePb.SearchEventRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchCowListResponse, error) {
 	cowList := make([]*model.Cow, 0)
 	var count int64 = 0
-	pref := s.DB.Model(&model.Cow{}).Where("admission_status = ?", pasturePb.AdmissionStatus_Admission)
+	pref := s.DB.Model(&model.Cow{}).
+		Where("admission_status = ?", pasturePb.AdmissionStatus_Admission)
 
 	if len(req.CowId) > 0 {
 		cowIds := strings.Split(req.CowId, ",")
 		pref.Where("id IN ?", cowIds)
 	}
 
+	if req.EarNumber != "" {
+		pref.Where("ear_number LIKE ?", "%"+req.EarNumber+"%")
+	}
+
 	if err := pref.Order("id desc").
 		Count(&count).Limit(int(pagination.PageSize)).
 		Offset(int(pagination.PageOffset)).

module/backend/interface.go

@@ -217,6 +217,7 @@ type AnalyseService interface {
 	CalvingReport(ctx context.Context, req *pasturePb.CalvingReportRequest) (*pasturePb.CalvingReportResponse, error)
 	DiseaseCureReport(ctx context.Context, req *pasturePb.DiseaseCureRateRequest) (*pasturePb.DiseaseCureRateResponse, error)
 	SingleFactorInfantSurvivalRateAnalysis(ctx context.Context, req *pasturePb.SingleFactorPregnancyRateRequest) (*pasturePb.SingleFactorPregnancyRateResponse, error)
+	MultipleFactorAnalysis(ctx context.Context, req *pasturePb.MultiFactorPregnancyRateRequest) (*pasturePb.MultiFactorPregnancyRateResponse, error)
 }
 
 //go:generate mockgen -destination mock/DashboardService.go -package kptservicemock kpt-pasture/module/backend DashboardService

module/backend/mock/kptservice.go

@@ -6,6 +6,7 @@ package kptservicemock
 
 import (
 	context "context"
+	model "kpt-pasture/model"
 	reflect "reflect"
 
 	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
@@ -35,6 +36,64 @@ func (m *MockKptService) EXPECT() *MockKptServiceMockRecorder {
 	return m.recorder
 }
 
+// AbortionCreate mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) AbortionCreate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	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 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AbortionCreateSlice", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AbortionCreateSlice indicates an expected call of AbortionCreateSlice.
+func (mr *MockKptServiceMockRecorder) AbortionCreateSlice(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)
+}
+
+// AbortionList mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) AbortionList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionList", reflect.TypeOf((*MockKptService)(nil).AbortionList), arg0, arg1, arg2)
+}
+
+// AbortionRate mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) AbortionRate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortionRate", reflect.TypeOf((*MockKptService)(nil).AbortionRate), arg0, arg1)
+}
+
 // Bar mocks base method.
 func (m *MockKptService) Bar(arg0 context.Context) (*cowPb.BarCowStructResponse, error) {
 	m.ctrl.T.Helper()
@@ -51,18 +110,18 @@ func (mr *MockKptServiceMockRecorder) Bar(arg0 interface{}) *gomock.Call {
 }
 
 // BarnListOptions mocks base method.
-func (m *MockKptService) BarnListOptions(arg0 context.Context, arg1 int) (*cowPb.ConfigOptionsListResponse, error) {
+func (m *MockKptService) BarnListOptions(arg0 context.Context, arg1 int, arg2 string) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BarnListOptions", arg0, arg1)
+	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 *MockKptServiceMockRecorder) BarnListOptions(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockKptServiceMockRecorder) BarnListOptions(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BarnListOptions", reflect.TypeOf((*MockKptService)(nil).BarnListOptions), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BarnListOptions", reflect.TypeOf((*MockKptService)(nil).BarnListOptions), arg0, arg1, arg2)
 }
 
 // BarnTypeOptions mocks base method.
@@ -125,8 +184,53 @@ func (mr *MockKptServiceMockRecorder) BullOptions(arg0 interface{}) *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BullOptions", reflect.TypeOf((*MockKptService)(nil).BullOptions), arg0)
 }
 
+// CalendarList mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CalendarList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalendarList", reflect.TypeOf((*MockKptService)(nil).CalendarList), arg0, arg1)
+}
+
+// CalendarTableDetail mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CalendarTableDetail(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalendarTableDetail", reflect.TypeOf((*MockKptService)(nil).CalendarTableDetail), arg0, arg1, arg2)
+}
+
+// CalendarToDoList mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CalendarToDoList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalendarToDoList", reflect.TypeOf((*MockKptService)(nil).CalendarToDoList), arg0, arg1, arg2)
+}
+
 // CalvingCreate mocks base method.
-func (m *MockKptService) CalvingCreate(arg0 context.Context, arg1 *cowPb.CalvingEventRequest) error {
+func (m *MockKptService) CalvingCreate(arg0 context.Context, arg1 *cowPb.EventCalving) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CalvingCreate", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -154,6 +258,107 @@ func (mr *MockKptServiceMockRecorder) CalvingList(arg0, arg1, arg2 interface{})
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalvingList", reflect.TypeOf((*MockKptService)(nil).CalvingList), arg0, arg1, arg2)
 }
 
+// CalvingReport mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CalvingReport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalvingReport", reflect.TypeOf((*MockKptService)(nil).CalvingReport), arg0, arg1)
+}
+
+// CowDiseaseCreate mocks base method.
+func (m *MockKptService) CowDiseaseCreate(arg0 context.Context, arg1 *cowPb.EventCowDiseaseRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CowDiseaseCreate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CowDiseaseCreate indicates an expected call of CowDiseaseCreate.
+func (mr *MockKptServiceMockRecorder) CowDiseaseCreate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseCreate", reflect.TypeOf((*MockKptService)(nil).CowDiseaseCreate), arg0, arg1)
+}
+
+// CowDiseaseCurable mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CowDiseaseCurable(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseCurable", reflect.TypeOf((*MockKptService)(nil).CowDiseaseCurable), arg0, arg1)
+}
+
+// CowDiseaseDiagnose mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CowDiseaseDiagnose(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseDiagnose", reflect.TypeOf((*MockKptService)(nil).CowDiseaseDiagnose), arg0, arg1)
+}
+
+// CowDiseaseList mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CowDiseaseList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseList", reflect.TypeOf((*MockKptService)(nil).CowDiseaseList), arg0, arg1, arg2)
+}
+
+// CowDiseaseTreatment mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CowDiseaseTreatment(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseTreatment", reflect.TypeOf((*MockKptService)(nil).CowDiseaseTreatment), arg0, arg1)
+}
+
+// CowDiseaseTreatmentDetail mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) CowDiseaseTreatmentDetail(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowDiseaseTreatmentDetail", reflect.TypeOf((*MockKptService)(nil).CowDiseaseTreatmentDetail), arg0, arg1, arg2)
+}
+
 // CowKindOptions mocks base method.
 func (m *MockKptService) CowKindOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
@@ -199,21 +404,6 @@ func (mr *MockKptServiceMockRecorder) CowSourceOptions(arg0 interface{}) *gomock
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowSourceOptions", reflect.TypeOf((*MockKptService)(nil).CowSourceOptions), arg0)
 }
 
-// CowStatusOptions mocks base method.
-func (m *MockKptService) CowStatusOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CowStatusOptions", arg0)
-	ret0, _ := ret[0].(*cowPb.ConfigOptionsListResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CowStatusOptions indicates an expected call of CowStatusOptions.
-func (mr *MockKptServiceMockRecorder) CowStatusOptions(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowStatusOptions", reflect.TypeOf((*MockKptService)(nil).CowStatusOptions), arg0)
-}
-
 // CowTransferPenReasonOptions mocks base method.
 func (m *MockKptService) CowTransferPenReasonOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
@@ -230,18 +420,18 @@ func (mr *MockKptServiceMockRecorder) CowTransferPenReasonOptions(arg0 interface
 }
 
 // CowTypeOptions mocks base method.
-func (m *MockKptService) CowTypeOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+func (m *MockKptService) CowTypeOptions(arg0 context.Context, arg1, arg2 string) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CowTypeOptions", arg0)
+	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 *MockKptServiceMockRecorder) CowTypeOptions(arg0 interface{}) *gomock.Call {
+func (mr *MockKptServiceMockRecorder) CowTypeOptions(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowTypeOptions", reflect.TypeOf((*MockKptService)(nil).CowTypeOptions), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CowTypeOptions", reflect.TypeOf((*MockKptService)(nil).CowTypeOptions), arg0, arg1, arg2)
 }
 
 // CreateBodyScore mocks base method.
@@ -259,7 +449,7 @@ func (mr *MockKptServiceMockRecorder) CreateBodyScore(arg0, arg1 interface{}) *g
 }
 
 // CreateEnter mocks base method.
-func (m *MockKptService) CreateEnter(arg0 context.Context, arg1 *cowPb.SearchEnterData) error {
+func (m *MockKptService) CreateEnter(arg0 context.Context, arg1 *cowPb.EventEnterRequest) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateEnter", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -426,18 +616,18 @@ func (mr *MockKptServiceMockRecorder) CreateOrUpdatePrescription(arg0, arg1 inte
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdatePrescription", reflect.TypeOf((*MockKptService)(nil).CreateOrUpdatePrescription), arg0, arg1)
 }
 
-// CreateOrUpdateSemeTime mocks base method.
-func (m *MockKptService) CreateOrUpdateSemeTime(arg0 context.Context, arg1 *cowPb.SemeTimeRequest) error {
+// CreateOrUpdateSameTime mocks base method.
+func (m *MockKptService) CreateOrUpdateSameTime(arg0 context.Context, arg1 *cowPb.SearchSameTimeList) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateOrUpdateSemeTime", arg0, arg1)
+	ret := m.ctrl.Call(m, "CreateOrUpdateSameTime", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// CreateOrUpdateSemeTime indicates an expected call of CreateOrUpdateSemeTime.
-func (mr *MockKptServiceMockRecorder) CreateOrUpdateSemeTime(arg0, arg1 interface{}) *gomock.Call {
+// CreateOrUpdateSameTime indicates an expected call of CreateOrUpdateSameTime.
+func (mr *MockKptServiceMockRecorder) CreateOrUpdateSameTime(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateSemeTime", reflect.TypeOf((*MockKptService)(nil).CreateOrUpdateSemeTime), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateSameTime", reflect.TypeOf((*MockKptService)(nil).CreateOrUpdateSameTime), arg0, arg1)
 }
 
 // CreateOrUpdateSystemMenu mocks base method.
@@ -468,20 +658,6 @@ func (mr *MockKptServiceMockRecorder) CreateOrUpdateTransferPenReason(arg0, arg1
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTransferPenReason", reflect.TypeOf((*MockKptService)(nil).CreateOrUpdateTransferPenReason), arg0, arg1)
 }
 
-// CreateWeight mocks base method.
-func (m *MockKptService) CreateWeight(arg0 context.Context, arg1 *cowPb.WeightEventRequest) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateWeight", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// CreateWeight indicates an expected call of CreateWeight.
-func (mr *MockKptServiceMockRecorder) CreateWeight(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWeight", reflect.TypeOf((*MockKptService)(nil).CreateWeight), arg0, arg1)
-}
-
 // CreatedOrUpdateImmunization mocks base method.
 func (m *MockKptService) CreatedOrUpdateImmunization(arg0 context.Context, arg1 *cowPb.ImmunizationRequest) error {
 	m.ctrl.T.Helper()
@@ -538,6 +714,21 @@ func (mr *MockKptServiceMockRecorder) DeleteSystemUser(arg0, arg1 interface{}) *
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSystemUser", reflect.TypeOf((*MockKptService)(nil).DeleteSystemUser), arg0, arg1)
 }
 
+// DiseaseCureReport mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) DiseaseCureReport(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseCureReport", reflect.TypeOf((*MockKptService)(nil).DiseaseCureReport), arg0, arg1)
+}
+
 // DiseaseOptions mocks base method.
 func (m *MockKptService) DiseaseOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
@@ -554,32 +745,32 @@ func (mr *MockKptServiceMockRecorder) DiseaseOptions(arg0 interface{}) *gomock.C
 }
 
 // DiseaseTypeOptions mocks base method.
-func (m *MockKptService) DiseaseTypeOptions(arg0 context.Context) (*cowPb.ConfigOptionsListResponse, error) {
+func (m *MockKptService) DiseaseTypeOptions(arg0 context.Context, arg1 string) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DiseaseTypeOptions", arg0)
+	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 *MockKptServiceMockRecorder) DiseaseTypeOptions(arg0 interface{}) *gomock.Call {
+func (mr *MockKptServiceMockRecorder) DiseaseTypeOptions(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseTypeOptions", reflect.TypeOf((*MockKptService)(nil).DiseaseTypeOptions), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiseaseTypeOptions", reflect.TypeOf((*MockKptService)(nil).DiseaseTypeOptions), arg0, arg1)
 }
 
-// DrugsCreate mocks base method.
-func (m *MockKptService) DrugsCreate(arg0 context.Context, arg1 *cowPb.SearchDrugsList) error {
+// DrugsCreateOrUpdate mocks base method.
+func (m *MockKptService) DrugsCreateOrUpdate(arg0 context.Context, arg1 *cowPb.SearchDrugsList) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DrugsCreate", arg0, arg1)
+	ret := m.ctrl.Call(m, "DrugsCreateOrUpdate", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// DrugsCreate indicates an expected call of DrugsCreate.
-func (mr *MockKptServiceMockRecorder) DrugsCreate(arg0, arg1 interface{}) *gomock.Call {
+// DrugsCreateOrUpdate indicates an expected call of DrugsCreateOrUpdate.
+func (mr *MockKptServiceMockRecorder) DrugsCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DrugsCreate", reflect.TypeOf((*MockKptService)(nil).DrugsCreate), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DrugsCreateOrUpdate", reflect.TypeOf((*MockKptService)(nil).DrugsCreateOrUpdate), arg0, arg1)
 }
 
 // DrugsList mocks base method.
@@ -613,7 +804,7 @@ func (mr *MockKptServiceMockRecorder) EnterList(arg0, arg1, arg2 interface{}) *g
 }
 
 // EstrusCreate mocks base method.
-func (m *MockKptService) EstrusCreate(arg0 context.Context, arg1 *cowPb.EstrusEventRequest) error {
+func (m *MockKptService) EstrusCreate(arg0 context.Context, arg1 *cowPb.EventEstrus) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EstrusCreate", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -818,7 +1009,7 @@ func (mr *MockKptServiceMockRecorder) Login(arg0, arg1 interface{}) *gomock.Call
 }
 
 // MatingCreate mocks base method.
-func (m *MockKptService) MatingCreate(arg0 context.Context, arg1 *cowPb.MatingEventRequest) error {
+func (m *MockKptService) MatingCreate(arg0 context.Context, arg1 *cowPb.EventMating) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "MatingCreate", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -846,8 +1037,140 @@ func (mr *MockKptServiceMockRecorder) MatingList(arg0, arg1, arg2 interface{}) *
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatingList", reflect.TypeOf((*MockKptService)(nil).MatingList), arg0, arg1, arg2)
 }
 
+// MatingTimely mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) MatingTimely(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatingTimely", reflect.TypeOf((*MockKptService)(nil).MatingTimely), arg0, arg1)
+}
+
+// MedicalEquipmentCreateOrUpdate mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) MedicalEquipmentCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MedicalEquipmentCreateOrUpdate", reflect.TypeOf((*MockKptService)(nil).MedicalEquipmentCreateOrUpdate), arg0, arg1)
+}
+
+// MedicalEquipmentList mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) MedicalEquipmentList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MedicalEquipmentList", reflect.TypeOf((*MockKptService)(nil).MedicalEquipmentList), arg0, arg1, arg2)
+}
+
+// MultipleFactorAnalysis mocks base method.
+func (m *MockKptService) MultipleFactorAnalysis(arg0 context.Context, arg1 *cowPb.MultiFactorPregnancyRateRequest) (*cowPb.MultiFactorPregnancyRateResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MultipleFactorAnalysis", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.MultiFactorPregnancyRateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MultipleFactorAnalysis indicates an expected call of MultipleFactorAnalysis.
+func (mr *MockKptServiceMockRecorder) MultipleFactorAnalysis(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultipleFactorAnalysis", reflect.TypeOf((*MockKptService)(nil).MultipleFactorAnalysis), arg0, arg1)
+}
+
+// OrderCreateOrUpdate mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) OrderCreateOrUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderCreateOrUpdate", reflect.TypeOf((*MockKptService)(nil).OrderCreateOrUpdate), arg0, arg1)
+}
+
+// OrderIsShow mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) OrderIsShow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderIsShow", reflect.TypeOf((*MockKptService)(nil).OrderIsShow), arg0, arg1)
+}
+
+// OrderList mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) OrderList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrderList", reflect.TypeOf((*MockKptService)(nil).OrderList), 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()
+	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 *MockKptServiceMockRecorder) PenWeight(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PenWeight", reflect.TypeOf((*MockKptService)(nil).PenWeight), 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()
+	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 *MockKptServiceMockRecorder) PregnancyReport(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	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.PregnantCheckEventRequest) error {
+func (m *MockKptService) PregnantCheckCreate(arg0 context.Context, arg1 *cowPb.EventPregnantCheck) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PregnantCheckCreate", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -875,6 +1198,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)
 }
 
+// PrescriptionOptions mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) PrescriptionOptions(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrescriptionOptions", reflect.TypeOf((*MockKptService)(nil).PrescriptionOptions), arg0)
+}
+
 // ResetPasswordSystemUser mocks base method.
 func (m *MockKptService) ResetPasswordSystemUser(arg0 context.Context, arg1 *cowPb.ResetUserPasswordRequest) error {
 	m.ctrl.T.Helper()
@@ -903,6 +1241,49 @@ func (mr *MockKptServiceMockRecorder) RoleMenuSave(arg0, arg1 interface{}) *gomo
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoleMenuSave", reflect.TypeOf((*MockKptService)(nil).RoleMenuSave), arg0, arg1)
 }
 
+// SameTimeCreate mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) SameTimeCreate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeCreate", reflect.TypeOf((*MockKptService)(nil).SameTimeCreate), arg0, arg1)
+}
+
+// SameTimeIsShow mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) SameTimeIsShow(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeIsShow", reflect.TypeOf((*MockKptService)(nil).SameTimeIsShow), arg0, arg1)
+}
+
+// SameTimeList mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) SameTimeList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SameTimeList", reflect.TypeOf((*MockKptService)(nil).SameTimeList), arg0, arg1, arg2)
+}
+
 // SearchBarnList mocks base method.
 func (m *MockKptService) SearchBarnList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBarnResponse, error) {
 	m.ctrl.T.Helper()
@@ -1053,19 +1434,19 @@ func (mr *MockKptServiceMockRecorder) SearchPrescriptionList(arg0, arg1, arg2 in
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchPrescriptionList", reflect.TypeOf((*MockKptService)(nil).SearchPrescriptionList), arg0, arg1, arg2)
 }
 
-// SearchSemeTimeList mocks base method.
-func (m *MockKptService) SearchSemeTimeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SemeTimeEventResponse, error) {
+// SearchSameTimeList mocks base method.
+func (m *MockKptService) SearchSameTimeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SameTimeResponse, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SearchSemeTimeList", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*cowPb.SemeTimeEventResponse)
+	ret := m.ctrl.Call(m, "SearchSameTimeList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*cowPb.SameTimeResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// SearchSemeTimeList indicates an expected call of SearchSemeTimeList.
-func (mr *MockKptServiceMockRecorder) SearchSemeTimeList(arg0, arg1, arg2 interface{}) *gomock.Call {
+// SearchSameTimeList indicates an expected call of SearchSameTimeList.
+func (mr *MockKptServiceMockRecorder) SearchSameTimeList(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSemeTimeList", reflect.TypeOf((*MockKptService)(nil).SearchSemeTimeList), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchSameTimeList", reflect.TypeOf((*MockKptService)(nil).SearchSameTimeList), arg0, arg1, arg2)
 }
 
 // SearchSystemDeptList mocks base method.
@@ -1143,34 +1524,34 @@ func (mr *MockKptServiceMockRecorder) SearchTransferPenReasonList(arg0, arg1, ar
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransferPenReasonList", reflect.TypeOf((*MockKptService)(nil).SearchTransferPenReasonList), arg0, arg1, arg2)
 }
 
-// SemeTimeDetail mocks base method.
-func (m *MockKptService) SemeTimeDetail(arg0 context.Context, arg1 int64) (*cowPb.SemeTimeDetailResponse, error) {
+// SingleFactorInfantSurvivalRateAnalysis mocks base method.
+func (m *MockKptService) SingleFactorInfantSurvivalRateAnalysis(arg0 context.Context, arg1 *cowPb.SingleFactorPregnancyRateRequest) (*cowPb.SingleFactorPregnancyRateResponse, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SemeTimeDetail", arg0, arg1)
-	ret0, _ := ret[0].(*cowPb.SemeTimeDetailResponse)
+	ret := m.ctrl.Call(m, "SingleFactorInfantSurvivalRateAnalysis", arg0, arg1)
+	ret0, _ := ret[0].(*cowPb.SingleFactorPregnancyRateResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// SemeTimeDetail indicates an expected call of SemeTimeDetail.
-func (mr *MockKptServiceMockRecorder) SemeTimeDetail(arg0, arg1 interface{}) *gomock.Call {
+// SingleFactorInfantSurvivalRateAnalysis indicates an expected call of SingleFactorInfantSurvivalRateAnalysis.
+func (mr *MockKptServiceMockRecorder) SingleFactorInfantSurvivalRateAnalysis(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SemeTimeDetail", reflect.TypeOf((*MockKptService)(nil).SemeTimeDetail), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SingleFactorInfantSurvivalRateAnalysis", reflect.TypeOf((*MockKptService)(nil).SingleFactorInfantSurvivalRateAnalysis), arg0, arg1)
 }
 
 // SystemBaseConfigOptions mocks base method.
-func (m *MockKptService) SystemBaseConfigOptions(arg0 context.Context, arg1 string) (*cowPb.ConfigOptionsListResponse, error) {
+func (m *MockKptService) SystemBaseConfigOptions(arg0 context.Context, arg1, arg2 string) (*cowPb.ConfigOptionsListResponse, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SystemBaseConfigOptions", arg0, arg1)
+	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 *MockKptServiceMockRecorder) SystemBaseConfigOptions(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockKptServiceMockRecorder) SystemBaseConfigOptions(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemBaseConfigOptions", reflect.TypeOf((*MockKptService)(nil).SystemBaseConfigOptions), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemBaseConfigOptions", reflect.TypeOf((*MockKptService)(nil).SystemBaseConfigOptions), arg0, arg1, arg2)
 }
 
 // SystemDepDelete mocks base method.
@@ -1303,6 +1684,50 @@ func (mr *MockKptServiceMockRecorder) SystemUserRoleSave(arg0, arg1 interface{})
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SystemUserRoleSave", reflect.TypeOf((*MockKptService)(nil).SystemUserRoleSave), arg0, arg1)
 }
 
+// TwentyOnePregnantRate mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) TwentyOnePregnantRate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TwentyOnePregnantRate", reflect.TypeOf((*MockKptService)(nil).TwentyOnePregnantRate), 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()
+	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 *MockKptServiceMockRecorder) UserWorkOrderList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	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 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WeightCreate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// WeightCreate indicates an expected call of WeightCreate.
+func (mr *MockKptServiceMockRecorder) WeightCreate(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)
+}
+
 // WeightList mocks base method.
 func (m *MockKptService) WeightList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchWeightEventResponse, error) {
 	m.ctrl.T.Helper()
@@ -1317,3 +1742,18 @@ func (mr *MockKptServiceMockRecorder) WeightList(arg0, arg1, arg2 interface{}) *
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeightList", reflect.TypeOf((*MockKptService)(nil).WeightList), arg0, arg1, arg2)
 }
+
+// WeightRange mocks base method.
+func (m *MockKptService) 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 *MockKptServiceMockRecorder) WeightRange(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WeightRange", reflect.TypeOf((*MockKptService)(nil).WeightRange), arg0, arg1)
+}