kpt-pasture/module/crontab/neck_ring_estrus.go

package crontab

import (
	"kpt-pasture/model"
	"time"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"

	"gitee.com/xuyiping_admin/pkg/logger/zaplog"
	"go.uber.org/zap"

	"gitee.com/xuyiping_admin/pkg/xerr"
)

const (
	MaxRuminaAdJust = 20
	XAdjust21       = 15
	XAdjust42       = 10
	RumtoHeat       = 0.5
	MinCalvingAge   = 20
	MinLact         = 0
	NormalChangJust = 10
)

func (e *Entry) PastureUpdateCowEstrus() (err error) {
	pastureList := e.FindPastureList()
	if pastureList == nil || len(pastureList) == 0 {
		return nil
	}

	for _, pasture := range pastureList {
		if err = e.EntryCowEstrus(pasture.Id); err != nil {
			zaplog.Error("EntryCrontab", zap.Any("PastureUpdateCowEstrus", err), zap.Any("pasture", pasture))
		}
		zaplog.Error("PastureUpdateCowEstrus-success", zap.Any("pasture", pasture.Id))
	}
	return nil
}

func (e *Entry) EntryCowEstrus(pastureId int64) (err error) {
	activeLowValue := e.GetSystemConfigure(pastureId, model.ActiveLow).Value
	activeMiddleValue := e.GetSystemConfigure(pastureId, model.ActiveMiddle).Value
	activeHighValue := e.GetSystemConfigure(pastureId, model.ActiveHigh).Value
	lastMaxEstrusId := e.GetSystemConfigure(pastureId, model.MaxEstrus).Value

	currentMaxHabit := &model.NeckActiveHabit{}
	if err = e.DB.Model(new(model.NeckActiveHabit)).
		Where("id > ?", lastMaxEstrusId).
		Order("id desc").
		First(currentMaxHabit).Error; err != nil {
		return xerr.WithStack(err)
	}
	// 当前Id<=上次执行的id，则不执行
	if currentMaxHabit.Id <= lastMaxEstrusId {
		return nil
	}

	defer func() {
		if err == nil {
			e.DB.Model(new(model.SystemConfigure)).
				Where("name = ?", model.MaxEstrus).
				Update("value", currentMaxHabit.Id)
		}
	}()

	xToday := &XToday{}
	if err = e.DB.Model(new(model.NeckActiveHabit)).
		Select(`MIN(heat_date) as x_beg_date, MAX(heat_date) as x_end_date`).
		Where("id BETWEEN ? AND ?", lastMaxEstrusId, currentMaxHabit.Id).
		First(xToday).Error; err != nil {
		return xerr.WithStack(err)
	}

	xToday.LastMaxHabitId = lastMaxEstrusId
	xToday.CurrMaxHabitId = currentMaxHabit.Id
	xToday.ActiveLow = activeLowValue
	xToday.ActiveMiddle = activeMiddleValue
	xToday.ActiveHigh = activeHighValue
	if err = e.CowEstrusWarning(xToday); err != nil {
		zaplog.Error("EntryCowEstrus", zap.Any("CowEstrusWarning", err), zap.Any("xToday", xToday))
	}
	return nil
}

