kpt-pasture/module/backend/goods.go

package backend

import (
	"context"
	"fmt"
	"kpt-pasture/model"
	"net/http"
	"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) DrugsList(ctx context.Context, req *pasturePb.SearchDrugsRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchDrugsResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	drugsList := make([]*model.Drugs, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.Drugs)).Where("pasture_id = ?", userModel.AppPasture.Id)
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if req.Usage > 0 {
		pref.Where("usage_method = ?", req.Usage)
	}

	if req.CategoryId > 0 {
		pref.Where("category_id = ?", req.CategoryId)
	}

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

	return &pasturePb.SearchDrugsResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchDrugsData{
			List:     model.DrugsSlice(drugsList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

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

	req.CategoryName = s.DrugCategoryMaps()[req.CategoryId]
	req.UnitName = s.UnitMap()[req.Unit]
	req.UsageName = s.DrugUsageMaps()[req.Usage]

	newDrugs := model.NewDrugs(userModel.AppPasture.Id, req, userModel.SystemUser)
	if req.Id <= 0 {
		if err = s.DB.Create(newDrugs).Error; err != nil {
			return xerr.WithStack(err)
		}
	} else {
		if err = s.DB.Where("id = ?", req.Id).Updates(newDrugs).Error; err != nil {
			return xerr.WithStack(err)
		}
	}

	return nil
}

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

	medicalEquipmentList := make([]*model.MedicalEquipment, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.MedicalEquipment)).Where("pasture_id = ?", userModel.AppPasture.Id)
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

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

	unitMap := s.UnitMap()
	return &pasturePb.SearchMedicalEquipmentResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchMedicalEquipmentData{
			List:     model.MedicalEquipmentSlice(medicalEquipmentList).ToPB(unitMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) MedicalEquipmentCreateOrUpdate(ctx context.Context, req *pasturePb.SearchMedicalEquipmentList) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	newDrugs := model.NewMedicalEquipment(userModel.AppPasture.Id, req, userModel.SystemUser)
	if req.Id <= 0 {
		if err = s.DB.Create(newDrugs).Error; err != nil {
			return xerr.WithStack(err)
		}
	} else {
		if err = s.DB.Where("id = ?", req.Id).Updates(newDrugs).Error; err != nil {
			return xerr.WithStack(err)
		}
	}
	return nil
}

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

	if req.Items == nil || len(req.Items) == 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.selectNeckRing",
		})
		return xerr.Custom(messageId)
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		for _, item := range req.Items {
			number := ""
			cowInfo, err := s.GetCowInfoByEarNumber(ctx, userModel.AppPasture.Id, item.EarNumber)
			if err != nil {
				messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
					MessageID: "cow.cowNotExist",
					TemplateData: map[string]interface{}{
						"earNumber": item.EarNumber,
					},
				})
				return xerr.Customf(messageId)
			}

			newNeckRingLog := model.NewNeckRingBindLog(userModel.AppPasture.Id, item.Number, cowInfo, userModel.SystemUser, "")
			neckRing, ok := s.NeckRingIsExist(userModel.AppPasture.Id, item.Number)

			switch req.Status {
			case pasturePb.NeckRingOperationStatus_Bind: // 绑定
				if ok && neckRing.IsBind == pasturePb.NeckRingIsBind_Bind {
					messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
						MessageID: "goods.neckRingAlreadyBind",
						TemplateData: map[string]interface{}{
							"neckRingNumber": item.Number,
							"earNumber":      neckRing.EarNumber,
						},
					})
					return xerr.Customf(messageId)
				}

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

				newNeckRing := model.NewNeckRing(userModel.AppPasture.Id, item.Number, cowInfo, userModel.SystemUser)
				if err = tx.Create(newNeckRing).Error; err != nil {
					return xerr.WithStack(err)
				}
				number = item.Number
				newNeckRingLog.OperationName = model.OperationNameBind
				newNeckRingLog.Remarks = model.DefaultBind
				// 解绑
			case pasturePb.NeckRingOperationStatus_UnBind:
				if ok && neckRing.IsBind != pasturePb.NeckRingIsBind_Bind {
					messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
						MessageID: "goods.neckRingNotBind",
						TemplateData: map[string]interface{}{
							"neckRingNumber": item.Number,
						},
					})
					return xerr.Customf(messageId)
				}
				if err = tx.Model(new(model.NeckRing)).
					Where("id = ?", neckRing.Id).
					Updates(map[string]interface{}{
						"cow_id":     0,
						"ear_number": "",
						"wear_at":    0,
						"is_bind":    pasturePb.NeckRingIsBind_Unbind,
					}).Error; err != nil {
					return xerr.WithStack(err)
				}
				newNeckRingLog.OperationName = model.OperationNameUnbind
				newNeckRingLog.Remarks = model.DefaultUnBind
				// 编辑
			case pasturePb.NeckRingOperationStatus_Edit:
				if cowInfo.NeckRingNumber != "" && item.Number != cowInfo.NeckRingNumber {
					messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
						MessageID: "cow.neckRingNumberBind",
						TemplateData: map[string]interface{}{
							"neckRingNumber": cowInfo.NeckRingNumber,
							"earNumber":      cowInfo.EarNumber,
						},
					})
					return xerr.Customf(messageId)
				}

				if err = tx.Model(new(model.NeckRing)).
					Where("neck_ring_number = ?", item.Number).
					Updates(map[string]interface{}{
						"cow_id":     cowInfo.Id,
						"ear_number": cowInfo.EarNumber,
						"wear_at":    time.Now().Local().Unix(),
						"is_bind":    pasturePb.NeckRingIsBind_Bind,
					}).Error; err != nil {
					return xerr.WithStack(err)
				}
				number = item.Number
				newNeckRingLog.OperationName = model.OperationNameUpdate
			}

			if err = tx.Create(newNeckRingLog).Error; err != nil {
				return xerr.WithStack(err)
			}
			if err = tx.Model(new(model.Cow)).
				Where("id = ?", cowInfo.Id).
				Update("neck_ring_number", number).
				Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

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

	neckRingLogList := make([]*model.NeckRingModel, 0)
	var count int64 = 0

	pref := s.DB.Table(fmt.Sprintf("%s as a", new(model.NeckRing).TableName())).
		Select("a.*,COALESCE(b.pen_name, '') AS pen_name").
		Joins("LEFT JOIN cow as b ON a.cow_id = b.id").
		Where("a.pasture_id = ?", userModel.AppPasture.Id).
		Where("a.neck_ring_number != ?", "")

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

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

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

	if req.Number != "" {
		pref.Where("a.neck_ring_number like ?", fmt.Sprintf("%s%s%s", "%", req.Number, "%"))
	}

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

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

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

	neckRingIsBindMap := s.NeckRingIsBindMap()
	neckRingStatusMap := s.NeckRingStatusMap()
	return &pasturePb.SearchNeckRingResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchNeckRingData{
			List:     model.NeckRingSlice(neckRingLogList).ToPB(neckRingIsBindMap, neckRingStatusMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

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

	if len(req.Goods) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.selectOutGoods",
		})
		return xerr.Custom(messageId)
	}
	var outbound *model.Outbound
	if req.Id > 0 {
		outbound, err = s.GetOutboundById(ctx, userModel.AppPasture.Id, int64(req.Id))
		if err != nil || outbound == nil || outbound.Id <= 0 {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "goods.outGoodsNotExist",
			})
			return xerr.Customf(messageId)
		}
		if userModel.SystemUser.Id != int64(outbound.ApplicantId) {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "goods.outGoodsNotAllowEdit",
			})
			return xerr.Custom(messageId)
		}

		if outbound.AuditStatus != pasturePb.AuditStatus_Pending {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "goods.outGoodsNotEdit",
			})
			return xerr.Custom(messageId)
		}
	} else {
		// 创建出库申请
		outbound = model.NewOutbound(userModel.AppPasture.Id, req, userModel.SystemUser)
	}
	goodsItems := make([]*pasturePb.OutboundApplyGoodsItem, 0)
	switch req.OutType {
	case pasturePb.OutType_Drugs:
		for _, v := range req.Goods {
			if v.Quantity <= 0 {
				messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
					MessageID: "goods.goodsCount",
				})
				return xerr.Custom(messageId)
			}
			if v.GoodsId <= 0 {
				messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
					MessageID: "goods.selectOutGoods",
				})
				return xerr.Custom(messageId)
			}

			newDrugs := &model.Drugs{}
			if err = s.DB.Model(new(model.Drugs)).
				Where("id = ?", v.GoodsId).
				Where("inventory >= ?", v.Quantity).
				First(newDrugs).Error; err != nil {
				return xerr.WithStack(err)
			}
			goodsItems = append(goodsItems, &pasturePb.OutboundApplyGoodsItem{
				GoodsId:     v.GoodsId,
				Quantity:    v.Quantity,
				Unit:        v.Unit,
				GoodsName:   newDrugs.Name,
				Specs:       newDrugs.Specs,
				Producer:    newDrugs.Producer,
				BatchNumber: newDrugs.BatchNumber,
				Price:       float32(newDrugs.Price) / 100,
			})
		}
	case pasturePb.OutType_Medical_Equipment:
		for _, v := range req.Goods {
			if v.Quantity <= 0 {
				messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
					MessageID: "goods.goodsCount",
				})
				return xerr.Custom(messageId)
			}
			if v.GoodsId <= 0 {
				messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
					MessageID: "goods.selectOutGoods",
				})
				return xerr.Custom(messageId)
			}

			newMedicalEquipment := &model.MedicalEquipment{}
			if err = s.DB.Model(new(model.Drugs)).
				Where("id = ?", v.GoodsId).
				Where("inventory >= ?", v.Quantity).
				First(newMedicalEquipment).Error; err != nil {
				return xerr.WithStack(err)
			}
			goodsItems = append(goodsItems, &pasturePb.OutboundApplyGoodsItem{
				GoodsId:     v.GoodsId,
				Quantity:    v.Quantity,
				Unit:        v.Unit,
				GoodsName:   newMedicalEquipment.Name,
				Specs:       newMedicalEquipment.Specs,
				Producer:    newMedicalEquipment.Producer,
				BatchNumber: newMedicalEquipment.BatchNumber,
				Price:       float32(newMedicalEquipment.Price) / 100,
			})
		}
	default:
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.unknownOutGoodsType",
		})
		return xerr.Custom(messageId)
	}
	unitMap := s.UnitMap()
	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		if req.Id > 0 {
			if err = tx.Model(new(model.Outbound)).
				Where("id = ?", req.Id).
				Update("applicant_remarks", req.ApplicantRemarks).Error; err != nil {
				return xerr.WithStack(err)
			}

			if err = tx.Model(new(model.OutboundDetail)).
				Where("outbound_id = ?", req.Id).
				Update("is_delete = ?", pasturePb.IsShow_No).Error; err != nil {
				return xerr.WithStack(err)
			}
		} else {
			if err = tx.Create(outbound).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		outboundLog := model.NewOutboundDetailList(outbound.Id, goodsItems, unitMap)
		if err = tx.Create(outboundLog).Error; err != nil {
			return xerr.WithStack(err)
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

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

	var count int64 = 0
	outboundList := make([]*model.Outbound, 0)
	pref := s.DB.Model(new(model.Outbound)).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("audit_status < ?", pasturePb.AuditStatus_Delete)
	if req.OutType > 0 {
		pref.Where("out_type = ?", req.OutType)
	}

	if req.StartDayTime > 0 && req.EndDayTime > 0 && req.EndDayTime >= req.StartDayTime {
		pref.Where("applicant_at BETWEEN ? AND ?", req.StartDayTime, req.EndDayTime+86400)
	}

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

	if req.AuditStatus > 0 {
		pref.Where("audit_status = ?", req.AuditStatus)
	}

	if req.ApplicantId > 0 {
		pref.Where("applicant_id = ?", req.ApplicantId)
	}

	if req.ExamineId > 0 {
		pref.Where("examine_id = ?", req.ExamineId)
	}

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

	outTypeMap := s.OutTypeMap()
	auditStatusMap := s.AuditStatusMap()

	return &pasturePb.SearchOutboundApplyResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchOutboundApplyData{
			List:     model.OutboundSlice(outboundList).ToPB(outTypeMap, auditStatusMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

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

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

	if outbound == nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.outGoodsNotExist",
		})
		return xerr.Custom(messageId)
	}

	if req.AuditStatus != pasturePb.AuditStatus_Pass && req.AuditStatus != pasturePb.AuditStatus_Reject && req.AuditStatus != pasturePb.AuditStatus_Cancel {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.outGoodsAuditStatusError",
		})
		return xerr.Custom(messageId)
	}

	if outbound.AuditStatus != pasturePb.AuditStatus_Pending {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.outGoodsError",
		})
		return xerr.Custom(messageId)
	}

	outboundDetails, err := s.GetOutboundDetailByOutboundId(ctx, outbound.Id)
	if err != nil {
		return xerr.WithStack(err)
	}

	if len(outboundDetails) <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.outGoodsNotExist",
		})
		return xerr.Custom(messageId)
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		if err = tx.Model(outbound).
			Where("id = ?", outbound.Id).
			Updates(map[string]interface{}{
				"audit_status":    req.AuditStatus,
				"examine_id":      userModel.SystemUser.Id,
				"examine_name":    userModel.SystemUser.Name,
				"examine_remarks": req.ExamineRemarks,
				"examine_at":      time.Now().Local().Unix(),
			}).Error; err != nil {
			return xerr.WithStack(err)
		}

		if req.AuditStatus != pasturePb.AuditStatus_Pass {
			return nil
		}

		tableName := ""
		switch outbound.OutType {
		case pasturePb.OutType_Drugs:
			tableName = new(model.Drugs).TableName()
		case pasturePb.OutType_Medical_Equipment:
			tableName = new(model.MedicalEquipment).TableName()
		default:
			return nil
		}

		for _, v := range outboundDetails {
			if err = tx.Table(tableName).
				Where("id = ?", v.GoodsId).
				Updates(map[string]interface{}{
					"inventory": gorm.Expr("inventory - ?", v.Quantity),
				}).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}

