gdxz/hepa-calc-api
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改了手机号登录

Browse Source
This commit is contained in:
admin
2024-08-16 14:13:19 +08:00
parent 9a3a6bbb2e
commit 3fcc745e83
11 changed files with 724 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files
api/controller/Login.go
+22 -35
View File
@@ -56,6 +56,9 @@ func (r *Login) LoginPhone(c *gin.Context) {
}
}()
var userInfo *model.UserInfo
var err error
// 检测用户信息
userDao := dao.UserDao{}
maps := make(map[string]interface{})
@@ -88,7 +91,7 @@ func (r *Login) LoginPhone(c *gin.Context) {
loginAt := model.LocalTime(time.Now())
user.LoginAt = &loginAt
user, err := userDao.AddUser(tx, user)
user, err = userDao.AddUser(tx, user)
if err != nil {
tx.Rollback()
responses.FailWithMessage(err.Error(), c)
@@ -96,7 +99,7 @@ func (r *Login) LoginPhone(c *gin.Context) {
}
// 新增用户详情
userInfo := &model.UserInfo{
userInfo = &model.UserInfo{
UserId: user.UserId,
Height: "",
Weight: "",
@@ -118,34 +121,32 @@ func (r *Login) LoginPhone(c *gin.Context) {
responses.FailWithMessage(err.Error(), c)
return
}
// 处理app用户数据
userService := service.UserService{}
err = userService.HandleAppUserInfo(tx, user, userInfo)
if err != nil {
tx.Rollback()
responses.FailWithMessage(err.Error(), c)
return
}
} else {
// 获取用户详情数据
userInfoDao := dao.UserInfoDao{}
userInfo, err := userInfoDao.GetUserInfoByUserId(user.UserId)
userInfo, err = userInfoDao.GetUserInfoByUserId(user.UserId)
if err != nil {
tx.Rollback()
responses.FailWithMessage(err.Error(), c)
return
}
}
// 处理app用户数据
userService := service.UserService{}
err = userService.HandleAppUserInfo(tx, user, userInfo)
if err != nil {
tx.Rollback()
responses.FailWithMessage(err.Error(), c)
return
}
// 处理app用户数据
userService := service.UserService{}
err = userService.HandleAppUserInfo(tx, user, userInfo)
if err != nil {
tx.Rollback()
responses.FailWithMessage(err.Error(), c)
return
}
// 处理app用户病例数据
err = userService.HandleAppUserCase(tx, user)
if err != nil {
tx.Rollback()
responses.FailWithMessage(err.Error(), c)
return
}
tx.Commit()
@@ -162,13 +163,6 @@ func (r *Login) LoginPhone(c *gin.Context) {
return
}
// 获取用户数据
user, err = userDao.GetUser(maps)
if err != nil {
responses.FailWithMessage("登陆失败", c)
return
}
// 处理返回值
g := dto.LoginMobileDto(user)
@@ -261,13 +255,6 @@ func (r *Login) LoginWx(c *gin.Context) {
responses.FailWithMessage(err.Error(), c)
return
}
// 获取app用户信息
//var result *string
//if result == nil {
// // 新增app用户信息
//}
tx.Commit()
}
api/dao/BaseDiseaseClass.go
+117
View File
@@ -0,0 +1,117 @@
package dao
import (
"gorm.io/gorm"
"gorm.io/gorm/clause"
"hepa-calc-api/api/model"
"hepa-calc-api/global"
)
type BaseDiseaseClassDao struct {
}
// GetBaseDiseaseClassById 获取数据-id
func (r *BaseDiseaseClassDao) GetBaseDiseaseClassById(id int64) (m *model.BaseDiseaseClass, err error) {
err = global.Db.First(&m, id).Error
if err != nil {
return nil, err
}
return m, nil
}
// GetBaseDiseaseClassPreloadById 获取数据-加载全部关联-id
func (r *BaseDiseaseClassDao) GetBaseDiseaseClassPreloadById(id int64) (m *model.BaseDiseaseClass, err error) {
err = global.Db.Preload(clause.Associations).First(&m, id).Error
if err != nil {
return nil, err
}
return m, nil
}
// GetBaseDiseaseClassByAppIden 获取数据-app_iden
func (r *BaseDiseaseClassDao) GetBaseDiseaseClassByAppIden(appIden string) (m *model.BaseDiseaseClass, err error) {
err = global.Db.Where("app_iden = ?", appIden).First(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// DeleteBaseDiseaseClass 删除
func (r *BaseDiseaseClassDao) DeleteBaseDiseaseClass(tx *gorm.DB, maps interface{}) error {
err := tx.Where(maps).Delete(&model.BaseDiseaseClass{}).Error
if err != nil {
return err
}
return nil
}
// DeleteBaseDiseaseClassById 删除-id
func (r *BaseDiseaseClassDao) DeleteBaseDiseaseClassById(tx *gorm.DB, id int64) error {
if err := tx.Delete(&model.BaseDiseaseClass{}, id).Error; err != nil {
return err
}
return nil
}
// EditBaseDiseaseClass 修改
func (r *BaseDiseaseClassDao) EditBaseDiseaseClass(tx *gorm.DB, maps interface{}, data interface{}) error {
err := tx.Model(&model.BaseDiseaseClass{}).Where(maps).Updates(data).Error
if err != nil {
return err
}
return nil
}
// EditBaseDiseaseClassById 修改-id
func (r *BaseDiseaseClassDao) EditBaseDiseaseClassById(tx *gorm.DB, id int64, data interface{}) error {
err := tx.Model(&model.BaseDiseaseClass{}).Where("id = ?", id).Updates(data).Error
if err != nil {
return err
}
return nil
}
// GetBaseDiseaseClassList 获取列表
func (r *BaseDiseaseClassDao) GetBaseDiseaseClassList(maps interface{}) (m []*model.BaseDiseaseClass, err error) {
err = global.Db.Where(maps).Find(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// GetBaseDiseaseClassCount 获取数量
func (r *BaseDiseaseClassDao) GetBaseDiseaseClassCount(maps interface{}) (total int64, err error) {
err = global.Db.Model(&model.BaseDiseaseClass{}).Where(maps).Count(&total).Error
if err != nil {
return 0, err
}
return total, nil
}
// GetBaseDiseaseClassListRand 获取列表-随机
func (r *BaseDiseaseClassDao) GetBaseDiseaseClassListRand(maps interface{}, limit int) (m []*model.BaseDiseaseClass, err error) {
err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// AddBaseDiseaseClass 新增
func (r *BaseDiseaseClassDao) AddBaseDiseaseClass(tx *gorm.DB, model *model.BaseDiseaseClass) (*model.BaseDiseaseClass, error) {
if err := tx.Create(model).Error; err != nil {
return nil, err
}
return model, nil
}
// GetBaseDiseaseClass 获取
func (r *BaseDiseaseClassDao) GetBaseDiseaseClass(maps interface{}) (m *model.BaseDiseaseClass, err error) {
err = global.Db.Where(maps).First(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
api/dao/UserCase.go
+9
View File
@@ -28,6 +28,15 @@ func (r *UserCaseDao) GetUserCasePreloadById(UserCaseId int64) (m *model.UserCas
return m, nil
}
// GetUserCaseByUserId 获取数据-user_id
func (r *UserCaseDao) GetUserCaseByUserId(userId int64) (m *model.UserCase, err error) {
err = global.Db.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
+117
View File
@@ -0,0 +1,117 @@
package dao
import (
"gorm.io/gorm"
"gorm.io/gorm/clause"
"hepa-calc-api/api/model"
"hepa-calc-api/global"
)
type UserCaseDiseaseItemDao struct {
}
// GetUserCaseDiseaseItemById 获取数据-id
func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItemById(itemId int64) (m *model.UserCaseDiseaseItem, err error) {
err = global.Db.First(&m, itemId).Error
if err != nil {
return nil, err
}
return m, nil
}
// GetUserCaseDiseaseItemPreloadById 获取数据-加载全部关联-id
func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItemPreloadById(itemId int64) (m *model.UserCaseDiseaseItem, err error) {
err = global.Db.Preload(clause.Associations).First(&m, itemId).Error
if err != nil {
return nil, err
}
return m, nil
}
// GetUserCaseDiseaseItemByUserCaseId 获取数据-user_case_id
func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItemByUserCaseId(userCaseId int64) (m *model.UserCaseDiseaseItem, err error) {
err = global.Db.Where("user_case_id = ?", userCaseId).First(&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
if err != nil {
return err
}
return nil
}
// DeleteUserCaseDiseaseItemById 删除-id
func (r *UserCaseDiseaseItemDao) DeleteUserCaseDiseaseItemById(tx *gorm.DB, UserCaseDiseaseItemId int64) error {
if err := tx.Delete(&model.UserCaseDiseaseItem{}, UserCaseDiseaseItemId).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
if err != nil {
return err
}
return nil
}
// EditUserCaseDiseaseItemById 修改-id
func (r *UserCaseDiseaseItemDao) EditUserCaseDiseaseItemById(tx *gorm.DB, itemId int64, data interface{}) error {
err := tx.Model(&model.UserCaseDiseaseItem{}).Where("item_id = ?", itemId).Updates(data).Error
if err != nil {
return err
}
return nil
}
// GetUserCaseDiseaseItemList 获取列表
func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItemList(maps interface{}) (m []*model.UserCaseDiseaseItem, err error) {
err = global.Db.Where(maps).Find(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// GetUserCaseDiseaseItemCount 获取数量
func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItemCount(maps interface{}) (total int64, err error) {
err = global.Db.Model(&model.UserCaseDiseaseItem{}).Where(maps).Count(&total).Error
if err != nil {
return 0, err
}
return total, nil
}
// GetUserCaseDiseaseItemListRand 获取列表-随机
func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItemListRand(maps interface{}, limit int) (m []*model.UserCaseDiseaseItem, err error) {
err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// AddUserCaseDiseaseItem 新增
func (r *UserCaseDiseaseItemDao) AddUserCaseDiseaseItem(tx *gorm.DB, model *model.UserCaseDiseaseItem) (*model.UserCaseDiseaseItem, error) {
if err := tx.Create(model).Error; err != nil {
return nil, err
}
return model, nil
}
// GetUserCaseDiseaseItem 获取
func (r *UserCaseDiseaseItemDao) GetUserCaseDiseaseItem(maps interface{}) (m *model.UserCaseDiseaseItem, err error) {
err = global.Db.Where(maps).First(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
api/model/BaseDiseaseClass.go
+34
View File
@@ -0,0 +1,34 @@
package model
import (
"gorm.io/gorm"
"hepa-calc-api/global"
"time"
)
// BaseDiseaseClass 基础-疾病分类
type BaseDiseaseClass struct {
DiseaseClassId int64 `gorm:"column:disease_class_id;type:bigint(19);primary_key;comment:主键id" json:"disease_class_id"`
AppIden string `gorm:"column:app_iden;type:varchar(50);comment:app唯一标识" json:"app_iden"`
DiseaseClassName string `gorm:"column:disease_class_name;type:varchar(255);comment:疾病分类名称" json:"disease_class_name"`
Sort int `gorm:"column:sort;type:int(5);default:0;comment:排序值" json:"sort"`
Model
}
func (m *BaseDiseaseClass) TableName() string {
return "base_disease_class"
}
func (m *BaseDiseaseClass) BeforeCreate(tx *gorm.DB) error {
if m.DiseaseClassId == 0 {
m.DiseaseClassId = global.Snowflake.Generate().Int64()
}
m.CreatedAt = LocalTime(time.Now())
tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
m.UpdatedAt = LocalTime(time.Now())
tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
return nil
}
api/model/UserCase.go
+21 -1
View File
@@ -1,5 +1,11 @@
package model
import (
"gorm.io/gorm"
"hepa-calc-api/global"
"time"
)
// UserCase 用户表-病例
type UserCase struct {
UserCaseId int64 `gorm:"column:user_case_id;type:bigint(19);primary_key;comment:主键id" json:"user_case_id"`
@@ -8,7 +14,7 @@ type UserCase struct {
LiverStatus string `gorm:"column:liver_status;type:varchar(30);comment:肝脏状态" json:"liver_status"`
IsMedication *int `gorm:"column:is_medication;type:tinyint(1);comment:是否服药（0:否 1:是）" json:"is_medication"`
Medication string `gorm:"column:medication;type:varchar(20);comment:服药名称" json:"medication"`
Disease string `gorm:"column:disease;type:varchar(500);comment:慢性疾病名称（逗号分隔）" json:"disease"`
ChronicDisease string `gorm:"column:chronic_disease;type:varchar(500);comment:慢性疾病名称（逗号分隔）" json:"chronic_disease"`
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
@@ -17,3 +23,17 @@ type UserCase struct {
func (m *UserCase) TableName() string {
return "user_case"
}
func (m *UserCase) BeforeCreate(tx *gorm.DB) error {
if m.UserCaseId == 0 {
m.UserCaseId = global.Snowflake.Generate().Int64()
}
m.CreatedAt = LocalTime(time.Now())
tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
m.UpdatedAt = LocalTime(time.Now())
tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
return nil
}
api/model/UserCaseDiseaseItem.go
+36
View File
@@ -0,0 +1,36 @@
package model
import (
"gorm.io/gorm"
"hepa-calc-api/global"
"time"
)
// UserCaseDiseaseItem 用户-病例-所患疾病列表
type UserCaseDiseaseItem struct {
ItemId int64 `gorm:"column:item_id;type:bigint(19);primary_key;comment:主键id" json:"item_id"`
UserCaseId int64 `gorm:"column:user_case_id;type:bigint(19);comment:用户病例id" json:"user_case_id"`
DiseaseClassId int64 `gorm:"column:disease_class_id;type:bigint(19);comment:疾病分类id" json:"disease_class_id"`
AppIden string `gorm:"column:app_iden;type:varchar(50);comment:app唯一标识" json:"app_iden"`
Duration *int `gorm:"column:duration;type:int(5);comment:患病时长（年）" json:"duration"`
Genotype string `gorm:"column:genotype;type:varchar(20);comment:基因型（仅丙肝存在）" json:"genotype"`
Model
}
func (m *UserCaseDiseaseItem) TableName() string {
return "user_case_disease_item"
}
func (m *UserCaseDiseaseItem) BeforeCreate(tx *gorm.DB) error {
if m.ItemId == 0 {
m.ItemId = global.Snowflake.Generate().Int64()
}
m.CreatedAt = LocalTime(time.Now())
tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
m.UpdatedAt = LocalTime(time.Now())
tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
return nil
}
api/service/User.go
+218 -13
View File
@@ -169,7 +169,7 @@ func (r *UserService) HandleAppUserInfo(tx *gorm.DB, user *model.User, userInfo
// 出生日期/年龄
if appUserInfo.Data.Birthday != "" {
if user.Birthday != nil {
birthday := time.Time(*user.Birthday).Format("2006-01-02 15:04:05")
birthday := time.Time(*user.Birthday).Format("2006-01-02")
if appUserInfo.Data.Birthday != birthday {
userData["birthday"] = appUserInfo.Data.Birthday
}
@@ -213,8 +213,8 @@ func (r *UserService) HandleAppUserInfo(tx *gorm.DB, user *model.User, userInfo
}
// 体重
if appUserInfo.Data.Weight != nil {
weight := fmt.Sprintf("%f", appUserInfo.Data.Weight)
if appUserInfo.Data.Weight != nil && *appUserInfo.Data.Weight != 0 {
weight := fmt.Sprintf("%d", *appUserInfo.Data.Weight)
if userInfo.Weight != "" {
if weight != userInfo.Weight {
@@ -225,6 +225,19 @@ func (r *UserService) HandleAppUserInfo(tx *gorm.DB, user *model.User, userInfo
}
}
// 身高
if appUserInfo.Data.Height != nil && *appUserInfo.Data.Height != 0 {
height := fmt.Sprintf("%d", *appUserInfo.Data.Height)
if userInfo.Height != "" {
if height != userInfo.Height {
userInfoData["height"] = height
}
} else {
userInfoData["height"] = height
}
}
// 省份 id
if appUserInfo.Data.ProvinceID != nil {
// 获取省份数据
@@ -237,7 +250,7 @@ func (r *UserService) HandleAppUserInfo(tx *gorm.DB, user *model.User, userInfo
if err != nil {
return err
}
userInfoData["province_name"] = baseArea.Name
userInfoData["province"] = baseArea.Name
}
} else {
userInfoData["province_id"] = appUserInfo.Data.ProvinceID
@@ -246,7 +259,7 @@ func (r *UserService) HandleAppUserInfo(tx *gorm.DB, user *model.User, userInfo
if err != nil {
return err
}
userInfoData["province_name"] = baseArea.Name
userInfoData["province"] = baseArea.Name
}
}
@@ -258,20 +271,20 @@ func (r *UserService) HandleAppUserInfo(tx *gorm.DB, user *model.User, userInfo
if *appUserInfo.Data.CityID != *userInfo.CityId {
userInfoData["city_id"] = appUserInfo.Data.CityID
baseArea, err := baseAreaDao.GetBaseAreaById(int64(*appUserInfo.Data.ProvinceID))
baseArea, err := baseAreaDao.GetBaseAreaById(int64(*appUserInfo.Data.CityID))
if err != nil {
return err
}
userInfoData["city_name"] = baseArea.Name
userInfoData["city"] = baseArea.Name
}
} else {
userInfoData["city_id"] = appUserInfo.Data.CityID
baseArea, err := baseAreaDao.GetBaseAreaById(int64(*appUserInfo.Data.ProvinceID))
baseArea, err := baseAreaDao.GetBaseAreaById(int64(*appUserInfo.Data.CityID))
if err != nil {
return err
}
userInfoData["city_name"] = baseArea.Name
userInfoData["city"] = baseArea.Name
}
}
@@ -283,20 +296,20 @@ func (r *UserService) HandleAppUserInfo(tx *gorm.DB, user *model.User, userInfo
if *appUserInfo.Data.CountyID != *userInfo.CountyId {
userInfoData["county_id"] = appUserInfo.Data.CountyID
baseArea, err := baseAreaDao.GetBaseAreaById(int64(*appUserInfo.Data.ProvinceID))
baseArea, err := baseAreaDao.GetBaseAreaById(int64(*appUserInfo.Data.CountyID))
if err != nil {
return err
}
userInfoData["county_name"] = baseArea.Name
userInfoData["county"] = baseArea.Name
}
} else {
userInfoData["county_id"] = appUserInfo.Data.CountyID
baseArea, err := baseAreaDao.GetBaseAreaById(int64(*appUserInfo.Data.ProvinceID))
baseArea, err := baseAreaDao.GetBaseAreaById(int64(*appUserInfo.Data.CountyID))
if err != nil {
return err
}
userInfoData["county_name"] = baseArea.Name
userInfoData["county"] = baseArea.Name
}
}
@@ -382,3 +395,195 @@ func (r *UserService) HandleAppUserInfo(tx *gorm.DB, user *model.User, userInfo
return nil
}
// HandleAppUserCase 处理app用户病例数据
func (r *UserService) HandleAppUserCase(tx *gorm.DB, user *model.User) error {
appUserCase, err := app.GetUserCaseByAppIden(user.AppIden)
if err != nil {
return err
}
// 用户无病例数据
if appUserCase.Data == nil {
return nil
}
// 获取用户病例数据
userCaseDao := dao.UserCaseDao{}
userCase, _ := userCaseDao.GetUserCaseByUserId(user.UserId)
if userCase == nil {
// 未添加用户病例数据
userCase = &model.UserCase{}
userCase.UserId = user.UserId
// 是否过敏史
if appUserCase.Data.IsAllergy != nil {
userCase.IsAllergyHistory = appUserCase.Data.IsAllergy
// 过敏史描述
if appUserCase.Data.AllergyInfo != "" {
userCase.AllergyHistory = appUserCase.Data.AllergyInfo
}
}
// 是否服药
if appUserCase.Data.IsMedication != nil {
userCase.IsMedication = appUserCase.Data.IsMedication
// 服药名称
if appUserCase.Data.MedicationInfo != "" {
userCase.Medication = appUserCase.Data.MedicationInfo
}
}
// 是否去医院
if appUserCase.Data.IsHospital != nil {
userCase.IsHospital = appUserCase.Data.IsHospital
}
// 慢性疾病
if appUserCase.Data.OtherDisease != "" {
userCase.ChronicDisease = appUserCase.Data.OtherDisease
}
// 目前肝脏状态
if appUserCase.Data.LiverStatus != "" {
userCase.LiverStatus = appUserCase.Data.LiverStatus
}
userCase, err = userCaseDao.AddUserCase(tx, userCase)
if err != nil {
return err
}
} else {
// 对比处理用户数据
userCaseData := make(map[string]interface{}) // 用户病例数据
// 是否过敏史
if appUserCase.Data.IsAllergy != nil {
if userCase.IsAllergyHistory != nil {
if *appUserCase.Data.IsAllergy != *userCase.IsAllergyHistory {
userCaseData["is_allergy_history"] = appUserCase.Data.IsAllergy
}
} else {
userCaseData["is_allergy_history"] = appUserCase.Data.IsAllergy
}
// 过敏史描述
if appUserCase.Data.AllergyInfo != "" {
if userCase.AllergyHistory != "" {
if appUserCase.Data.AllergyInfo != userCase.AllergyHistory {
userCaseData["allergy_history"] = appUserCase.Data.AllergyInfo
}
} else {
userCaseData["allergy_history"] = appUserCase.Data.AllergyInfo
}
}
}
// 是否服药
if appUserCase.Data.IsMedication != nil {
if userCase.IsMedication != nil {
if *appUserCase.Data.IsMedication != *userCase.IsMedication {
userCaseData["is_medication"] = appUserCase.Data.IsMedication
}
} else {
userCaseData["is_medication"] = appUserCase.Data.IsMedication
}
// 服药名称
if appUserCase.Data.MedicationInfo != "" {
if userCase.Medication != "" {
if appUserCase.Data.MedicationInfo != userCase.Medication {
userCaseData["medication"] = appUserCase.Data.MedicationInfo
}
} else {
userCaseData["medication"] = appUserCase.Data.MedicationInfo
}
}
}
// 是否去医院
if appUserCase.Data.IsHospital != nil {
if userCase.IsHospital != nil {
if *appUserCase.Data.IsHospital != *userCase.IsHospital {
userCaseData["is_hospital"] = appUserCase.Data.IsHospital
}
} else {
userCaseData["is_hospital"] = appUserCase.Data.IsHospital
}
}
// 慢性疾病
if appUserCase.Data.OtherDisease != "" {
if userCase.ChronicDisease != "" {
if appUserCase.Data.OtherDisease != userCase.ChronicDisease {
userCaseData["chronic_disease"] = appUserCase.Data.OtherDisease
}
} else {
userCaseData["chronic_disease"] = appUserCase.Data.OtherDisease
}
}
// 目前肝脏状态
if appUserCase.Data.LiverStatus != "" {
if userCase.LiverStatus != "" {
if appUserCase.Data.LiverStatus != userCase.LiverStatus {
userCaseData["liver_status"] = appUserCase.Data.LiverStatus
}
} else {
userCaseData["liver_status"] = appUserCase.Data.LiverStatus
}
}
// 修改用户病例数据
if len(userCaseData) > 0 {
err := userCaseDao.EditUserCaseById(tx, userCase.UserCaseId, userCaseData)
if err != nil {
return err
}
}
if len(appUserCase.Data.DiseasesList) > 0 {
userCaseDiseaseItemDao := dao.UserCaseDiseaseItemDao{}
// 删除所患疾病列表
maps := make(map[string]interface{})
maps["user_case_id"] = userCase.UserCaseId
err := userCaseDiseaseItemDao.DeleteUserCaseDiseaseItem(tx, maps)
if err != nil {
return err
}
}
}
// 所患疾病列表
if len(appUserCase.Data.DiseasesList) > 0 {
for _, data := range appUserCase.Data.DiseasesList {
userCaseDiseaseItemDao := dao.UserCaseDiseaseItemDao{}
baseDiseaseClassDao := dao.BaseDiseaseClassDao{}
// 获取基础数据-疾病分类
baseDiseaseClass, err := baseDiseaseClassDao.GetBaseDiseaseClassByAppIden(data.UUID)
if err != nil {
return err
}
// 新增所患疾病列表
userCaseDiseaseItem := &model.UserCaseDiseaseItem{
UserCaseId: userCase.UserCaseId,
DiseaseClassId: baseDiseaseClass.DiseaseClassId,
AppIden: data.UUID,
Duration: data.Year,
Genotype: data.Info,
}
userCaseDiseaseItem, err = userCaseDiseaseItemDao.AddUserCaseDiseaseItem(tx, userCaseDiseaseItem)
if err != nil {
return err
}
}
}
return nil
}