kpt-pasture/module/backend/neck_ring_warning.go

package backend

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

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

	"go.uber.org/zap"
	"gorm.io/gorm"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
	"gitee.com/xuyiping_admin/pkg/logger/zaplog"
	"gitee.com/xuyiping_admin/pkg/xerr"
)

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

	var count int32
	neckRingEstrusList := make([]*model.NeckRingEstrusWarning, 0)
	var pref *gorm.DB
	switch req.Kind {
	case "abortion":
		pref, err = s.AbortionWarningQuery(ctx, userModel.AppPasture.Id)
		if err != nil {
			return nil, xerr.WithStack(err)
		}
	default:
		pref, err = s.EstrusWarningQuery(ctx, userModel.AppPasture.Id)
		if err != nil {
			return nil, xerr.WithStack(err)
		}
	}

	if len(req.EarNumber) > 0 {
		pref.Where("a.ear_number = ?", req.EarNumber)
	}

	if req.Level > 0 {
		pref.Where("a.level = ?", req.Level)
	}

	if len(req.EstrusLevels) > 0 {
		pref.Where("a.level IN ?", req.EstrusLevels)
	}

	if len(req.PenIds) > 0 {
		pref.Where("b.pen_id IN ?", req.PenIds)
	}

	// 按照发情时间和发情等级倒叙排序
	if req.MatingWindowPeriod > 0 {
		if err = pref.Group("a.cow_id").
			Find(&neckRingEstrusList).Error; err != nil {
			return nil, xerr.WithStack(err)
		}
	} else {
		if err = pref.Group("a.cow_id").
			Find(&neckRingEstrusList).Error; err != nil {
			return nil, xerr.WithStack(err)
		}
	}

	cowMap := make(map[int64]*model.Cow)
	eventLogMap := make(map[int64]string)
	cowIds := make([]int64, 0)
	for _, v := range neckRingEstrusList {
		cowIds = append(cowIds, v.CowId)
	}

	if len(cowIds) > 0 {
		lastEventLogList := s.GetCowLastEventByCowIds(userModel.AppPasture.Id, cowIds, pasturePb.EventCategory_Breed)
		for _, log := range lastEventLogList {
			eventLogMap[log.CowId] = log.EventDescription
		}

		cowList, _ := s.GetCowInfoByCowIds(ctx, userModel.AppPasture.Id, cowIds)
		for _, cow := range cowList {
			cowMap[cow.Id] = cow
		}
	}
	list := model.NeckRingEstrusWarningSlice(neckRingEstrusList).ToPB(cowMap, eventLogMap, req.MatingWindowPeriod, req.MatingWindowPeriods)
	// 排序 先按照高峰时间正序排，然后再按照发情等级倒叙排
	sort.Slice(list, func(i, j int) bool {
		if list[i].PostPeakTimeForHours != list[j].PostPeakTimeForHours {
			return list[i].PostPeakTimeForHours < list[j].PostPeakTimeForHours
		}
		return list[i].Level > list[j].Level
	})
	// 分页
	count = int32(len(list))
	if count > pagination.PageOffset {
		end := pagination.PageOffset + pagination.PageSize
		if end > count {
			end = count
		}
		list = list[pagination.PageOffset:end]
	} else {
		// 如果偏移量已超过列表长度，返回空列表
		list = list[:0]
	}

	return &pasturePb.EstrusResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.EstrusData{
			List:     list,
			Total:    count,
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) NeckRingWarningHealthCowList(ctx context.Context, req *pasturePb.HealthWarningRequest, pagination *pasturePb.PaginationModel) (*pasturePb.HealthWarningResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	neckWaringHealthList := make([]*model.NeckRingHealthWarning, 0)
	var count int64

	pref := s.DB.Table(fmt.Sprintf("%s as a", new(model.NeckRingHealthWarning).TableName())).
		Select(`MAX(a.id) as id,a.cow_id,a.ear_number,a.neck_ring_number,a.score,a.heat_date,a.min_high,a.min_intake,
		a.min_chew,a.chew_sum,a.before_three_sum_chew,a.level`).
		Joins(fmt.Sprintf("JOIN cow AS b on a.cow_id = b.id")).
		Where("a.score >= ?", 0).
		Where("a.is_show = ?", pasturePb.IsShow_Ok).
		Where("a.pasture_id = ?", userModel.AppPasture.Id)

	if len(req.PenIds) > 0 {
		pref.Where("b.pen_id IN ?", req.PenIds)
	}
	if len(req.EarNumber) > 0 {
		pref.Where("a.ear_number = ?", req.EarNumber)
	}

	if req.Level > 0 {
		pref.Where("a.level = ?", req.Level)
	}

	if err = pref.Order("a.level DESC,a.score ASC").
		Group("a.cow_id").
		Count(&count).
		Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Find(&neckWaringHealthList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	warningHealthLevelMap := s.WarningHealthLevelMap(userModel)
	healthStatusMap := s.HealthStatusMap(userModel)
	cowMap := make(map[int64]*model.Cow)
	eventLogMap := make(map[int64]string)
	cowIds := make([]int64, 0)
	for _, v := range neckWaringHealthList {
		cowIds = append(cowIds, v.CowId)
		lastEventLog := s.GetCowLastEvent(userModel.AppPasture.Id, v.CowId, pasturePb.EventCategory_Breed)
		if lastEventLog != nil {
			eventLogMap[v.CowId] = lastEventLog.EventDescription
		}
	}

	dayData := make(map[int64]*model.NeckActiveHabit)
	if len(cowIds) > 0 {
		cowList, _ := s.GetCowInfoByCowIds(ctx, userModel.AppPasture.Id, cowIds)
		for _, cow := range cowList {
			cowMap[cow.Id] = cow
		}

		neckRingHabitList := make([]*model.NeckActiveHabit, 0)
		if err = s.DB.Model(new(model.NeckActiveHabit)).
			Select("rumina,intake,inactive,active,change_rumina,change_high,active_time").
			Where("pasture_id = ?", userModel.AppPasture.Id).
			Where("cow_id IN ?", cowIds).
			Where("heat_date = ?", time.Now().Format(model.LayoutDate2)).
			Where("is_show = ?", pasturePb.IsShow_Ok).
			Find(&neckRingHabitList).Error; err != nil {
			zaplog.Error("GetNeckRingHabitList", zap.Error(err))
		}

		if len(neckRingHabitList) > 0 {
			for _, v := range neckRingHabitList {
				if _, ok := dayData[v.CowId]; ok {
					dayData[v.CowId].Active += 120 - v.Active
					dayData[v.CowId].Inactive += v.Inactive
					dayData[v.CowId].Intake += v.Intake
					dayData[v.CowId].Rumina += v.Rumina
					if dayData[v.CowId].ActiveTime < v.ActiveTime {
						dayData[v.CowId].ChangeRumina = v.ChangeRumina
						dayData[v.CowId].ActiveTime = v.ActiveTime
						dayData[v.CowId].ChangeHigh = v.ChangeHigh
					}
				}
			}
		}
	}

	return &pasturePb.HealthWarningResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.HealthWarningData{
			Total:    int32(count),
			Page:     pagination.Page,
			PageSize: pagination.PageSize,
			List: model.NeckRingHealthWarningSlice(neckWaringHealthList).ToPB(
				warningHealthLevelMap,
				cowMap,
				eventLogMap,
				healthStatusMap,
				dayData,
			),
		},
	}, nil

}

