新增了用户病例处理

api/controller/Base.go

@@ -7,6 +7,7 @@ type Api struct {
 	BaseClass      // 分类
 	Question       // 问题
 	User           // 用户
+	UserCase       // 用户病例
 	UserCoupon     // 用户优惠卷
 	UserCollection // 用户收藏
 	OrderSingle    // 订单-单项

api/controller/User.go

@@ -86,63 +86,6 @@ func (r *User) PutUser(c *gin.Context) {
 	responses.Ok(c)
 }
 
-// PutBindUserName 绑定用户数据-昵称
-func (r *User) PutBindUserName(c *gin.Context) {
-	userRequest := requests.UserRequest{}
-	req := userRequest.PutBindUserName
-	if err := c.ShouldBind(&req); err != nil {
-		responses.FailWithMessage(err.Error(), c)
-		return
-	}
-
-	// 参数验证
-	if err := global.Validate.Struct(req); err != nil {
-		responses.FailWithMessage(utils.Translate(err), c)
-		return
-	}
-
-	if req.Nickname == "" {
-		responses.FailWithMessage("参数错误", c)
-		return
-	}
-
-	userId := c.GetInt64("UserId")
-
-	// 获取用户数据
-	userDao := dao.UserDao{}
-	user, err := userDao.GetUserById(userId)
-	if err != nil {
-		responses.FailWithMessage("用户数据错误", c)
-		return
-	}
-
-	if user.UserName != "" {
-		responses.Ok(c)
-		return
-	}
-
-	userData := make(map[string]interface{})
-	userData["user_name"] = req.Nickname
-
-	// 开始事务
-	tx := global.Db.Begin()
-	defer func() {
-		if r := recover(); r != nil {
-			tx.Rollback()
-		}
-	}()
-
-	err = userDao.EditUserById(tx, user.UserId, userData)
-	if err != nil {
-		tx.Rollback()
-		responses.FailWithMessage(err.Error(), c)
-		return
-	}
-
-	tx.Commit()
-	responses.Ok(c)
-}
-
 // GetUserCheck 检测用户数据绑定状态
 func (r *User) GetUserCheck(c *gin.Context) {
 	userRequest := requests.UserRequest{}

api/controller/UserCase.go

@@ -0,0 +1,229 @@
+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)
+}

api/dao/UserCase.go

@@ -37,6 +37,15 @@ func (r *UserCaseDao) GetUserCaseByUserId(userId int64) (m *model.UserCase, err
 	return m, nil
 }
 
