kpt-pasture/module/backend/cow.go

package backend

import (
	"context"
	"errors"
	"fmt"
	"kpt-pasture/model"
	"kpt-pasture/util"
	"net/http"
	"sort"
	"strings"
	"time"

	"github.com/nicksnyder/go-i18n/v2/i18n"

	"gorm.io/gorm"

	"gitee.com/xuyiping_admin/pkg/xerr"

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

func (s *StoreEntry) Detail(ctx context.Context, req *pasturePb.SearchEventRequest) (*pasturePb.CowInfoResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	if req.EarNumber == "" && req.NeckRingNumber == "" {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.inputCow",
		})
		return nil, xerr.Custom(messageId)
	}

	cowInfo := &model.Cow{}
	pref := s.DB.Model(new(model.Cow)).
		Where("pasture_id = ?", userModel.AppPasture.Id)

	if req.EarNumber != "" {
		pref.Where("ear_number = ?", strings.TrimSpace(req.EarNumber))
	}

	if req.NeckRingNumber != "" {
		pref.Where("neck_ring_number = ?", strings.TrimSpace(req.NeckRingNumber))
	}

	if err = pref.First(cowInfo).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "cow.noCow",
			})
			return nil, xerr.Custom(messageId)
		} else {
			return nil, xerr.WithStack(err)
		}
	}

	cowTypeMap := s.CowTypeMap(userModel)
	breedStatusMap := s.CowBreedStatusMap(userModel)
	cowKindMap := s.CowKindMap(userModel)
	cowSourceMap := s.CowSourceMap(userModel)
	admissionStatusMap := s.AdmissionStatusMap(userModel)
	healthStatusMap := s.HealthStatusMap(userModel)
	purposeMap := s.PurposeMap(userModel)
	systemBasic, err := s.GetSystemBasicByName(ctx, userModel.AppPasture.Id, model.PregnancyAge)
	if err != nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.pregnancyDays",
		})
		return nil, xerr.Custom(messageId)
	}

	cowDetails := model.CowSlice([]*model.Cow{cowInfo}).ToPB(
		cowTypeMap, breedStatusMap, cowKindMap, cowSourceMap,
		admissionStatusMap, healthStatusMap, purposeMap, systemBasic.MinValue,
	)
	if len(cowDetails) != 1 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.noCow",
		})
		return nil, xerr.Custom(messageId)
	}

	data := cowDetails[0]
	return &pasturePb.CowInfoResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: data,
	}, nil
}

