kpt-pasture/http/handler/analysis/analysis.go

package analysis

import (
	"kpt-pasture/http/middleware"
	"net/http"

	"gitee.com/xuyiping_admin/pkg/valid"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
	"gitee.com/xuyiping_admin/pkg/apierr"
	"gitee.com/xuyiping_admin/pkg/ginutil"
	"github.com/gin-gonic/gin"
)

func WeightScatterPlot(c *gin.Context) {
	var req pasturePb.SearchGrowthCurvesRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	pagination := &pasturePb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.WeightScatterPlot(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	ginutil.JSONResp(c, res)
}

func WeightRange(c *gin.Context) {
	var req pasturePb.WeightRangeRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.MaxWeight, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	pagination := &pasturePb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.WeightRange(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	ginutil.JSONResp(c, res)
}

func MatingTimeLy(c *gin.Context) {
	var req pasturePb.MatingTimelyRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.StartDayAt, valid.Required),
		valid.Field(&req.EndDayAt, valid.Required),
		valid.Field(&req.CowType, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.MatingTimely(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	c.JSON(http.StatusOK, res)
}

func PenWeight(c *gin.Context) {
	var req pasturePb.PenWeightRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	pagination := &pasturePb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.PenWeight(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func TwentyOnePregnantRate(c *gin.Context) {
	var req pasturePb.TwentyOnePregnantRateRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.StartDate, valid.Required),
		valid.Field(&req.EndDate, valid.Required),
		valid.Field(&req.CowType, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.TwentyOnePregnantRate(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func AbortionRate(c *gin.Context) {
	var req pasturePb.AbortionRateRequest
	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),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.AbortionRate(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func PregnancyReport(c *gin.Context) {
	var req pasturePb.PregnancyReportRequest
	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),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	pagination := &pasturePb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.PregnancyReport(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func CalvingReport(c *gin.Context) {
	var req pasturePb.CalvingReportRequest
	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.LateLabor, valid.Required),
		valid.Field(&req.PrematureLabor, valid.Required),
		valid.Field(&req.AnalysisMethod, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.CalvingReport(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func DiseaseCureReport(c *gin.Context) {
	var req pasturePb.DiseaseCureRateRequest
	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.AnalysisMethod, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.DiseaseCureReport(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func SaleCowReport(c *gin.Context) {
	var req pasturePb.SaleCowReportRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.StartDay, valid.Required),
		valid.Field(&req.EndDay, valid.Required),
		valid.Field(&req.AnalysisMethod, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.SaleCowReport(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func SingleFactorInfantSurvivalRate(c *gin.Context) {
	var req pasturePb.SingleFactorPregnancyRateRequest
	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.AnalysisMethod, valid.Required),
		valid.Field(&req.CowType, valid.Required),
		valid.Field(&req.LactInterval, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.SingleFactorInfantSurvivalRateAnalysis(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	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
	}

	c.JSON(http.StatusOK, res)
}

func PenBehaviorAnalysis(c *gin.Context) {
	var req pasturePb.BarnBehaviorCurveRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.StartAt, valid.Required),
		valid.Field(&req.EndAt, valid.Required),
		valid.Field(&req.PenId, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.PenBehavior(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	c.JSON(http.StatusOK, res)
}

func PenBehaviorDaily(c *gin.Context) {
	var req pasturePb.BarnMonitorRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.StartAt, valid.Required),
		valid.Field(&req.EndAt, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.PenBehaviorDaily(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	c.JSON(http.StatusOK, res)
}