+// GetUserCasePreloadByUserId 获取数据-user_id
+func (r *UserCaseDao) GetUserCasePreloadByUserId(userId int64) (m *model.UserCase, err error) {
+	err = global.Db.Preload(clause.Associations).Where("user_id = ?", userId).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // DeleteUserCase 删除
 func (r *UserCaseDao) DeleteUserCase(tx *gorm.DB, maps interface{}) error {
 	err := tx.Where(maps).Delete(&model.UserCase{}).Error

api/dao/UserCaseDiseaseItem.go

@@ -37,6 +37,15 @@ func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItemByUserCaseId(userCaseId i
 	return m, nil
 }
 
+// GetUserCaseDiseaseItemListPreloadByUserCaseId 获取数据-user_case_id
+func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItemListPreloadByUserCaseId(userCaseId int64) (m []*model.UserCaseDiseaseItem, err error) {
+	err = global.Db.Preload(clause.Associations).Where("user_case_id = ?", userCaseId).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // DeleteUserCaseDiseaseItem 删除
 func (r *UserCaseDiseaseItemDao) DeleteUserCaseDiseaseItem(tx *gorm.DB, maps interface{}) error {
 	err := tx.Where(maps).Delete(&model.UserCaseDiseaseItem{}).Error
@@ -54,6 +63,14 @@ func (r *UserCaseDiseaseItemDao) DeleteUserCaseDiseaseItemById(tx *gorm.DB, User
 	return nil
 }
 
+// DeleteUserCaseDiseaseItemByUserCaseIdId 删除-id
+func (r *UserCaseDiseaseItemDao) DeleteUserCaseDiseaseItemByUserCaseIdId(tx *gorm.DB, userCaseId int64) error {
+	if err := tx.Where("user_case_id = ?", userCaseId).Delete(&model.UserCaseDiseaseItem{}).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
 // EditUserCaseDiseaseItem 修改
 func (r *UserCaseDiseaseItemDao) EditUserCaseDiseaseItem(tx *gorm.DB, maps interface{}, data interface{}) error {
 	err := tx.Model(&model.UserCaseDiseaseItem{}).Where(maps).Updates(data).Error

api/dto/UserCase.go

@@ -0,0 +1,48 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-api/api/model"
+)
+
+// UserCaseDto 用户表-病例
+type UserCaseDto struct {
+	UserCaseId          string                    `json:"user_case_id"`           // 主键id
+	UserId              string                    `json:"user_id"`                // 用户id
+	IsHospital          *int                      `json:"is_hospital"`            // 是否医院就诊（0:否 1:是）
+	LiverStatus         string                    `json:"liver_status"`           // 肝脏状态
+	IsMedication        *int                      `json:"is_medication"`          // 是否服药（0:否 1:是）
+	Medication          string                    `json:"medication"`             // 服药名称
+	ChronicDisease      string                    `json:"chronic_disease"`        // 慢性疾病名称（逗号分隔）
+	IsAllergyHistory    *int                      `json:"is_allergy_history"`     // 过敏史（0:否 1:是）
+	AllergyHistory      string                    `json:"allergy_history"`        // 过敏史描述
+	CreatedAt           model.LocalTime           `json:"created_at"`             // 创建时间
+	UpdatedAt           model.LocalTime           `json:"updated_at"`             // 更新时间
+	UserCaseDiseaseItem []*UserCaseDiseaseItemDto `json:"user_case_disease_item"` // 所患疾病列表
+}
+
+// GetUserCaseDto 详情
+func GetUserCaseDto(m *model.UserCase) *UserCaseDto {
+	return &UserCaseDto{
+		UserCaseId:       fmt.Sprintf("%d", m.UserCaseId),
+		UserId:           fmt.Sprintf("%d", m.UserId),
+		IsHospital:       m.IsHospital,
+		LiverStatus:      m.LiverStatus,
+		IsMedication:     m.IsMedication,
+		Medication:       m.Medication,
+		ChronicDisease:   m.ChronicDisease,
+		IsAllergyHistory: m.IsAllergyHistory,
+		AllergyHistory:   m.AllergyHistory,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+// LoadUserCaseDiseaseItem 加载数据-疾病列表
+func (r *UserCaseDto) LoadUserCaseDiseaseItem(m []*model.UserCaseDiseaseItem) *UserCaseDto {
+	if len(m) > 0 {
+		r.UserCaseDiseaseItem = GetUserCaseDiseaseItemListDto(m)
+	}
+
+	return r
+}

api/dto/UserCaseDiseaseItem.go

@@ -0,0 +1,59 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-api/api/model"
+)
+
+// UserCaseDiseaseItemDto 用户-病例-所患疾病列表
+type UserCaseDiseaseItemDto struct {
+	ItemId           string          `json:"item_id"`            // 主键id
+	UserCaseId       string          `json:"user_case_id"`       // 用户病例id
+	DiseaseClassId   string          `json:"disease_class_id"`   // 疾病分类id
+	DiseaseClassName string          `json:"disease_class_name"` // 疾病分类名称
+	AppIden          string          `json:"app_iden"`           // app唯一标识
+	Duration         *int            `json:"duration"`           // 患病时长（年）
+	Genotype         string          `json:"genotype"`           // 基因型（仅丙肝存在）
+	CreatedAt        model.LocalTime `json:"created_at"`         // 创建时间
+	UpdatedAt        model.LocalTime `json:"updated_at"`         // 更新时间
+}
+
+// GetUserCaseDiseaseItemListDto 列表-分页
+func GetUserCaseDiseaseItemListDto(m []*model.UserCaseDiseaseItem) []*UserCaseDiseaseItemDto {
+	// 处理返回值
+	responses := make([]*UserCaseDiseaseItemDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &UserCaseDiseaseItemDto{
+				ItemId:         fmt.Sprintf("%d", v.ItemId),
+				UserCaseId:     fmt.Sprintf("%d", v.UserCaseId),
+				DiseaseClassId: fmt.Sprintf("%d", v.DiseaseClassId),
+				AppIden:        v.AppIden,
+				Duration:       v.Duration,
+				Genotype:       v.Genotype,
+				CreatedAt:      v.CreatedAt,
+				UpdatedAt:      v.UpdatedAt,
+			}
+
+			// 加载数据-疾病名称
+			if v.BaseDiseaseClass != nil {
+				response = response.LoadDiseaseClassName(v.BaseDiseaseClass)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadDiseaseClassName 加载数据-疾病名称
+func (r *UserCaseDiseaseItemDto) LoadDiseaseClassName(m *model.BaseDiseaseClass) *UserCaseDiseaseItemDto {
+	if m != nil {
+		r.DiseaseClassName = m.DiseaseClassName
+	}
+
+	return r
+}

api/model/UserCase.go

@@ -18,6 +18,7 @@ type UserCase struct {
 	IsAllergyHistory *int   `gorm:"column:is_allergy_history;type:tinyint(1);comment:过敏史（0:否 1:是）" json:"is_allergy_history"`
 	AllergyHistory   string `gorm:"column:allergy_history;type:varchar(100);comment:过敏史描述" json:"allergy_history"`
 	Model
+	UserCaseDiseaseItem []*UserCaseDiseaseItem `gorm:"foreignKey:UserCaseId;references:user_case_id" json:"user_case_disease_item"`
 }
 
 func (m *UserCase) TableName() string {

api/model/UserCaseDiseaseItem.go

@@ -15,6 +15,7 @@ type UserCaseDiseaseItem struct {
 	Duration       *int   `gorm:"column:duration;type:int(5);comment:患病时长（年）" json:"duration"`
 	Genotype       string `gorm:"column:genotype;type:varchar(20);comment:基因型（仅丙肝存在）" json:"genotype"`
 	Model
+	BaseDiseaseClass *BaseDiseaseClass `gorm:"foreignKey:DiseaseClassId;references:disease_class_id" json:"disease_class"`
 }
 
 func (m *UserCaseDiseaseItem) TableName() string {

api/requests/UserCase.go

@@ -0,0 +1,24 @@
+package requests
+
+type UserCaseRequest struct {
+	PutUserCase // 修改用户数据-病例
+}
+
+// PutUserCase 修改用户数据-病例
+type PutUserCase struct {
+	IsHospital          *int                              `json:"is_hospital" form:"is_hospital" label:"是否医院就诊"`
+	LiverStatus         string                            `json:"liver_status" form:"liver_status" label:"肝脏状态"`
+	IsMedication        *int                              `json:"is_medication" form:"is_medication" label:"是否服药"`
+	Medication          string                            `json:"medication" form:"medication" label:"服药名称"`
+	ChronicDisease      string                            `json:"chronic_disease" form:"chronic_disease" label:"慢性疾病名称（逗号分隔）"`
+	IsAllergyHistory    *int                              `json:"is_allergy_history" form:"is_allergy_history" label:"过敏史"`
+	AllergyHistory      string                            `json:"allergy_history" form:"allergy_history" label:"过敏史描述"`
+	UserCaseDiseaseItem []*PutUserCaseUserCaseDiseaseItem `json:"user_case_disease_item" form:"user_case_disease_item" label:"所患疾病列表"`
+}
+
+// PutUserCaseUserCaseDiseaseItem 修改用户数据-病例-所患疾病列表
+type PutUserCaseUserCaseDiseaseItem struct {
+	DiseaseClassId string `json:"disease_class_id" form:"disease_class_id" label:"疾病分类id" validate:"required"` // 疾病分类id
+	Duration       int    `json:"duration" form:"duration" label:"患病时长" validate:"required"`                   // 患病时长（年）
+	Genotype       string `json:"genotype" form:"genotype" label:"基因型（仅丙肝存在）"`                                 // 基因型（仅丙肝存在）
+}

api/router/router.go

@@ -184,6 +184,16 @@ func privateRouter(r *gin.Engine, api controller.Api) {
 
 		// 修改用户数据-基本信息
 		centerGroup.PUT("", api.User.PutUser)
+
+		// 用户病例
+		caseGroup := centerGroup.Group("/case")
+		{
+			// 获取用户数据-病例
+			caseGroup.GET("", api.UserCase.GetUserCase)
+
+			// 修改用户数据-病例
+			caseGroup.PUT("", api.UserCase.PutUserCase)
+		}
 	}
 
 	// 优惠卷

api/service/User.go

@@ -686,6 +686,18 @@ func (r *UserService) PutUser(userId int64, req requests.PutUser) (bool, error)
 		userData["sex"] = req.Sex
 	}
 
+	// 头像
+	if req.Avatar != "" {
+		avatar := utils.RemoveOssDomain(req.Avatar)
+		if avatar != user.Avatar {
+			userData["avatar"] = req.Avatar
+		}
+	} else {
+		if user.Avatar != "" {
+			userData["avatar"] = ""
+		}
+	}
+
 	// 身高
 	if req.Height != nil {
 		height := fmt.Sprintf("%d", *req.Height)
@@ -693,7 +705,9 @@ func (r *UserService) PutUser(userId int64, req requests.PutUser) (bool, error)
 			userInfoData["height"] = req.Height
 		}
 	} else {
-		userInfoData["height"] = nil
+		if userInfo.Height != "" {
+			userInfoData["height"] = nil
+		}
 	}
 
 	// 体重
@@ -703,7 +717,9 @@ func (r *UserService) PutUser(userId int64, req requests.PutUser) (bool, error)
 			userInfoData["weight"] = req.Weight
 		}
 	} else {
-		userInfoData["weight"] = nil
+		if userInfo.Weight != "" {
+			userInfoData["weight"] = nil
+		}
 	}
 
 	// 民族id