func (s *StoreEntry) NeckRingNoEstrusBatch(ctx context.Context, req *pasturePb.NeckRingNoEstrusBatchRequest) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	if len(req.EarNumbers) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.earNumber",
		})
		return xerr.Custom(messageId)
	}

	nowTime := time.Now().Local()
	startTime := nowTime.AddDate(0, 0, -1).Format(model.LayoutDate2)
	endTime := nowTime.AddDate(0, 0, 1).Format(model.LayoutDate2)

	startTimeUnix := util.TimeParseLocalUnix(startTime)
	endTimeUnix := util.TimeParseLocalUnix(endTime)

	startTime = time.Unix(startTimeUnix, 0).Local().Format(model.LayoutTime)
	endTime = time.Unix(endTimeUnix, 0).Local().Format(model.LayoutTime)
	neckRingEstrusWarningList := make([]*model.NeckRingEstrusWarning, 0)
	if err = s.DB.Model(new(model.NeckRingEstrusWarning)).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("date_time BETWEEN ? AND ?", startTime, endTime).
		Where("ear_number IN ?", req.EarNumbers).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Find(&neckRingEstrusWarningList).Error; err != nil {
		return xerr.WithStack(err)
	}

	if len(neckRingEstrusWarningList) <= 0 {
		return nil
	}

	neckRingEstrusIds := make([]int64, 0)
	for _, v := range neckRingEstrusWarningList {
		neckRingEstrus := &model.NeckRingEstrus{}
		if err = s.DB.Model(new(model.NeckRingEstrus)).
			Where("pasture_id = ?", userModel.AppPasture.Id).
			Where("id = ?", v.NeckRingEstrusId).
			Where("is_show = ?", pasturePb.IsShow_Ok).
			First(neckRingEstrus).Error; err != nil {
			zaplog.Error("NeckRingNoEstrusBatch", zap.Any("err", err), zap.Any("neckRingEstrusWarning", v))
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "cow.dataError",
				TemplateData: map[string]interface{}{
					"earNumber": v.EarNumber,
				},
			})
			return xerr.Customf(messageId)
		}
		neckRingEstrusIds = append(neckRingEstrusIds, neckRingEstrus.Id)
	}

	if len(neckRingEstrusIds) <= 0 {
		return nil
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		for _, id := range neckRingEstrusIds {
			if err = tx.Model(new(model.NeckRingEstrus)).
				Where("id = ?", id).
				Updates(map[string]interface{}{
					"check_result":    pasturePb.CheckResult_Fail,
					"check_user_id":   userModel.SystemUser.Id,
					"check_user_name": userModel.SystemUser.Name,
					"check_at":        time.Now().Local().Unix(),
					"is_show":         pasturePb.IsShow_No,
				}).Error; err != nil {
				return xerr.WithStack(err)
			}

			if err = tx.Model(new(model.NeckRingEstrusWarning)).
				Where("neck_ring_estrus_id = ?", id).
				Updates(map[string]interface{}{
					"is_show": pasturePb.IsShow_No,
				}).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}

func (s *StoreEntry) NeckRingNoDiseaseBatch(ctx context.Context, req *pasturePb.NeckRingNoEstrusBatchRequest) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	if len(req.EarNumbers) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.earNumber",
		})
		return xerr.Custom(messageId)
	}

	nowTime := time.Now().Local()
	startTime := nowTime.AddDate(0, 0, -1).Format(model.LayoutDate2)
	endTime := nowTime.Format(model.LayoutDate2)

	neckRingHealthWarningList := make([]*model.NeckRingHealthWarning, 0)
	if err = s.DB.Model(new(model.NeckRingHealthWarning)).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("heat_date BETWEEN ? AND ?", startTime, endTime).
		Where("ear_number IN ?", req.EarNumbers).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Find(&neckRingHealthWarningList).Error; err != nil {
		return xerr.WithStack(err)
	}

	if len(neckRingHealthWarningList) <= 0 {
		return nil
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		for _, v := range neckRingHealthWarningList {
			if err = tx.Model(new(model.NeckRingHealth)).
				Where("pasture_id = ?", userModel.AppPasture.Id).
				Where("heat_date = ?", v.HeatDate).
				Where("cow_id = ?", v.CowId).
				Updates(map[string]interface{}{
					"check_result":    pasturePb.CheckResult_Fail,
					"check_user_id":   userModel.SystemUser.Id,
					"check_user_name": userModel.SystemUser.Name,
					"check_at":        time.Now().Local().Unix(),
					"is_show":         pasturePb.IsShow_No,
				}).Error; err != nil {
				return xerr.WithStack(err)
			}

			if err = tx.Model(new(model.NeckRingHealthWarning)).
				Where("neck_ring_health_id = ?", v.NeckRingHealthId).
				Updates(map[string]interface{}{
					"is_show": pasturePb.IsShow_No,
				}).Error; err != nil {
				return xerr.WithStack(err)
			}
		}

		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}
