hepa-calc-api/api/controller/UserCase.go

package controller

import (
	"github.com/gin-gonic/gin"
	"hepa-calc-api/api/dao"
	"hepa-calc-api/api/dto"
	"hepa-calc-api/api/model"
	"hepa-calc-api/api/requests"
	"hepa-calc-api/api/responses"
	"hepa-calc-api/extend/app"
	"hepa-calc-api/global"
	"hepa-calc-api/utils"
	"strconv"
)

type UserCase struct{}

// GetUserCase 获取用户数据-病例
func (r *UserCase) GetUserCase(c *gin.Context) {
	userId := c.GetInt64("UserId")

	// 获取用户数据-病例
	userCaseDao := dao.UserCaseDao{}
	userCase, err := userCaseDao.GetUserCaseByUserId(userId)
	if err != nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	// 获取疾病列表
	userCaseDiseaseItemDao := dao.UserCaseDiseaseItemDao{}
	userCaseDiseaseItems, err := userCaseDiseaseItemDao.GetUserCaseDiseaseItemListPreloadByUserCaseId(userCase.UserCaseId)
	if err != nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	// 处理返回数据
	g := dto.GetUserCaseDto(userCase)

	// 加载数据-疾病列表
	g.LoadUserCaseDiseaseItem(userCaseDiseaseItems)

	responses.OkWithData(g, c)
}

// PutUserCase 修改用户数据-病例
func (r *UserCase) PutUserCase(c *gin.Context) {
	userCaseRequest := requests.UserCaseRequest{}
	req := userCaseRequest.PutUserCase
	if err := c.ShouldBindJSON(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	userId := c.GetInt64("UserId")

	// 获取用户数据
	userDao := dao.UserDao{}
	user, err := userDao.GetUserById(userId)
	if err != nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	// 获取用户数据-病例
	userCaseDao := dao.UserCaseDao{}
	userCase, err := userCaseDao.GetUserCaseByUserId(userId)
	if err != nil {
		responses.FailWithMessage("用户数据错误", c)
		return
	}

	userCaseData := make(map[string]interface{})
	appData := app.UpdateUserCaseRequest{
		IsAllergy:      req.IsAllergyHistory,
		AllergyInfo:    req.AllergyHistory,
		IsHospital:     req.IsHospital,
		IsMedication:   req.IsMedication,
		MedicationInfo: req.Medication,
		LiverStatus:    req.LiverStatus,
		OtherDisease:   req.ChronicDisease,
		PatientUuid:    user.AppIden,
		DiseasesList:   nil,
	}

	// 是否医院就诊
	if req.IsHospital != nil {
		userCaseData["is_hospital"] = *req.IsHospital
	} else {
		userCaseData["is_hospital"] = nil
	}

	// 肝脏状态
	userCaseData["liver_status"] = req.LiverStatus

	// 是否服药
	if req.IsMedication != nil {
		userCaseData["is_medication"] = *req.IsMedication

		// 服药名称
		if *req.IsMedication == 1 {
			if req.Medication == "" {
				responses.FailWithMessage("请填写正在服用药品名称", c)
				return
			}

			userCaseData["medication"] = req.Medication
		}
	} else {
		userCaseData["is_medication"] = nil
		userCaseData["medication"] = ""
	}

	// 慢性疾病名称（逗号分隔）
	userCaseData["chronic_disease"] = req.ChronicDisease

	// 过敏史
	if req.IsAllergyHistory != nil {
		userCaseData["is_allergy_history"] = *req.IsAllergyHistory

		// 过敏史描述
		if *req.IsAllergyHistory == 1 {
			if req.AllergyHistory == "" {
				responses.FailWithMessage("请填写过敏史描述", c)
				return
			}

			userCaseData["allergy_history"] = req.AllergyHistory
		}
	} else {
		userCaseData["is_allergy_history"] = nil
		userCaseData["allergy_history"] = ""
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 删除疾病列表
	userCaseDiseaseItemDao := dao.UserCaseDiseaseItemDao{}
	err = userCaseDiseaseItemDao.DeleteUserCaseDiseaseItemByUserCaseIdId(tx, userCase.UserCaseId)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("操作失败", c)
		return
	}

	// 所患疾病列表
	if len(req.UserCaseDiseaseItem) > 0 {
		baseDiseaseClassDao := dao.BaseDiseaseClassDao{}
		diseasesLists := make([]*app.DiseasesListRequest, len(req.UserCaseDiseaseItem))

		for i, item := range req.UserCaseDiseaseItem {
			diseaseClassId, err := strconv.ParseInt(item.DiseaseClassId, 10, 64)
			if err != nil {
				tx.Rollback()
				responses.Fail(c)
				return
			}

			// 获取疾病分类数据
			baseDiseaseClass, err := baseDiseaseClassDao.GetBaseDiseaseClassById(diseaseClassId)
			if err != nil {
				tx.Rollback()
				responses.Fail(c)
				return
			}

			userCaseDiseaseItem := &model.UserCaseDiseaseItem{
				UserCaseId:     userCase.UserCaseId,
				DiseaseClassId: diseaseClassId,
				AppIden:        baseDiseaseClass.AppIden,
				Duration:       &item.Duration,
				Genotype:       item.Genotype,
			}

			userCaseDiseaseItem, err = userCaseDiseaseItemDao.AddUserCaseDiseaseItem(tx, userCaseDiseaseItem)
			if err != nil {
				tx.Rollback()
				responses.Fail(c)
				return
			}

			// app请求数据
			diseasesList := &app.DiseasesListRequest{
				Uuid: baseDiseaseClass.AppIden,
				Year: &item.Duration,
				Info: "",
				Name: baseDiseaseClass.DiseaseClassName,
			}
			diseasesLists[i] = diseasesList
		}

		appData.DiseasesList = diseasesLists
	}

	// 病例数据
	if len(userCaseData) > 0 {
		err := userCaseDao.EditUserCaseById(tx, userCase.UserCaseId, userCaseData)
		if err != nil {
			tx.Rollback()
			responses.Fail(c)
			return
		}
	}

	// app数据
	appData.PatientUuid = user.AppIden
	_, err = app.UpdateUserCase(appData)
	if err != nil {
		tx.Rollback()
		responses.Fail(c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}