kpt-pasture/module/backend/event_breed_more.go

package backend

import (
	"context"
	"kpt-pasture/model"
	"kpt-pasture/util"
	"net/http"
	"strings"

	"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"
	"gorm.io/gorm"
)

func (s *StoreEntry) PregnantCheckList(ctx context.Context, req *pasturePb.SearchEventRequest, pagination *pasturePb.PaginationModel) (*pasturePb.EventPregnantCheckResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.Custom("当前用户信息错误,请退出重新登录")
	}

	pregnantCheckList := make([]*model.EventPregnantCheck, 0)
	var count int64 = 0
	pref := s.DB.Table(new(model.EventPregnantCheck).TableName()).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("status = ?", pasturePb.IsShow_Ok)
	if len(req.CowId) > 0 {
		cowIds := strings.Split(req.CowId, ",")
		pref.Where("cow_id IN ?", cowIds)
	}

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

	pregnantCheckResultMap := s.PregnantCheckResultMap()
	pregnantCheckMethodMap := s.PregnantCheckMethodMap()
	return &pasturePb.EventPregnantCheckResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchPregnantCheckData{
			List:     model.EventPregnantCheckSlice(pregnantCheckList).ToPB(pregnantCheckResultMap, pregnantCheckMethodMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

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

	pregnantCheckBatchModelList, err := s.PregnantCheckDataCheck(ctx, userModel.AppPasture.Id, req)
	if err != nil {
		return xerr.WithStack(err)
	}

	abortionReasonsMap := s.AbortionReasonsMap()
	matingResultMap := s.MatingResultMap()

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		for _, item := range pregnantCheckBatchModelList {
			breedStatus := pasturePb.BreedStatus_Pregnant
			isPregnant := pasturePb.IsShow_Ok
			matingResult := pasturePb.MatingResult_Pregnant

			if item.PregnantCheckResult == pasturePb.PregnantCheckResult_UnPregnant {
				breedStatus = pasturePb.BreedStatus_Empty
				isPregnant = pasturePb.IsShow_No
				matingResult = pasturePb.MatingResult_Empty
			}

			// 更新上一次配种结果数据,如何是复检无胎则更新为流产
			if item.EventPregnancyCheck.PregnantCheckName == model.PregnantCheckForSecond {
				breedStatus = pasturePb.BreedStatus_Abort
				matingResult = pasturePb.MatingResult_Abort
			}

			item.Cow.EventPregnantCheckUpdate(breedStatus, int64(item.PregnantCheckAt), isPregnant)
			// 更新牛只基本信息
			if err = tx.Model(item.Cow).
				Select("breed_status", "last_pregnant_check_at", "is_pregnant").
				Where("id = ?", item.Cow.Id).
				Updates(item.Cow).Error; err != nil {
				return xerr.WithStack(err)
			}

			// 更新最近一次配种结果数据
			item.LastMating.EventMatingResultUpdate(matingResult, int64(item.PregnantCheckAt))
			if err = tx.Model(item.LastMating).
				Where("id = ?", item.LastMating.Id).
				Select("mating_result", "mating_result_at").
				Updates(item.LastMating).Error; err != nil {
				return xerr.WithStack(err)
			}

			// 更新孕检事件表
			item.EventPregnancyCheck.EventUpdate(int64(item.PregnantCheckAt), item.PregnantCheckResult, item.PregnantCheckMethod,
				item.OperationUser, userModel.SystemUser, item.Remarks)
			if err = tx.Model(new(model.EventPregnantCheck)).
				Select("reality_day", "pregnant_check_result", "pregnant_check_method", "operation_id", "operation_name", "message_id", "message_name", "remarks", "status").
				Where("id = ?", item.EventPregnancyCheck.Id).
				Updates(item.EventPregnancyCheck).Error; err != nil {
				return xerr.WithStack(err)
			}

			// 更新上次配种结果
			matingResultName := ""
			if matingRName, ok := matingResultMap[matingResult]; ok {
				matingResultName = matingRName
			}

			if err = s.UpdateMatingResultEventCowLogByCowId(ctx, item.Cow.Id, matingResultName); err != nil {
				zaplog.Error("PregnantCheckCreateBatch", zap.Any("UpdateMatingResultEventCowLogByCowId", err))
				return xerr.WithStack(err)
			}

			// 如果确定是流产
			if matingResult == pasturePb.MatingResult_Abort {
				newEventAbortion := model.NewEventAbortion(userModel.AppPasture.Id, item.Cow, &pasturePb.EventAbortionItem{
					CowId:               int32(item.Cow.Id),
					AbortionAt:          item.PregnantCheckAt,
					IsAfterbirth:        pasturePb.IsShow_No,
					Photos:              []string{},
					AbortionReasons:     pasturePb.AbortionReasons_Unknown,
					AbortionReasonsName: abortionReasonsMap[pasturePb.AbortionReasons_Unknown],
					Remarks:             "追加流产数据",
					OperationId:         int32(item.OperationUser.Id),
					OperationName:       item.OperationUser.Name,
				}, pasturePb.IsShow_Ok)
				if err = tx.Create(newEventAbortion).Error; err != nil {
					return xerr.WithStack(err)
				}
			}
			// 记录日志
			cowLogs := s.SubmitEventLog(ctx, userModel.AppPasture.Id, item.Cow, pasturePb.EventType_Pregnancy_Check, pasturePb.ExposeEstrusType_Invalid, item)
			if err = tx.Table(cowLogs.TableName()).Create(cowLogs).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) AbortionCreateBatch(ctx context.Context, req *pasturePb.EventAbortionBatch) error {
	if len(req.Items) <= 0 {
		return nil
	}
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}

	eventAbortionModelList, err := s.AbortionEventDataCheck(ctx, userModel, req.Items)
	if err != nil {
		return xerr.WithStack(err)
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		for _, item := range eventAbortionModelList {
			if err = tx.Create(item.EventAbortion).Error; err != nil {
				return xerr.WithStack(err)
			}

			item.Cow.EventAbortionUpdate(item.EventAbortion.AbortionAt)

			// 更新牛只状态
			if err = tx.Model(new(model.Cow)).
				Select("is_pregnant", "last_abortion_at", "breed_status").
				Where("id = ?", item.Cow.Id).
				Updates(item.Cow).Error; err != nil {
				return xerr.WithStack(err)
			}

			lastCowMating := &model.EventMating{}
			if err = s.DB.Model(new(model.EventMating)).Where("cow_id = ?", item.Cow.Id).
				Where("mating_result = ?", pasturePb.MatingResult_Pregnant).
				Order("id desc").First(lastCowMating).Error; err != nil {
				return xerr.WithStack(err)
			}
			// 更新最近一次配种结果为流产
			lastCowMating.EventMatingResultUpdate(pasturePb.MatingResult_Abort, item.EventAbortion.AbortionAt)
			// 更新最近一次配种结果为流产
			if err = tx.Model(new(model.EventMating)).
				Select("mating_result", "mating_result_at").
				Where("id = ?", lastCowMating.Id).
				Updates(lastCowMating).Error; err != nil {
			}
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}

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

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

	if len(req.CowId) > 0 {
		cowIds, err := util.ConvertCowIdsToInt64Slice(req.CowId)
		if err != nil {
			return nil, xerr.Custom("cowId转换失败")
		}
		pref.Where("cow_id IN (?)", cowIds)
	}

	if req.StartDayAt > 0 && req.EndDayAt > 0 && req.StartDayAt <= req.EndDayAt {
		pref.Where("abortion_at BETWEEN ? AND ?", req.StartDayAt, req.EndDayAt)
	}

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

	return &pasturePb.EventAbortionResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.EventAbortionData{
			List:     model.AbortionSlice(abortionList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}