func (s *StoreEntry) EstrusWarningQuery(ctx context.Context, pastureId int64) (*gorm.DB, error) {
	nowTime := time.Now().Local()
	startTime := time.Unix(util.TimeParseLocalUnix(nowTime.AddDate(0, 0, -1).Format(model.LayoutDate2)), 0).Format(model.LayoutTime)
	entTime := time.Unix(util.TimeParseLocalEndUnix(nowTime.Format(model.LayoutDate2)), 0).Format(model.LayoutTime)
	systemBasic, err := s.FindSystemBasic(ctx, pastureId, model.EstrusWaringDays)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	return s.DB.Table(fmt.Sprintf("%s as a", new(model.NeckRingEstrusWarning).TableName())).
		Joins(fmt.Sprintf("JOIN %s AS b on a.cow_id = b.id", new(model.Cow).TableName())).
		Where("b.last_mating_at < UNIX_TIMESTAMP(a.date_time)").
		Where("b.admission_status = ?", pasturePb.AdmissionStatus_Admission).
		Where("b.is_forbidden_mating = ?", pasturePb.IsShow_No).
		Where("a.level >= ?", pasturePb.EstrusLevel_Low).
		Where("a.pasture_id = ?", pastureId).
		Where("a.date_time BETWEEN ? AND ?", startTime, entTime).
		Where(s.DB.Where("b.last_mating_at < UNIX_TIMESTAMP(a.first_time)").
			Or(s.DB.Where("b.last_mating_at = ?", 0).
				Where("b.calving_age > ?", systemBasic.MinValue).
				Or("b.lact = ?", 0))).
		Where("a.is_show = ?", pasturePb.IsShow_Ok), nil
}