func (s *StoreEntry) List(ctx context.Context, req *pasturePb.SearchEventRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchCowListResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	systemBasic, err := s.GetSystemBasicByName(ctx, userModel.AppPasture.Id, model.PregnancyAge)
	if err != nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.pregnancyDays",
		})
		return nil, xerr.Custom(messageId)
	}

	cowList := make([]*model.Cow, 0)
	var count int64 = 0
	pref := s.DB.Model(new(model.Cow)).
		Where("pasture_id = ?", userModel.AppPasture.Id)

	if len(req.CowId) > 0 {
		cowIds := strings.Split(req.CowId, ",")
		pref.Where("id IN ?", cowIds)
	}

	if req.EarNumber != "" {
		pref.Where("ear_number like ?", fmt.Sprintf("%s%s%s", "%", req.EarNumber, "%"))
	}

	if req.Id > 0 {
		pref.Where("id = ?", req.Id)
	}

	if req.PenId > 0 {
		pref.Where("pen_id = ?", req.PenId)
	}

	if req.CowType > 0 {
		pref.Where("cow_type = ?", req.CowType)
	}

	if req.BreedStatus > 0 {
		pref.Where("breed_status = ?", req.BreedStatus)
	}

	if req.CowKind > 0 {
		pref.Where("cow_kind = ?", req.CowKind)
	}

	if req.Sex > 0 {
		pref.Where("sex = ?", req.Sex)
	}

	if req.Lact > 0 {
		pref.Where("lact = ?", req.Lact)
	}

	if req.CowSource > 0 {
		pref.Where("source_id = ?", req.CowSource)
	}

	if err = pref.Order("id desc").
		Count(&count).
		Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Find(&cowList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	cowTypeMap := s.CowTypeMap(userModel)
	breedStatusMap := s.CowBreedStatusMap(userModel)
	cowKindMap := s.CowKindMap(userModel)
	cowSourceMap := s.CowSourceMap(userModel)
	admissionStatusMap := s.AdmissionStatusMap(userModel)
	healthStatusMap := s.HealthStatusMap(userModel)
	purposeMap := s.PurposeMap(userModel)
	return &pasturePb.SearchCowListResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchCowData{
			List: model.CowSlice(cowList).ToPB(
				cowTypeMap, breedStatusMap, cowKindMap, cowSourceMap,
				admissionStatusMap, healthStatusMap, purposeMap, systemBasic.MinValue,
			),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) EventList(ctx context.Context, req *pasturePb.SearchCowEventListRequest, pagination *pasturePb.PaginationModel) (*pasturePb.CowEventListResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	eventCowLogList := make([]*model.EventCowLog, 0)
	cowInfo, err := s.GetCowEventByEarNumber(ctx, userModel.AppPasture.Id, req.EarNumber)
	if err != nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID:    "auth.errorCow",
			TemplateData: map[string]interface{}{"earNumber": req.EarNumber},
		})
		return nil, xerr.Customf(messageId)
	}

	eventCowLog := &model.EventCowLog{CowId: cowInfo.Id}
	pref := s.DB.Table(eventCowLog.TableName()).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("cow_id = ?", cowInfo.Id)

	if req.Lact >= 0 {
		pref.Where("lact = ?", req.Lact)
	}

	if req.EventCategoryKind > 0 {
		pref.Where("event_type = ?", req.EventCategoryKind)
	}

	if err = pref.Order("event_at DESC").
		Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Find(&eventCowLogList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	eventCategoryMap := s.EventCategoryMap(userModel)
	return &pasturePb.CowEventListResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.CowEventData{
			List:     model.EventCowLogSlice(eventCowLogList).ToPB(eventCategoryMap),
			Total:    int32(len(eventCowLogList)),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) BehaviorCurve(ctx context.Context, req *pasturePb.CowBehaviorCurveRequest) (*model.CowBehaviorCurveResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	cowInfo, err := s.GetCowEventByEarNumber(ctx, userModel.AppPasture.Id, req.EarNumber)
	if err != nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID:    "auth.errorCow",
			TemplateData: map[string]interface{}{"earNumber": req.EarNumber},
		})
		return nil, xerr.Customf(messageId)
	}

	nowTime := time.Now().Local()
	nowDayZero := util.TimeParseLocalUnix(nowTime.Format(model.LayoutDate2))
	endDataTime := nowTime.Format(model.LayoutDate2)
	startDataTime := nowTime.AddDate(0, 0, -model.NeckRingDataDays).Format(model.LayoutDate2)

	dayRange, err := util.GetDaysBetween(startDataTime, endDataTime)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	if len(dayRange) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.errorDateRange",
		})
		return nil, xerr.Customf(messageId)
	}

	// 行为曲线数据
	neckActiveHabitList := make([]*model.NeckActiveHabit, 0)
	if err = s.DB.Table(new(model.NeckActiveHabit).TableName()).
		Where("neck_ring_number = ?", cowInfo.NeckRingNumber).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Where("cow_id > ?", 0).
		Where("heat_date IN (?)", dayRange).
		Order("heat_date, frameid").
		Find(&neckActiveHabitList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	data := model.NeckActiveHabitSlice(neckActiveHabitList).ToPB(req.CurveName)
	q1, q3 := s.CowIQR(cowInfo, req.CurveName, dayRange, data.DateTimeList)
	data.IQR3 = q3
	data.IQR1 = q1
	eventMapList := s.EventTypeMap(userModel)
	for k, v := range eventMapList {
		if k == pasturePb.EventType_Enter || k == pasturePb.EventType_Body_Score || k == pasturePb.EventType_Birth ||
			k == pasturePb.EventType_Weaning || k == pasturePb.EventType_Sale || k == pasturePb.EventType_Weight ||
			k == pasturePb.EventType_Castrated {
			continue
		}
		data.EventMap[k] = v
	}
	data.LowActivity = model.LowActivity
	data.MiddleActivity = model.MiddleActivity
	// 牛只事件列表
	eventLogList := make([]*model.EventCowLog, 0)
	eventLog := &model.EventCowLog{CowId: cowInfo.Id}
	if err = s.DB.Table(eventLog.TableName()).
		Where("cow_id = ?", cowInfo.Id).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("event_at BETWEEN ? AND ?", nowDayZero-(model.NeckRingDataDays*86400), nowDayZero+86400).
		Order("event_at").
		Find(&eventLogList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	for _, v := range eventLogList {
		if v.EventType == pasturePb.EventType_Enter || v.EventType == pasturePb.EventType_Body_Score ||
			v.EventType == pasturePb.EventType_Birth || v.EventType == pasturePb.EventType_Weaning ||
			v.EventType == pasturePb.EventType_Sale || v.EventType == pasturePb.EventType_Weight ||
			v.EventType == pasturePb.EventType_Castrated {
			continue
		}

		if v.EventAt <= 0 {
			continue
		}

		eventAt := time.Unix(v.EventAt, 0).Local()
		data.EventList = append(data.EventList, &pasturePb.CowEvent{
			EventTypeKind:    v.EventType,
			EventTypeName:    v.EventTypeName,
			EventDescription: v.EventDescription,
			Remarks:          v.Remarks,
			EventAtFormat:    fmt.Sprintf("%s 09", eventAt.Format(model.LayoutDate2)),
		})
	}

	// 发情数据
	estrusList := make([]*model.NeckRingEstrus, 0)
	if err = s.DB.Model(new(model.NeckRingEstrus)).
		Select("id,active_level,MAX(active_time) AS active_time,is_peak").
		Where("cow_id = ?", cowInfo.Id).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("active_time BETWEEN ? AND ?", fmt.Sprintf("%s 00:00:00", startDataTime), fmt.Sprintf("%s 23:59:59", endDataTime)).
		Where("is_peak = ?", pasturePb.IsShow_Ok).
		Group("first_time").
		Find(&estrusList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	for _, v := range estrusList {
		if data.EstrusList[v.ActiveLevel] == nil {
			data.EstrusList[v.ActiveLevel] = make([]string, 0)
		}
		data.EstrusList[v.ActiveLevel] = append(data.EstrusList[v.ActiveLevel], strings.TrimSuffix(v.ActiveTime, ":00:00"))
	}

	return &model.CowBehaviorCurveResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: data,
	}, nil
}

func (s *StoreEntry) CowIQR(cowInfo *model.Cow, curveName string, dayRange []string, dateTimeList []string) ([]int32, []int32) {
	q1, q3 := make([]int32, 0), make([]int32, 0)
	if curveName == "" || curveName == "active" || curveName == "behavior" || len(dateTimeList) <= 0 {
		return q1, q3
	}

	penId := cowInfo.PenId
	cowList := make([]*model.Cow, 0)
	if err := s.DB.Table(new(model.Cow).TableName()).
		Where("pen_id = ?", penId).
		Where("pasture_id = ?", cowInfo.PastureId).
		Where("neck_ring_number != ?", "").
		Find(&cowList).Error; err != nil {
		return q1, q3
	}

	cowIds := make([]int64, 0)
	for _, cow := range cowList {
		cowIds = append(cowIds, cow.Id)
	}

	neckActiveHabitList, err := s.GetNeckActiveHabitsConcurrent(cowInfo, cowIds, dayRange)
	if err != nil {
		return q1, q3
	}

	neckActiveHabitMap := make(map[string][]*model.NeckActiveHabit)
	for _, habit := range neckActiveHabitList {
		activeTime := habit.ActiveTime[:13]
		neckActiveHabitMap[activeTime] = append(neckActiveHabitMap[activeTime], habit)
	}

	penOriginal := make(map[string][]int32)
	for _, dt := range dateTimeList {
		habits, ok := neckActiveHabitMap[dt]
		if !ok {
			penOriginal[dt] = append(penOriginal[dt], int32(0))
			continue
		}

		switch curveName {
		case "rumina":
			for _, habit := range habits {
				penOriginal[dt] = append(penOriginal[dt], habit.Rumina)
			}
		case "intake":
			for _, habit := range habits {
				penOriginal[dt] = append(penOriginal[dt], habit.Inactive)
			}
		case "inactive":
			for _, habit := range habits {
				penOriginal[dt] = append(penOriginal[dt], habit.Inactive)
			}
		case "chew":
			for _, habit := range habits {
				penOriginal[dt] = append(penOriginal[dt], habit.Rumina+habit.Intake)
			}
		case "immobility":
			for _, habit := range habits {
				penOriginal[dt] = append(penOriginal[dt], 120-habit.Active)
			}
		}
	}

	if len(penOriginal) > 0 {
		for _, dataList := range penOriginal {
			dl := len(dataList)
			if dl < 4 {
				q1 = append(q1, int32(0))
				q3 = append(q3, int32(0))
				continue
			}

			sort.Slice(dataList, func(i, j int) bool {
				return dataList[i] < dataList[j]
			})

			v1 := (len(dataList) + 1) / 4
			// 防止下标溢出panic
			s1 := float64(dataList[v1-1]) + 0.25*float64(dataList[v1]-dataList[v1-1])
			v3 := v1 * 3
			s3 := float64(dataList[v3-1]) + 0.75*float64(dataList[v3]-dataList[v3-1])

			q1 = append(q1, int32(s1))
			q3 = append(q3, int32(s3))
		}
	}
	return q1, q3
}