kpt-pasture/module/backend/event_check.go

package backend

import (
	"context"
	"errors"
	"kpt-pasture/model"
	"kpt-pasture/util"
	"time"

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

	"gorm.io/gorm"

	"go.uber.org/zap"

	"gitee.com/xuyiping_admin/pkg/logger/zaplog"

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

// PregnantCheckBatchModel 批量孕检
type PregnantCheckBatchModel struct {
	EventPregnancyCheck *model.EventPregnantCheck
	Cow                 *model.Cow
	OperationUser       *model.SystemUser
	PregnantCheckAt     int32                              // 孕检日期
	PregnantCheckResult pasturePb.PregnantCheckResult_Kind // 孕检结果
	PregnantCheckMethod pasturePb.PregnantCheckMethod_Kind // 孕检方式
	Remarks             string
	LastMating          *model.EventMating
}

// MatingTimes 更新配次
type MatingTimes struct {
	Mt            int32
	CowId         int64
	EventMatingId int64
}

type AbortionCheckBatchModel struct {
	EventAbortion *model.EventAbortion
	Cow           *model.Cow
	OperationUser *model.SystemUser
	IsLact        pasturePb.IsShow_Kind
}

func (s *StoreEntry) EnterCheck(userModel *model.UserModel, req *pasturePb.EventEnterRequest) error {
	var count int64
	if err := s.DB.Model(new(model.Cow)).
		Where("ear_number = ?", req.EarNumber).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Count(&count).Error; err != nil {
		return xerr.WithStack(err)
	}
	if count > 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.Exists",
		})
		return xerr.Custom(messageId)
	}

	if req.BirthAt > req.EnterAt {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "validate.birthTimeEnterTime",
		})
		return xerr.Custom(messageId)
	}

	return nil
}

func (s *StoreEntry) MatingCreateCheck(ctx context.Context, userModel *model.UserModel, req *pasturePb.EventMatingBatch) ([]*model.EventMatingCheckBatchModel, error) {
	if len(req.Items) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.selectCow",
		})
		return nil, xerr.Custom(messageId)
	}

	if len(req.Items) > 50 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "validate.dataLimit",
		})
		return nil, xerr.Custom(messageId)
	}
	eventMatingCheckBatchModelList := make([]*model.EventMatingCheckBatchModel, 0)

	for _, v := range req.Items {
		cowInfo, err := s.GetCowInfoByEarNumber(ctx, userModel.AppPasture.Id, v.EarNumber)
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		if cowInfo.GetEventDayAge(int64(v.MatingAt)) < 0 {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.matingTimeBirthTime",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if int64(v.MatingAt) < cowInfo.LastCalvingAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.matingTimeLastCalvingTime",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		operationUser, err := s.GetSystemUserById(ctx, int64(v.OperationId))
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		frozenSemen := &model.FrozenSemen{}
		if err = s.DB.Where("bull_id = ?", v.FrozenSemenNumber).
			First(frozenSemen).Error; err != nil {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "goods.frozenSemenNotExist",
			})
			return nil, xerr.Custom(messageId)
		}

		if frozenSemen.Quantity < v.FrozenSemenCount {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "goods.frozenSemenNotEnough",
			})
			return nil, xerr.Custom(messageId)
		}

		if cowInfo.Sex != pasturePb.Genders_Female {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.cowSex",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if int64(v.MatingAt) < cowInfo.LastMatingAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.matingTimeLastMatingTime",
				TemplateData: map[string]interface{}{
					"earNumber":      cowInfo.EarNumber,
					"matingTime":     time.Unix(int64(v.MatingAt), 0).Format(model.LayoutDate2),
					"lastMatingTime": time.Unix(cowInfo.LastMatingAt, 0).Format(model.LayoutDate2),
				},
			})

			return nil, xerr.Customf(messageId)
		}

		if int64(v.MatingAt) < cowInfo.LastPregnantCheckAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.validate.pregnantCheckMatingTime",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if int64(v.MatingAt) < cowInfo.LastAbortionAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.matingTimeLastAbortionTime",
				TemplateData: map[string]interface{}{
					"earNumber":        cowInfo.EarNumber,
					"lastAbortionDate": time.Unix(cowInfo.LastAbortionAt, 0).Format(model.LayoutDate2),
					"matingDate":       time.Unix(int64(v.MatingAt), 0).Format(model.LayoutDate2),
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if int64(v.MatingAt) < cowInfo.BirthAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.matingTimeBirthTime",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if cowInfo.BreedStatus == pasturePb.BreedStatus_Pregnant || cowInfo.BreedStatus == pasturePb.BreedStatus_No_Mating {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.breedStatusError",
				TemplateData: map[string]interface{}{
					"earNumber":   cowInfo.EarNumber,
					"breedStatus": cowInfo.BreedStatus.String(),
				},
			})
			return nil, xerr.Customf(messageId)
		}
		eventMatingCheckBatchModelList = append(eventMatingCheckBatchModelList, &model.EventMatingCheckBatchModel{
			Cow:              cowInfo,
			FrozenSemen:      frozenSemen,
			OperationUser:    operationUser,
			MatingAt:         int64(v.MatingAt),
			FrozenSemenCount: v.FrozenSemenCount,
			Remarks:          v.Remarks,
			ExposeEstrusType: v.ExposeEstrusType,
		})
	}

	return eventMatingCheckBatchModelList, nil
}