func (s *StoreEntry) OutboundDetail(ctx context.Context, id int64) (*pasturePb.OutboundDetailResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	outbound, err := s.GetOutboundById(ctx, userModel.AppPasture.Id, id)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	outboundLogs, err := s.GetOutboundDetailByOutboundId(ctx, id)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	outTypeMap := s.OutTypeMap()
	auditStatusMap := s.AuditStatusMap()
	applicantAtFormat, examineAtFormat := "", ""
	if outbound.ApplicantAt > 0 {
		applicantAtFormat = time.Unix(outbound.ApplicantAt, 0).Local().Format(model.LayoutTime)
	}
	if outbound.ExamineAt > 0 {
		examineAtFormat = time.Unix(outbound.ExamineAt, 0).Local().Format(model.LayoutTime)
	}

	unitMap := s.UnitMap()
	return &pasturePb.OutboundDetailResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.OutboundApplyDetail{
			Id:                int32(outbound.Id),
			Number:            outbound.Number,
			OutType:           outbound.OutType,
			OutTypeName:       outTypeMap[outbound.OutType],
			AuditStatus:       outbound.AuditStatus,
			AuditStatusName:   auditStatusMap[outbound.AuditStatus],
			ApplicantName:     outbound.ApplicantName,
			ApplicantRemarks:  outbound.ApplicantRemarks,
			ExamineName:       outbound.ExamineName,
			ExamineRemarks:    outbound.ExamineRemarks,
			ApplicantAtFormat: applicantAtFormat,
			ExamineAtFormat:   examineAtFormat,
			GoodsItem: &pasturePb.OutboundApplyItem{
				OutType:          outbound.OutType,
				Goods:            model.OutboundDetailSlice(outboundLogs).ToPB(unitMap),
				ApplicantRemarks: outbound.ApplicantRemarks,
			},
		},
	}, nil
}

