kpt-pasture/module/backend/event_health.go

package backend

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

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

	"gitee.com/xuyiping_admin/pkg/logger/zaplog"
	"go.uber.org/zap"

	"gorm.io/gorm"

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

// CowDiseaseList 发病牛只清单
func (s *StoreEntry) CowDiseaseList(ctx context.Context, req *pasturePb.SearchEventCowTreatmentRequest, pagination *pasturePb.PaginationModel) (*pasturePb.EventCowDiseaseResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	cowDiseaseList := make([]*model.EventCowDisease, 0)
	var count int64 = 0
	pref := s.DB.Table(fmt.Sprintf("%s as a", new(model.EventCowDisease).TableName())).
		Joins(fmt.Sprintf("JOIN %s AS b on a.cow_id = b.id", new(model.Cow).TableName())).
		Select("a.*,b.pen_name").
		Where("a.pasture_id = ?", userModel.AppPasture.Id).
		Where("b.admission_status = ?", pasturePb.AdmissionStatus_Admission)

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

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

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

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

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

	if req.DiseasedStartAt > 0 && req.DiseaseEndAt > 0 && req.DiseaseEndAt >= req.DiseasedStartAt {
		pref.Where("a.disease_at BETWEEN ? AND ?", req.DiseasedStartAt, req.DiseaseEndAt)
	}

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

	healthStatusMap := s.HealthStatusMap()
	return &pasturePb.EventCowDiseaseResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.EventCowDiseaseData{
			List:     model.EventCowDiseaseSlice(cowDiseaseList).ToPB(healthStatusMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

// CowDiseaseCreate 牛只发病提交
func (s *StoreEntry) CowDiseaseCreate(ctx context.Context, req *pasturePb.EventCowDiseaseRequest, source string) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}

	pastureId := userModel.AppPasture.Id
	// 牛只信息
	cow, err := s.GetCowInfoByEarNumber(ctx, pastureId, req.EarNumber)
	if err != nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID:    "cow.errorCow",
			TemplateData: map[string]interface{}{"earNumber": req.EarNumber},
		})
		return xerr.Customf(messageId)
	}

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

	operationUser, err := s.GetSystemUserById(ctx, int64(req.OperationId))
	if err != nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.checkOperation",
		})
		return xerr.Customf(messageId)
	}

	disease, err := s.GetDiseaseById(ctx, pastureId, req.DiseaseId)
	if err != nil {
		return xerr.WithStack(err)
	}

	var alreadyCount int64
	if err = s.DB.Model(new(model.EventCowDisease)).
		Where("cow_id = ?", cow.Id).
		Where("disease_id = ?", disease.Id).
		Where(s.DB.Where("health_status = ?", pasturePb.HealthStatus_Disease).Or("health_status = ?", pasturePb.HealthStatus_Treatment)).
		Count(&alreadyCount).Error; err != nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "health.cowExist",
		})
		return xerr.Customf(messageId)
	}

	if alreadyCount > 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "health.cowExist",
		})
		return xerr.Customf(messageId)
	}

	// 牛只疾病信息
	newEventCowDisease := model.NewEventCowDisease(pastureId, cow, disease, req, operationUser, userModel.SystemUser)
	// PC端h和脖环揭发直接跳过诊断过程
	if source == model.SourcePC || req.ExposeDiseaseType == pasturePb.ExposeDiseaseType_Neck_Ring {
		newEventCowDisease.DiagnosedResult = pasturePb.IsShow_Ok
		newEventCowDisease.DiagnoseOperationId = int32(operationUser.Id)
		newEventCowDisease.DiagnoseOperationName = operationUser.Name
		newEventCowDisease.Source = model.SourcePC
		newEventCowDisease.DiagnoseId = req.DiseaseId
		newEventCowDisease.DiagnoseName = disease.Name
		newEventCowDisease.HealthStatus = pasturePb.HealthStatus_Disease
	}

	if req.PrescriptionId > 0 || len(req.PrescriptionDetail) > 0 {
		newEventCowDisease.HealthStatus = pasturePb.HealthStatus_Treatment
		newEventCowDisease.DiagnosedResult = pasturePb.IsShow_Ok
		newEventCowDisease.FirstTreatmentAt = int64(req.DiseaseAt)
		newEventCowDisease.LastTreatmentAt = int64(req.DiseaseAt)
		newEventCowDisease.DiagnoseId = int32(disease.Id)
		newEventCowDisease.DiagnoseName = disease.Name
	}

	prescription := &model.Prescription{}
	prescriptionDetail := make([]*pasturePb.PrescriptionDrugsList, 0)
	// 获取处方信息
	if req.PrescriptionId > 0 {
		prescription, err = s.GetPrescriptionById(ctx, pastureId, req.PrescriptionId)
		if err != nil {
			return xerr.WithStack(err)
		}

		prescriptionDrugs, err := s.PrescriptionDrugsByPrescriptionId(ctx, pastureId, prescription.Id)
		if err != nil {
			return xerr.WithStack(err)
		}
		prescriptionDetail = model.PrescriptionDrugsSlice(prescriptionDrugs).ToPB()
	}

	// 创建新的处方
	if req.PrescriptionId <= 0 && len(req.PrescriptionDetail) > 0 {
		newPrescriptionRequest := &pasturePb.PrescriptionRequest{
			Name:                 fmt.Sprintf("%s-%s-%s", disease.Name, time.Now().Local().Format("20060102"), operationUser.Name),
			ApplicableDiseaseIds: []int32{req.DiseaseId},
			IsShow:               pasturePb.IsShow_Ok,
		}
		prescription = model.NewPrescription(
			pastureId, newPrescriptionRequest, fmt.Sprintf("%d", disease.Id),
			1, 0, 0, userModel.SystemUser,
		)

		if err = s.DB.Model(new(model.Prescription)).
			Create(prescription).Error; err != nil {
			zaplog.Error("CowDiseaseCreate", zap.Any("err", err), zap.Any("prescription", prescription))
			messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
				MessageID: "health.createPrescriptionFail",
			})
			return xerr.Customf(messageId)
		}

		newPrescriptionDrugs := model.NewPrescriptionDrugs(pastureId, prescription.Id, req.PrescriptionDetail)
		if err = s.DB.Model(new(model.PrescriptionDrugs)).
			Create(newPrescriptionDrugs).Error; err != nil {
			return xerr.WithStack(err)
		}
		prescriptionDetail = model.PrescriptionDrugsSlice(newPrescriptionDrugs).ToPB()
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		lastPrescriptionName := ""
		// 1. 更新处方使用次数
		if prescription.Id > 0 {
			prescription.EventUseCountUpdate() // 处方使用次数+1
			if err = tx.Model(new(model.Prescription)).
				Select("use_count").
				Where("id = ?", prescription.Id).
				Updates(prescription).Error; err != nil {
				return xerr.WithStack(err)
			}
			lastPrescriptionName = prescription.Name
			// 记录事件日志
			cowLogs := s.SubmitEventLog(ctx, pastureId, cow, pasturePb.EventType_Disease, newEventCowDisease)
			if err = tx.Table(cowLogs.TableName()).Create(cowLogs).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		// 2. 创建牛只疾病信息
		newEventCowDisease.LastPrescriptionName = lastPrescriptionName
		if err = tx.Model(new(model.EventCowDisease)).
			Create(newEventCowDisease).Error; err != nil {
			return xerr.WithStack(err)
		}
		// 3. 创建治疗记录
		if len(prescriptionDetail) > 0 {
			diseaseTypeMap := s.DiseaseTypeMap()
			newCowTreatmentRequest := &pasturePb.CowTreatmentRequest{
				CowId:              req.CowId,
				PrescriptionId:     prescription.Id,
				DiseaseId:          int32(disease.Id),
				DiseaseName:        disease.Name,
				DiseaseType:        disease.DiseaseType,
				PrescriptionDetail: prescriptionDetail,
				TreatmentResult:    pasturePb.TreatmentResult_GoOn,
				Remarks:            req.Remarks,
				TreatmentAt:        req.DiseaseAt,
			}
			newEventCowTreatment := model.NewEventCowTreatment(pastureId, prescription, newCowTreatmentRequest, diseaseTypeMap, operationUser, userModel.SystemUser)
			newEventCowTreatment.CowDiseaseId = newEventCowDisease.Id
			if err = tx.Model(new(model.EventCowTreatment)).
				Create(newEventCowTreatment).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		// 更新牛只健康状态
		if newEventCowDisease.HealthStatus == pasturePb.HealthStatus_Disease || newEventCowDisease.HealthStatus == pasturePb.HealthStatus_Treatment {
			cow.EventHealthStatusUpdate(newEventCowDisease.HealthStatus)
			if err = s.DB.Model(new(model.Cow)).
				Select("health_status").
				Where("id = ?", req.CowId).
				Updates(cow).Error; err != nil {
				zaplog.Error("CowDiseaseCreate", zap.Any("EventHealthStatusUpdate", err))
			}
		}

		// 更新栏舍信息
		if req.PenId > 0 {
			penMap := s.PenMap(ctx, userModel.AppPasture.Id)
			if penData, ok := penMap[req.PenId]; ok {
				cow.EventPenUpdate(penData)
				if err = s.DB.Model(new(model.Cow)).
					Select("pen_id", "pen_name").
					Where("id = ?", cow.Id).
					Updates(cow).Error; err != nil {
					zaplog.Error("CowDiseaseCreate", zap.Any("EventPenUpdate", err))
				}
			}
		}

		// 4. 如果是脖环揭发
		if req.ExposeDiseaseType == pasturePb.ExposeDiseaseType_Neck_Ring {
			if err = s.NeckRingUpdateHealth(ctx, pastureId, cow.Id, operationUser); err != nil {
				return xerr.WithStack(err)
			}
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

// CowDiseaseDiagnose 发病牛只诊断
func (s *StoreEntry) CowDiseaseDiagnose(ctx context.Context, req *pasturePb.CowDiagnosedRequest) 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 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID:    "cow.errorCowById",
			TemplateData: map[string]interface{}{"cowId": req.CowId},
		})
		return xerr.Customf(messageId)
	}

	eventCowDisease := &model.EventCowDisease{}
	if err = s.DB.Model(new(model.EventCowDisease)).
		Where("cow_id = ?", req.CowId).
		Where("id = ?", req.Id).
		Where("health_status = ?", pasturePb.HealthStatus_Health).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		First(eventCowDisease).Error; err != nil {
		zaplog.Error("CowDiseaseDiagnose", zap.Any("req", req), zap.Any("userModel", userModel))
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.errorCowData",
		})
		return xerr.Custom(messageId)
	}

	if eventCowDisease == nil || eventCowDisease.Id <= 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "health.errorCowData",
		})
		return xerr.Custom(messageId)
	}

	if req.DiagnosedResult == pasturePb.IsShow_No {
		// 未发病更新
		eventCowDisease.EventUnDiseaseUpdate(userModel.SystemUser, req.Remarks)
		if err = s.DB.Model(eventCowDisease).
			Select("diagnosed_result", "diagnose_operation_id", "diagnose_operation_name", "remarks").
			Where("id = ?", req.Id).
			Updates(eventCowDisease).Error; err != nil {
			return xerr.WithStack(err)
		}
		return nil
	}

	// 已发病
	disease, err := s.GetDiseaseById(ctx, userModel.AppPasture.Id, req.DiseaseId)
	if err != nil {
		return xerr.WithStack(err)
	}
	systemUser, err := s.GetSystemUserById(ctx, int64(req.OperationId))
	if err != nil {
		return xerr.WithStack(err)
	}

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		eventCowDisease.EventDiseaseUpdate(disease, systemUser, req.Temperature)
		if err = tx.Model(eventCowDisease).
			Select("health_status", "diagnosed_result", "diagnose_id", "diagnose_name", "temperature", "diagnose_operation_id", "diagnose_operation_name", "diagnosed_at").
			Where("id = ?", req.Id).
			Where("cow_id = ?", req.CowId).
			Updates(eventCowDisease).Error; err != nil {
			return xerr.WithStack(err)
		}

		cow.EventHealthStatusUpdate(pasturePb.HealthStatus_Disease)
		if err = tx.Model(cow).
			Select("health_status").
			Where("id = ?", cow.Id).
			Updates(cow).Error; err != nil {
			return xerr.WithStack(err)
		}

		// 记录事件日志
		cowLogs := s.SubmitEventLog(ctx, userModel.AppPasture.Id, cow, pasturePb.EventType_Disease, eventCowDisease)
		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
}