func (s *StoreEntry) PregnantCheckDataCheck(ctx context.Context, userModel *model.UserModel, req *pasturePb.EventPregnantCheckBatch) ([]*PregnantCheckBatchModel, error) {
	if len(req.Items) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.selectCow",
		})
		return nil, xerr.Custom(messageId)
	}

	if len(req.Items) > 50 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "validate.dataLimit",
		})
		return nil, xerr.Custom(messageId)
	}

	pregnantCheckBatchModelList := make([]*PregnantCheckBatchModel, 0)
	cowInfo := &model.Cow{}
	var err error
	for _, item := range req.Items {
		cowInfo, err = s.GetCowInfoByEarNumber(ctx, userModel.AppPasture.Id, item.EarNumber)
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		if cowInfo.Sex != pasturePb.Genders_Female {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.cowSex",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if int64(item.PregnantCheckAt) > cowInfo.LastMatingAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.pregnantCheckMatingTime",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if cowInfo.GetEventDayAge(int64(item.PregnantCheckAt)) < 0 {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.pregnantCheckBirthTime",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		operationUser, err := s.GetSystemUserById(ctx, int64(item.OperationId))
		if err != nil {
			zaplog.Error("PregnantCheckDataCheck",
				zap.Any("id", item.OperationId),
				zap.Any("error", err.Error()),
			)
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.getOperationError",
			})
			return nil, xerr.Customf(messageId)
		}

		if cowInfo.LastMatingAt <= 0 {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.matingDataError",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		// 过滤掉没有配种状态的牛只
		if cowInfo.BreedStatus != pasturePb.BreedStatus_Breeding && cowInfo.BreedStatus != pasturePb.BreedStatus_Pregnant {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.cannotPregnantCheck",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		itemEventPregnantCheck, err := s.FindEventPregnantCheckIsExIstByCowId(ctx, cowInfo)
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		if itemEventPregnantCheck.Id <= 0 {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.notFoundPregnantCheckData",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		lastEventMating, err := s.FindLastEventMatingByCowId(ctx, userModel.AppPasture.Id, cowInfo.Id)
		if errors.Is(err, gorm.ErrRecordNotFound) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.notFoundMatingData",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if lastEventMating == nil || lastEventMating.Status == pasturePb.IsShow_No {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.notFoundMatingData",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		pregnantCheckBatchModelList = append(pregnantCheckBatchModelList, &PregnantCheckBatchModel{
			Cow:                 cowInfo,
			OperationUser:       operationUser,
			PregnantCheckAt:     item.PregnantCheckAt,
			PregnantCheckMethod: item.PregnantCheckMethod,
			PregnantCheckResult: item.PregnantCheckResult,
			Remarks:             item.Remarks,
			EventPregnancyCheck: itemEventPregnantCheck,
			LastMating:          lastEventMating,
		})
	}

	return pregnantCheckBatchModelList, nil
}

func (s *StoreEntry) EstrusCheckDataCheck(ctx context.Context, userModel *model.UserModel, req *pasturePb.EventEstrusBatch) (*model.EventEstrusBatch, error) {
	pastureId := userModel.AppPasture.Id
	exposeEstrusType := pasturePb.ExposeEstrusType_Natural_Estrus
	if req.ExposeEstrusType == pasturePb.ExposeEstrusType_Neck_Ring {
		exposeEstrusType = pasturePb.ExposeEstrusType_Neck_Ring
	}
	unMatingReasonsMap := s.UnMatingReasonsMap()

	res := &model.EventEstrusBatch{
		ExposeEstrusType: exposeEstrusType,
		EventEstrusList:  make([]*model.EventEstrus, 0),
		EventMatingList:  make([]*model.EventMating, 0),
		EarNumbers:       make([]string, 0),
	}

	for _, item := range req.Items {
		cowInfo, err := s.GetCowInfoByEarNumber(ctx, pastureId, item.EarNumber)
		if err != nil {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "cow.cowNotExist",
				TemplateData: map[string]interface{}{
					"earNumber": item.EarNumber,
				},
			})
			return nil, xerr.Custom(messageId)
		}

		if cowInfo.Sex != pasturePb.Genders_Female {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "cow.cowSex",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Custom(messageId)
		}

		if int64(item.EstrusAt) <= cowInfo.BirthAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.estrusDateBirthDate",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if int64(item.EstrusAt) <= cowInfo.LastCalvingAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.estrusDateLastCalvingDate",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Custom(messageId)
		}

		estrusAt := time.Unix(int64(item.EstrusAt), 0).Local().Format(model.LayoutDate2)
		estrusLocalStartTime := util.TimeParseLocalUnix(estrusAt)
		estrusLocalEndTime := util.TimeParseLocalEndUnix(estrusAt)
		isExists := s.FindEventEstrusByCowId(pastureId, cowInfo.Id, estrusLocalStartTime, estrusLocalEndTime)
		// 如果存在，并且当天已经提交过则跳过
		if isExists {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.estrusDataAlready",
				TemplateData: map[string]interface{}{
					"earNumber": item.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		operationUser, _ := s.GetSystemUserById(ctx, int64(item.OperationId))
		item.OperationName = operationUser.Name
		newEventEstrus := model.NewEventEstrus(
			pastureId, cowInfo, exposeEstrusType, pasturePb.IsShow_Ok,
			item.IsMating, int64(item.EstrusAt), operationUser, userModel.SystemUser,
		)

		if item.IsMating == pasturePb.IsShow_Ok {
			isExists = s.FindEventMatingByCowId(pastureId, cowInfo.Id)
			if isExists {
				messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
					MessageID: "validate.matingDataItemAlready",
					TemplateData: map[string]interface{}{
						"earNumber": item.EarNumber,
					},
				})
				return nil, xerr.Customf(messageId)
			}
			newEventMating := model.NewEventMating(pastureId, cowInfo, time.Now().Local().Unix(), exposeEstrusType)
			res.EventMatingList = append(res.EventMatingList, newEventMating)
		} else {
			newEventEstrus.UnMatingReasonsKind = item.UnMatingReasonsKind
			newEventEstrus.UnMatingReasonsName = unMatingReasonsMap[item.UnMatingReasonsKind]
		}

		newEventEstrus.Remarks = item.Remarks
		res.EventEstrusList = append(res.EventEstrusList, newEventEstrus)
		res.EarNumbers = append(res.EarNumbers, item.EarNumber)
	}
	return res, nil
}

