kpt-pasture/module/crontab/estrus_warning.go

package crontab

import (
	"context"
	"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"

	"github.com/hibiken/asynq"
)

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

func (e *Entry) EntryCowEstrus(ctx context.Context, t *asynq.Task) error {
	activeLowValue := e.GetSystemConfigure(model.ActiveLow).Value
	activeMiddleValue := e.GetSystemConfigure(model.ActiveMiddle).Value
	activeHighValue := e.GetSystemConfigure(model.ActiveHigh).Value
	lastMaxEstrusId := e.GetSystemConfigure(model.MaxEstrus).Value

	currentMaxHabit := &model.NeckActiveHabit{}
	if err := e.DB.Model(new(model.NeckActiveHabit)).
		Order("id desc").
		First(currentMaxHabit).Error; err != nil {
		return xerr.WithStack(err)
	}

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

	// 当前Id<=上次执行的id，则不执行
	if currentMaxHabit.Id <= int64(lastMaxEstrusId) {
		return nil
	}

	xToday.LastMaxHabitId = int64(lastMaxEstrusId)
	xToday.CurrMaxHabitId = currentMaxHabit.Id
	xToday.ActiveLow = int64(activeLowValue)
	xToday.ActiveMiddle = int64(activeMiddleValue)
	xToday.ActiveHigh = int64(activeHighValue)

	if err := e.CowEstrusWarning(ctx, xToday); err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (e *Entry) CowEstrusWarning(ctx context.Context, xToday *XToday) error {
	startDate, err := time.Parse(model.LayoutDate2, xToday.XBegDate)
	if err != nil {
		return xerr.WithStack(err)
	}
	endDate, err := time.Parse(model.LayoutDate2, xToday.XEndDate)
	if err != nil {
		return xerr.WithStack(err)
	}

	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("cow_id").
			Find(&neckActiveHabitList).
			Error; err != nil {
			return xerr.WithStack(err)
		}

		eventEstrusList := make([]*model.EventEstrus, 0)
		for _, v := range neckActiveHabitList {
			if ok := e.IsAdJustLow(ctx, 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 eventEstrus.CowId != v.CowId {
				if int32(cft) <= eventEstrus.PerTwentyFourHigh {
					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))
			if cowEstrus.CowId == v.CowId {
				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, err := e.GetCowById(v.CowId)
			if err != nil {
				zaplog.Error("CowEstrusWarning", zap.Any("GetCowById", err), zap.Any("cowId", v.CowId))
				continue
			}

			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.PerTwentyFourHigh > 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 {
				isShow = pasturePb.IsShow_No
			}

			eventEstrusList = append(eventEstrusList, &model.EventEstrus{
				CowId:             v.CowId,
				DayAge:            cowInfo.DayAge,
				Lact:              cowInfo.Lact,
				CalvingAge:        int32(cowInfo.CalvingAge),
				ExposeEstrusType:  pasturePb.ExposeEstrusType_Natural_Estrus,
				FilterHigh:        v.FilterHigh,
				EstrusDate:        v.ActiveTime,
				ActiveDate:        v.ActiveTime,
				LastEstrusDate:    cowEstrus.ActiveDate,
				Level:             level,
				IsPeak:            pasturePb.IsShow_No,
				PerTwentyFourHigh: 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.AddDate(0, 0, 1)
	}

	return nil
}

// IsAdJustLow 是否低于最低活动量
func (e *Entry) IsAdJustLow(ctx context.Context, 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
}