// CowDiseaseTreatment 发病牛只治疗
func (s *StoreEntry) CowDiseaseTreatment(ctx context.Context, req *pasturePb.CowTreatmentRequest) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}

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

	// 操作人信息
	operationUser, err := s.GetSystemUserById(ctx, int64(req.OperationId))
	if err != nil {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.checkOperation",
		})
		return xerr.Customf(messageId)
	}

	// 处方信息
	prescription, err := s.GetPrescriptionById(ctx, pastureId, req.PrescriptionId)
	if err != nil {
		return xerr.WithStack(err)
	}

	// 疾病信息
	disease, err := s.GetDiseaseById(ctx, pastureId, req.DiseaseId)
	if err != nil {
		return xerr.WithStack(err)
	}
	req.DiseaseName = disease.Name
	req.DiseaseType = disease.DiseaseType

	// 处方信息
	prescriptionDrugs, err := s.PrescriptionDrugsByPrescriptionId(ctx, pastureId, prescription.Id)
	if err != nil {
		return xerr.WithStack(err)
	}

	// 牛只疾病信息
	eventCowDisease := &model.EventCowDisease{}
	if err = s.DB.Where("cow_id = ?", req.CowId).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("id = ?", req.Id).
		First(eventCowDisease).Error; err != nil {
		return xerr.WithStack(err)
	}

	if eventCowDisease.HealthStatus != pasturePb.HealthStatus_Disease &&
		eventCowDisease.HealthStatus != pasturePb.HealthStatus_Treatment {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "cow.errorCowData",
		})
		return xerr.Custom(messageId)
	}

	if eventCowDisease.DiagnosedAt < int64(req.TreatmentAt) {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "health.treatmentTimeError",
		})
		return xerr.Custom(messageId)
	}

	// 处方详情
	unitMap := s.UnitMap()
	prescriptionDetail := make([]*pasturePb.PrescriptionDrugsList, len(prescriptionDrugs))
	for i, v := range prescriptionDrugs {
		prescriptionDetail[i] = &pasturePb.PrescriptionDrugsList{
			DrugsId:   int32(v.DrugsId),
			DrugsName: v.DrugsName,
			Unit:      v.Unit,
			UnitName:  unitMap[v.Unit],
			Dosages:   v.Dosages,
		}
	}
	req.PrescriptionDetail = prescriptionDetail
	healthStatus := pasturePb.HealthStatus_Treatment
	if req.TreatmentResult == pasturePb.TreatmentResult_Curable {
		healthStatus = pasturePb.HealthStatus_Curable
	}

	if req.TreatmentResult == pasturePb.TreatmentResult_Out {
		healthStatus = pasturePb.HealthStatus_Out
	}

	if req.TreatmentResult == pasturePb.TreatmentResult_Dead {
		healthStatus = pasturePb.HealthStatus_Dead
	}
	diseaseTypeMap := s.DiseaseTypeMap()
	newEventCowTreatment := model.NewEventCowTreatment(pastureId, prescription, req, diseaseTypeMap, operationUser, userModel.SystemUser)

	if err = s.DB.Transaction(func(tx *gorm.DB) error {
		if err = tx.Create(newEventCowTreatment).Error; err != nil {
			return xerr.WithStack(err)
		}
		eventCowDisease.EventTreatmentUpdate(healthStatus, int64(req.TreatmentAt), prescription.Name)
		if err = tx.Model(eventCowDisease).
			Select("health_status", "first_treatment_at", "last_treatment_at", "last_prescription_name").
			Where("id = ?", req.Id).
			Where("cow_id = ?", req.CowId).
			Updates(eventCowDisease).Error; err != nil {
			return xerr.WithStack(err)
		}

		cow.EventHealthStatusUpdate(healthStatus)
		if err = tx.Model(new(model.Cow)).
			Select("health_status").
			Where("id = ?", req.CowId).
			Updates(cow).Error; err != nil {
			return xerr.WithStack(err)
		}

		prescription.EventUseCountUpdate()
		if err = tx.Model(prescription).
			Select("use_count").
			Where("id = ?", prescription.Id).
			Updates(prescription).Error; err != nil {
			return xerr.WithStack(err)
		}
		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}

	return nil
}