// CowEstrusWarning 发情预警
func (e *Entry) CowEstrusWarning(xToday *XToday) (err error) {
	startDate, _ := time.Parse(model.LayoutDate2, xToday.XBegDate)
	endDate, _ := time.Parse(model.LayoutDate2, xToday.XEndDate)

	for startDate.Format(model.LayoutDate2) <= endDate.Format(model.LayoutDate2) {
		neckActiveHabitList := make([]*model.NeckActiveHabit, 0)
		if err = e.DB.Model(new(model.NeckActiveHabit)).
			Select("*,MAX(filter_high) as filter_high").
			Where("id BETWEEN ? AND ?", xToday.LastMaxHabitId, xToday.CurrMaxHabitId).
			Where("heat_date = ?", startDate.Format(model.LayoutDate2)).
			Where("cow_id > ?", 0).
			Where(e.DB.Where("calving_age > ?", MinCalvingAge).Or("lact = ?", MinLact)).
			Group("neck_ring_number").
			Find(&neckActiveHabitList).
			Error; err != nil {
			zaplog.Error("CowEstrusWarning", zap.Any("FindNeckActiveHabit", err), zap.Any("xToday", xToday))
			continue
		}

		eventEstrusList := make([]*model.EventEstrus, 0)
		for _, v := range neckActiveHabitList {
			if ok := e.IsAdJustLow(xToday, v); ok {
				continue
			}
			cft := float32(0)
			if v.ChangeAdjust > 10 {
				cft = float32(v.ChangeFilter) - float32(v.ChangeAdjust) + 3
			} else {
				value := float32(0)
				switch {
				case v.RuminaFilter > MaxRuminaAdJust:
					value = float32(5)
				case v.RuminaFilter > 0:
					value = float32(v.RuminaFilter) * 0.25
				case v.RuminaFilter < -MaxRuminaAdJust:
					value = -MaxRuminaAdJust * RumtoHeat
				default:
					value = float32(v.RuminaFilter) * RumtoHeat
				}
				cft = float32(v.ChangeFilter)*float32(v.FilterCorrect)/100 - value
			}

			// 最近3天最大发情记录，小于该变化趋势的不再插入
			eventEstrus := e.GetBeforeThreeDaysCowEstrus(v.CowId, startDate.AddDate(0, 0, -2).Format(model.LayoutTime))
			if int32(cft) <= eventEstrus.DaylongHigh {
				continue
			}

			// 判断最近50天内是否存在发情记录（发情等级>=2）,如果18～25天@xadjust21，如果36～50天@xadjust42
			cowEstrus := e.GetTwoEstrus(v.CowId, startDate.AddDate(0, 0, -100).Format(model.LayoutTime), startDate.AddDate(0, 0, -2).Format(model.LayoutTime))
			activeDateTime, _ := time.Parse(model.LayoutTime, cowEstrus.ActiveDate)
			if activeDateTime.Unix() >= startDate.AddDate(0, 0, -25).Unix() && activeDateTime.Unix() <= startDate.AddDate(0, 0, -18).Unix() {
				cowEstrus.HadJust = XAdjust21
			}
			if activeDateTime.Unix() >= startDate.AddDate(0, 0, -50).Unix() && activeDateTime.Unix() <= startDate.AddDate(0, 0, -36).Unix() {
				cowEstrus.HadJust = XAdjust42
			}

			if int32(cft)+cowEstrus.HadJust <= int32(xToday.ActiveLow) {
				continue
			}

			cowInfo := e.FindCowInfoByNeckRingNumber(v.NeckRingNumber)
			level := pasturePb.EstrusLevel_High
			if int32(cft)+cowEstrus.HadJust < int32(xToday.ActiveMiddle) {
				level = pasturePb.EstrusLevel_Low
			}
			if int32(cft)+cowEstrus.HadJust >= int32(xToday.ActiveHigh) {
				level = pasturePb.EstrusLevel_Middle
			}

			result := pasturePb.EstrusResult_Invalid
			if eventEstrus.Result == pasturePb.EstrusResult_Fail && eventEstrus.DaylongHigh > int32(cft)+cowEstrus.HadJust {
				result = pasturePb.EstrusResult_Fail
			}
			// todo 待定
			if result == pasturePb.EstrusResult_Invalid {
				result = pasturePb.EstrusResult_Correct
			}

			// 更新 已孕 + 不显示
			isShow := pasturePb.IsShow_Ok
			if cowInfo.IsPregnant == pasturePb.IsShow_Ok && level == pasturePb.EstrusLevel_Low {
				isShow = pasturePb.IsShow_No
			}

			eventEstrusList = append(eventEstrusList, &model.EventEstrus{
				CowId:            cowInfo.Id,
				Lact:             cowInfo.Lact,
				ExposeEstrusType: pasturePb.ExposeEstrusType_Natural_Estrus,
				FilterHigh:       v.FilterHigh,
				EstrusDate:       v.ActiveTime,
				ActiveDate:       v.ActiveTime,
				LastEstrusDate:   cowEstrus.ActiveDate,
				Level:            level,
				IsPeak:           pasturePb.IsShow_No,
				DaylongHigh:      int32(cft) + cowEstrus.HadJust,
				Result:           result,
				IsShow:           isShow,
			})
		}
		if len(eventEstrusList) > 0 {
			if err = e.DB.Create(eventEstrusList).Error; err != nil {
				zaplog.Error("CowEstrusWarning", zap.Any("eventEstrusList", eventEstrusList), zap.Any("err", err))
			}
		}
		startDate = startDate.AddDate(0, 0, 1)
	}
	return nil
}

// UpdateNewEstrus 更新新发情数据
func (e *Entry) UpdateNewEstrus(xToday *XToday) (err error) {

	return nil
}

// IsAdJustLow 是否低于最低活动量
func (e *Entry) IsAdJustLow(xToday *XToday, habit *model.NeckActiveHabit) bool {
	ruminaAdJust := float64(0)
	switch {
	case habit.RuminaFilter > MaxRuminaAdJust:
		ruminaAdJust = 5
	case habit.RuminaFilter > 0:
		ruminaAdJust = float64(habit.RuminaFilter) * 0.25
	case habit.RuminaFilter < -MaxRuminaAdJust:
		ruminaAdJust = -MaxRuminaAdJust * RumtoHeat
	default:
		ruminaAdJust = float64(habit.RuminaFilter) * RumtoHeat
	}
	ruminaAdJustSum := int32(float64(habit.FilterCorrect)/100 - ruminaAdJust)
	isContinue := int32(0)
	activeLow := xToday.ActiveLow - XAdjust21
	if habit.ChangeFilter >= NormalChangJust {
		isContinue = habit.ChangeFilter - habit.ChangeAdjust + 3*ruminaAdJustSum
	} else {
		isContinue = habit.ChangeFilter * ruminaAdJustSum
	}

	if isContinue < int32(activeLow) {
		return true
	}
	return false
}