func (s *StoreEntry) OutboundDelete(ctx context.Context, id int64) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}

	outbound, err := s.GetOutboundById(ctx, userModel.AppPasture.Id, id)
	if err != nil {
		return xerr.WithStack(err)
	}

	if outbound == nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.outGoodsNotExist",
		})
		return xerr.Custom(messageId)
	}

	if !(outbound.AuditStatus == pasturePb.AuditStatus_Pending || outbound.AuditStatus == pasturePb.AuditStatus_Cancel) {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.outGoodsNotDelete",
		})
		return xerr.Custom(messageId)
	}

	if userModel.SystemUser.Id != int64(outbound.ApplicantId) {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "goods.outGoodsNotAllowDelete",
		})
		return xerr.Custom(messageId)
	}

	outbound.Delete()
	if err = s.DB.Model(new(model.Outbound)).
		Select("audit_status").
		Where("id = ?", outbound.Id).
		Updates(outbound).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

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

	frozenSemenList := make([]*model.FrozenSemen, 0)
	var count int64 = 0
	pref := s.DB.Table(new(model.FrozenSemen).TableName()).
		Where("pasture_id = ?", userModel.AppPasture.Id)
	if req.BullId != "" {
		pref.Where("bull_id = ?", req.BullId)
	}

	if req.Producer != "" {
		pref.Where("producer = ?", req.Producer)
	}

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

	frozenSemenTypeMap := s.FrozenSemenTypeMap()
	unitMap := s.UnitMap()

	return &pasturePb.FrozenSemenResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.SearchFrozenSemenData{
			List:     model.FrozenSemenSlice(frozenSemenList).ToPB(frozenSemenTypeMap, unitMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

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

	req.CowKindName = s.CowKindMap()[req.CowKind]
	if req.Id > 0 {
		histData := &model.FrozenSemen{}
		if err = s.DB.Model(new(model.FrozenSemen)).
			Where("id = ?", req.Id).
			Where("pasture_id = ?", userModel.AppPasture.Id).
			First(histData).
			Error; err != nil {
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "goods.dataNotExist",
				TemplateData: map[string]interface{}{
					"id": req.Id,
				},
			})
			return xerr.Customf(messageId)
		}

		histData.UpdateData(req)
		if err = s.DB.Model(new(model.FrozenSemen)).
			Where("id = ?", req.Id).
			Where("pasture_id = ?", userModel.AppPasture.Id).
			Updates(histData).Error; err != nil {
			return xerr.WithStack(err)
		}

	} else {
		newFrozenSemen := model.NewFrozenSemen(userModel.AppPasture.Id, req, userModel.SystemUser)
		if err = s.DB.Create(newFrozenSemen).Error; err != nil {
			return xerr.WithStack(err)
		}
	}

	return nil
}