func (s *StoreEntry) AbortionEventDataCheck(ctx context.Context, userModel *model.UserModel, items []*pasturePb.EventAbortionItem) ([]*AbortionCheckBatchModel, error) {
	if len(items) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.selectCow",
		})
		return nil, xerr.Custom(messageId)
	}
	if len(items) > 50 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "validate.dataLimit",
		})
		return nil, xerr.Custom(messageId)
	}
	abortionCheckBatchModelList := make([]*AbortionCheckBatchModel, 0)
	for _, item := range items {
		cow, err := s.GetCowInfoByEarNumber(ctx, userModel.AppPasture.Id, item.EarNumber)
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		if cow.Sex != pasturePb.Genders_Female {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "cow.cowSex",
				TemplateData: map[string]interface{}{
					"earNumber": cow.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if cow.IsPregnant != pasturePb.IsShow_Ok {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.CowNotPregnant",
				TemplateData: map[string]interface{}{
					"earNumber": cow.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if cow.BreedStatus != pasturePb.BreedStatus_Pregnant {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.CowNotPregnant",
				TemplateData: map[string]interface{}{
					"earNumber": cow.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if cow.GetEventDayAge(int64(item.AbortionAt)) < 0 {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.AbortionDateBirthDate",
				TemplateData: map[string]interface{}{
					"earNumber": item.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		operationUser, err := s.GetSystemUserById(ctx, int64(item.OperationId))
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		item.OperationName = operationUser.Name
		item.AbortionReasonsName = s.AbortionReasonsMap()[item.AbortionReasons]
		newEventAbortion := model.NewEventAbortion(userModel.AppPasture.Id, cow, item, pasturePb.IsShow_No)
		abortionCheckBatchModelList = append(abortionCheckBatchModelList, &AbortionCheckBatchModel{
			EventAbortion: newEventAbortion,
			Cow:           cow,
			OperationUser: operationUser,
			IsLact:        item.IsLact,
		})
	}
	return abortionCheckBatchModelList, nil
}

func (s *StoreEntry) ForbiddenMatingCheck(ctx context.Context, userModel *model.UserModel, items []*pasturePb.ForbiddenMatingItem) ([]*model.EventForbiddenMatingItem, error) {
	res := make([]*model.EventForbiddenMatingItem, 0)
	forbiddenMatingReasonsMap := s.ForbiddenMatingReasonsMap()
	for _, v := range items {
		cowInfo, err := s.GetCowInfoByEarNumber(ctx, userModel.AppPasture.Id, v.EarNumber)
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		if cowInfo.Sex != pasturePb.Genders_Female {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "cow.cowSex",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if v.ForbiddenMatingAt < int32(cowInfo.BirthAt) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.unMatingDate",
				TemplateData: map[string]interface{}{
					"earNumber": cowInfo.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		operationUser, err := s.GetSystemUserById(ctx, int64(v.OperationId))
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		res = append(res, &model.EventForbiddenMatingItem{
			Cow:                        cowInfo,
			ForbiddenMatingAt:          int64(v.ForbiddenMatingAt),
			ForbiddenMatingReasonsKind: v.ForbiddenMatingReasonsKind,
			ForbiddenMatingReasonsName: forbiddenMatingReasonsMap[v.ForbiddenMatingReasonsKind],
			Remarks:                    v.Remarks,
			OperationUser:              operationUser,
			MessageUser:                userModel.SystemUser,
		})
	}
	return res, nil
}

func (s *StoreEntry) DeathCheck(ctx context.Context, userModel *model.UserModel, req *pasturePb.EventDeathBatch) ([]*model.EventDeathModel, error) {
	newEventDeathList := make([]*model.EventDeathModel, 0)
	for _, item := range req.Items {
		cow, err := s.GetCowInfoByEarNumber(ctx, userModel.AppPasture.Id, item.EarNumber)
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		if cow.BirthAt <= int64(item.DeathAt) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.deathTime",
				TemplateData: map[string]interface{}{
					"earNumber": cow.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		lastEventLog, _ := s.GetEventCowLog(ctx, userModel.AppPasture.Id, cow.Id)
		if lastEventLog != nil && int64(item.DeathAt) < lastEventLog.EventAt {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "validate.deathTimeLastEvent",
				TemplateData: map[string]interface{}{
					"earNumber": cow.EarNumber,
				},
			})
			return nil, xerr.Customf(messageId)
		}

		if name, ok := s.DeadReasonMap()[item.DeathReasonKind]; ok {
			item.DeathReasonName = name
		}

		operationUser, err := s.GetSystemUserById(ctx, int64(item.OperationId))
		if err != nil {
			zaplog.Error("DeathBatch", zap.Any("item", item), zap.Any("err", err))
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "auth.getOperationError",
			})
			return nil, xerr.Customf(messageId)
		}

		if name, ok := s.CowDeathDestinationMap()[item.DeathDestinationKind]; ok {
			item.DeathDestinationName = name
		}

		newEventDeath := model.NewEventDeath(userModel.AppPasture.Id, cow, item, userModel.SystemUser, operationUser)
		eventDeathModel := &model.EventDeathModel{
			Cow:         cow,
			EventDeath:  newEventDeath,
			NeckRing:    nil,
			CalvingCalf: nil,
		}

		// 犊牛死亡更新
		if cow.DayAge <= model.CalfDefaultDayAge {
			calvingCalf, ok := s.IsExistCalvingCalf(userModel.AppPasture.Id, cow.Id)
			if ok && calvingCalf != nil {
				eventDeathModel.CalvingCalf = calvingCalf
			}
		}

		if neckRing, ok := s.NeckRingIsExist(userModel.AppPasture.Id, item.EarNumber); ok && neckRing != nil {
			eventDeathModel.NeckRing = neckRing
		}
		newEventDeathList = append(newEventDeathList, eventDeathModel)
	}

	return newEventDeathList, nil
}