func (s *StoreEntry) AbortionWarningQuery(ctx context.Context, pastureId int64) (*gorm.DB, error) {
	return s.DB.Table(fmt.Sprintf("%s as a", new(model.NeckRingEstrusWarning).TableName())).
		Joins(fmt.Sprintf("JOIN %s AS b on a.cow_id = b.id", new(model.Cow).TableName())).
		Where("b.pregnancy_age BETWEEN ? AND ?", 1, 260).
		Where("b.admission_status = ?", pasturePb.AdmissionStatus_Admission).
		Where("b.is_pregnant = ?", pasturePb.IsShow_Ok).
		Where("a.level >= ?", pasturePb.EstrusLevel_Middle).
		Where("a.pasture_id = ?", pastureId).
		Where("a.is_show = ?", pasturePb.IsShow_Ok), nil
}

func (s *StoreEntry) DataNoticeDetail(ctx context.Context) *model.DataNoticeResponse {
	res := &model.DataNoticeResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: make([]*model.NoticeContent, 0),
	}
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return res
	}
	pastureId := userModel.AppPasture.Id
	nowTime := time.Now().Local().Format(model.LayoutDate2)
	noticeList := make([]*model.DataNotice, 0)
	if err = s.DB.Model(new(model.DataNotice)).
		Where("pasture_id = ?", pastureId).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Where("start_date >= ? AND end_date <= ?", nowTime, nowTime).
		Order("id desc").
		Group("notice_kind").
		Find(&noticeList).Error; err != nil {
		return res
	}
	res.Data = model.DataNoticeSlice(noticeList).ToPB(userModel.SystemUser.Id)
	return res
}

func (s *StoreEntry) DataNoticeKnown(ctx context.Context, dataNoticeId int64) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	pastureId := userModel.AppPasture.Id
	dataNotice := model.DataNotice{}
	if err = s.DB.Model(new(model.DataNotice)).
		Where("id = ? and pasture_id = ?", dataNoticeId, pastureId).
		First(&dataNotice).Error; err != nil {
		return xerr.WithStack(err)
	}

	newKnownUsers := ""
	if len(dataNotice.KnownUsers) > 0 {
		newKnownUsers = fmt.Sprintf("%s,%d", dataNotice.KnownUsers, userModel.SystemUser.Id)
	} else {
		newKnownUsers = fmt.Sprintf("%d", userModel.SystemUser.Id)
	}

	if err = s.DB.Model(new(model.DataNotice)).
		Where("id = ?", dataNotice.Id).
		Select("known_users").
		Update("known_users", newKnownUsers).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}