kpt-pasture/module/backend/event_breed_more.go

package backend

import (
	"context"
	"encoding/json"
	"kpt-pasture/model"
	"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.PregnantCheckEventResponse, 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)
	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.PregnantCheckEventResponse{
		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) {
	pregnantCheckBatchModelList, err := s.PregnantCheckDataCheck(ctx, req)
	if err != nil {
		return xerr.WithStack(err)
	}

	abortionReasonsMap := s.AbortionReasonsMap()
	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,
				item.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)
			}

			// 记录日志
			cowLogs := s.SubmitEventLog(ctx, item.UserModel.AppPasture.Id, item.Cow, pasturePb.EventType_Pregnancy_Check, pasturePb.ExposeEstrusType_Invalid, req)
			tx.Table(cowLogs.TableName()).Create(cowLogs)

			// 更新上次配种结果
			if err = s.UpdateMatingResultEventCowLogByCowId(ctx, item.Cow.Id, s.MatingResultMap()[matingResult]); err != nil {
				zaplog.Error("PregnantCheckCreateBatch", zap.Any("UpdateMatingResultEventCowLogByCowId", err))
			}

			// 如果确定是流产
			if matingResult == pasturePb.MatingResult_Abort {
				newEventAbortion := model.NewEventAbortion(item.UserModel.AppPasture.Id, item.Cow, &pasturePb.EventAbortionRequest{
					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)
				}
			}
		}

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

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

	cow, err := s.GetCowInfoByCowId(ctx, userModel.AppPasture.Id, int64(req.CowId))
	if err != nil {
		return xerr.WithStack(err)
	}

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

	req.OperationName = systemUser.Name
	req.AbortionReasonsName = s.AbortionReasonsMap()[req.AbortionReasons]
	newEventAbortion := model.NewEventAbortion(userModel.AppPasture.Id, cow, req, pasturePb.IsShow_No)

	lastCowMating := &model.EventMating{}
	if err = s.DB.Model(new(model.EventMating)).Where("cow_id = ?", 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, int64(req.AbortionAt))
	// 更新流产数据
	cow.EventAbortionUpdate(int64(req.AbortionAt))

	defer func() {
		if err != nil {
			cowLogs := s.SubmitEventLog(ctx, userModel.AppPasture.Id, cow, pasturePb.EventType_Abort, pasturePb.ExposeEstrusType_Invalid, req)
			s.DB.Table(cowLogs.TableName()).Create(cowLogs)
		}
	}()

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		// 创建牛只流产事件数据
		if err = tx.Create(newEventAbortion).Error; err != nil {
			return xerr.WithStack(err)
		}
		// 更新牛只状态
		if err = tx.Model(new(model.Cow)).
			Select("is_pregnant", "last_abortion_at", "breed_status").
			Where("id = ?", req.CowId).
			Updates(cow).Error; err != nil {
			return xerr.WithStack(err)
		}

		// 更新最近一次配种结果为流产
		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) AbortionCreateBatch(ctx context.Context, req *pasturePb.EventAbortionBatch) error {
	if len(req.Item) <= 0 {
		return xerr.WithStack(xerr.New("流产数据不能为空"))
	}

	errors := make(map[int32]error)
	for _, v := range req.Item {
		if err := s.AbortionCreate(ctx, v); err != nil {
			errors[v.CowId] = err
		}
	}

	if len(errors) > 0 {
		b, _ := json.Marshal(errors)
		return xerr.WithStack(xerr.Customf("部分流产数据创建失败: %s", string(b)))
	}
	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 := 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(&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
}