新增了基础数据

api/controller/Base.go

@@ -4,7 +4,7 @@ package controller
 type Api struct {
 	Login          // 登录
 	Public         // 公共方法
-	BaseClass      // 分类
+	Basic          // 基础数据
 	Question       // 问题
 	User           // 用户
 	UserCase       // 用户病例

api/controller/BaseClass.go

@@ -1,84 +0,0 @@
-package controller
-
-import (
-	"github.com/gin-gonic/gin"
-	"hepa-calc-api/api/dao"
-	"hepa-calc-api/api/dto"
-	"hepa-calc-api/api/requests"
-	"hepa-calc-api/api/responses"
-	"hepa-calc-api/global"
-	"hepa-calc-api/utils"
-	"strconv"
-)
-
-type BaseClass struct{}
-
-// GetBaseClassList 获取分类列表
-func (b *BaseClass) GetBaseClassList(c *gin.Context) {
-	baseClassRequest := requests.BaseClassRequest{}
-	req := baseClassRequest.GetBaseClassList
-	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
-	}
-
-	// 获取分类数据
-	baseClassDao := dao.BaseClassDao{}
-
-	maps := make(map[string]interface{})
-	maps["class_status"] = 1
-	baseClass, err := baseClassDao.GetBaseClassListSearch(req)
-	if err != nil {
-		responses.FailWithMessage(err.Error(), c)
-		return
-	}
-
-	// 处理返回值
-	g := dto.GetBaseClassListDto(baseClass)
-	if err != nil {
-		responses.FailWithMessage(err.Error(), c)
-		return
-	}
-
-	responses.OkWithData(g, c)
-}
-
-// GetBaseClass 获取分类详情
-func (r *BaseClass) GetBaseClass(c *gin.Context) {
-	id := c.Param("class_id")
-	if id == "" {
-		responses.FailWithMessage("缺少参数", c)
-		return
-	}
-
-	// 将 id 转换为 int64 类型
-	classId, err := strconv.ParseInt(id, 10, 64)
-	if err != nil {
-		responses.Fail(c)
-		return
-	}
-
-	// 获取数据
-	baseClassDao := dao.BaseClassDao{}
-	baseClass, err := baseClassDao.GetBaseClassById(classId)
-	if err != nil {
-		responses.FailWithMessage("分类不存在", c)
-		return
-	}
-
-	if baseClass.ClassStatus != 1 {
-		responses.FailWithMessage("分类不存在", c)
-		return
-	}
-
-	// 处理返回值
-	g := dto.GetBaseClassDto(baseClass)
-
-	responses.OkWithData(g, c)
-}

api/controller/Basic.go

@@ -0,0 +1,164 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-api/api/dao"
+	"hepa-calc-api/api/dto"
+	"hepa-calc-api/api/requests"
+	"hepa-calc-api/api/responses"
+	"hepa-calc-api/global"
+	"hepa-calc-api/utils"
+	"strconv"
+)
+
+type Basic struct{}
+
+// GetBaseClassList 获取分类列表
+func (r *Basic) GetBaseClassList(c *gin.Context) {
+	basicRequest := requests.BasicRequest{}
+	req := basicRequest.GetBaseClassList
+	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
+	}
+
+	// 获取分类数据
+	baseClassDao := dao.BaseClassDao{}
+
+	maps := make(map[string]interface{})
+	maps["class_status"] = 1
+	baseClass, err := baseClassDao.GetBaseClassListSearch(req)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetBaseClassListDto(baseClass)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.OkWithData(g, c)
+}
+
+// GetBaseClass 获取分类详情
+func (r *Basic) GetBaseClass(c *gin.Context) {
+	id := c.Param("class_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	classId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取数据
+	baseClassDao := dao.BaseClassDao{}
+	baseClass, err := baseClassDao.GetBaseClassById(classId)
+	if err != nil {
+		responses.FailWithMessage("分类不存在", c)
+		return
+	}
+
+	if baseClass.ClassStatus != 1 {
+		responses.FailWithMessage("分类不存在", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetBaseClassDto(baseClass)
+
+	responses.OkWithData(g, c)
+}
+
+// GetAreaList 获取分类列表
+func (r *Basic) GetAreaList(c *gin.Context) {
+	basicRequest := requests.BasicRequest{}
+	req := basicRequest.GetAreaList
+	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.ParentId == "" && req.AreaId == "" && req.AreaName == "" {
+		req.ParentId = ""
+	}
+
+	// 获取分类数据
+	baseAreaDao := dao.BaseAreaDao{}
+	baseAreas, err := baseAreaDao.GetAreaList(req)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetBaseAreaListDto(baseAreas)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.OkWithData(g, c)
+}
+
+// GetChronicDiseaseList 获取慢性疾病列表
+func (r *Basic) GetChronicDiseaseList(c *gin.Context) {
+	// 获取分类数据
+	baseChronicDiseaseDao := dao.BaseChronicDiseaseDao{}
+	maps := make(map[string]interface{})
+	baseChronicDiseases, err := baseChronicDiseaseDao.GetBaseChronicDiseaseList(maps)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetChronicDiseaseListDto(baseChronicDiseases)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.OkWithData(g, c)
+}
+
+// GetDiseaseList 获取疾病分类列表
+func (r *Basic) GetDiseaseList(c *gin.Context) {
+	// 获取分类数据
+	baseDiseaseClassDao := dao.BaseDiseaseClassDao{}
+	maps := make(map[string]interface{})
+	baseDiseaseClass, err := baseDiseaseClassDao.GetBaseDiseaseClassOrderList(maps, "sort desc", 20)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetDiseaseListDto(baseDiseaseClass)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.OkWithData(g, c)
+}

api/dao/BaseArea.go

@@ -4,6 +4,7 @@ import (
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	"hepa-calc-api/api/model"
+	"hepa-calc-api/api/requests"
 	"hepa-calc-api/global"
 )
 
@@ -106,3 +107,28 @@ func (r *BaseAreaDao) GetBaseArea(maps interface{}) (m *model.BaseArea, err erro
 	}
 	return m, nil
 }
+
+// GetAreaList 获取地区列表
+func (r *BaseAreaDao) GetAreaList(request requests.GetAreaList) (m []*model.BaseArea, err error) {
+	result := global.Db
+
+	if request.AreaId != "" {
+		result = result.Where("id = ?", request.AreaId)
+	}
+
+	if request.AreaName != "" {
+		result = result.Where("name like ?", "%"+request.AreaName+"%")
+	}
+
+	if request.ParentId != "" {
+		result = result.Where("parent = ?", request.ParentId)
+	} else {
+		result = result.Where("parent is NULL")
+	}
+
+	err = result.Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/BaseChronicDisease.go

@@ -0,0 +1,99 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-api/api/model"
+	"hepa-calc-api/global"
+)
+
+type BaseChronicDiseaseDao struct {
+}
+
+// GetBaseChronicDiseaseById 获取数据-id
+func (r *BaseChronicDiseaseDao) GetBaseChronicDiseaseById(id int64) (m *model.BaseChronicDisease, err error) {
+	err = global.Db.First(&m, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseChronicDiseasePreloadById 获取数据-加载全部关联-id
+func (r *BaseChronicDiseaseDao) GetBaseChronicDiseasePreloadById(id int64) (m *model.BaseChronicDisease, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteBaseChronicDisease 删除
+func (r *BaseChronicDiseaseDao) DeleteBaseChronicDisease(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.BaseChronicDisease{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteBaseChronicDiseaseById 删除-id
+func (r *BaseChronicDiseaseDao) DeleteBaseChronicDiseaseById(tx *gorm.DB, id int64) error {
+	if err := tx.Delete(&model.BaseChronicDisease{}, id).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetBaseChronicDiseaseList 获取列表
+func (r *BaseChronicDiseaseDao) GetBaseChronicDiseaseList(maps interface{}) (m []*model.BaseChronicDisease, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseChronicDiseaseOrderList 获取列表-排序
+func (r *BaseChronicDiseaseDao) GetBaseChronicDiseaseOrderList(maps interface{}) (m []*model.BaseChronicDisease, err error) {
+	err = global.Db.Where(maps).Order("sort desc").Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseChronicDiseaseCount 获取数量
+func (r *BaseChronicDiseaseDao) GetBaseChronicDiseaseCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.BaseChronicDisease{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetBaseChronicDiseaseListRand 获取列表-随机
+func (r *BaseChronicDiseaseDao) GetBaseChronicDiseaseListRand(maps interface{}, limit int) (m []*model.BaseChronicDisease, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddBaseChronicDisease 新增
+func (r *BaseChronicDiseaseDao) AddBaseChronicDisease(tx *gorm.DB, model *model.BaseChronicDisease) (*model.BaseChronicDisease, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetBaseChronicDisease 获取
+func (r *BaseChronicDiseaseDao) GetBaseChronicDisease(maps interface{}) (m *model.BaseChronicDisease, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/BaseDiseaseClass.go

@@ -115,3 +115,12 @@ func (r *BaseDiseaseClassDao) GetBaseDiseaseClass(maps interface{}) (m *model.Ba
 	}
 	return m, nil
 }
+
+// GetBaseDiseaseClassOrderList 获取列表-排序
+func (r *BaseDiseaseClassDao) GetBaseDiseaseClassOrderList(maps interface{}, orderField string, limit int) (m []*model.BaseDiseaseClass, err error) {
+	err = global.Db.Where(maps).Preload(clause.Associations).Order(orderField).Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dto/BaseArea.go

@@ -0,0 +1,50 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-api/api/model"
+)
+
+// BaseAreaDto 行政区域基础信息
+type BaseAreaDto struct {
+	Id         string           `json:"id"`          // 主键id
+	CreateDate *model.LocalTime `json:"create_date"` // 创建日期
+	ModifyDate *model.LocalTime `json:"modify_date"` // 修改日期
+	Orders     int              `json:"orders"`      // 排序
+	FullName   string           `json:"full_name"`   // 全名
+	Name       string           `json:"name"`        // 名称
+	TreePath   string           `json:"tree_path"`   // 树路径
+	Parent     string           `json:"parent"`      // 父节点id
+	CanClinic  int              `json:"can_clinic"`  // 是否可以开诊所
+	CreatedAt  model.LocalTime  `json:"created_at"`  // 创建时间
+	UpdatedAt  model.LocalTime  `json:"updated_at"`  // 更新时间
+}
+
+// GetBaseAreaListDto 列表-基础数据-分类表
+func GetBaseAreaListDto(m []*model.BaseArea) []*BaseAreaDto {
+	// 处理返回值
+	responses := make([]*BaseAreaDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &BaseAreaDto{
+				Id:         fmt.Sprintf("%d", v.Id),
+				CreateDate: v.CreateDate,
+				ModifyDate: v.ModifyDate,
+				Orders:     v.Orders,
+				FullName:   v.FullName,
+				Name:       v.Name,
+				TreePath:   v.TreePath,
+				Parent:     fmt.Sprintf("%d", v.Parent),
+				CanClinic:  v.CanClinic,
+				CreatedAt:  v.CreatedAt,
+				UpdatedAt:  v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/BaseChronicDisease.go

@@ -0,0 +1,32 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-api/api/model"
+)
+
+// BaseChronicDiseaseDto 基础数据-慢性疾病
+type BaseChronicDiseaseDto struct {
+	ChronicDiseaseId   string `json:"chronic_disease_id"`   // id
+	ChronicDiseaseName string `json:"chronic_disease_name"` // 名称
+}
+
+// GetChronicDiseaseListDto 列表-基础数据-慢性疾病
+func GetChronicDiseaseListDto(m []*model.BaseChronicDisease) []*BaseChronicDiseaseDto {
+	// 处理返回值
+	responses := make([]*BaseChronicDiseaseDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &BaseChronicDiseaseDto{
+				ChronicDiseaseId:   fmt.Sprintf("%d", v.ChronicDiseaseId),
+				ChronicDiseaseName: v.ChronicDiseaseName,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/BaseDiseaseClass.go

@@ -0,0 +1,40 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-api/api/model"
+)
+
+// BaseDiseaseClassDto 基础数据-疾病分类
+type BaseDiseaseClassDto struct {
+	DiseaseClassId   string          `json:"disease_class_id"`   // 主键id
+	AppIden          string          `json:"app_iden"`           // app唯一标识
+	DiseaseClassName string          `json:"disease_class_name"` // 疾病分类名称
+	Sort             int             `json:"sort"`               // 排序值
+	CreatedAt        model.LocalTime `json:"created_at"`         // 创建时间
+	UpdatedAt        model.LocalTime `json:"updated_at"`         // 更新时间
+}
+
+// GetDiseaseListDto 列表-基础数据-疾病分类
+func GetDiseaseListDto(m []*model.BaseDiseaseClass) []*BaseDiseaseClassDto {
+	// 处理返回值
+	responses := make([]*BaseDiseaseClassDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &BaseDiseaseClassDto{
+				DiseaseClassId:   fmt.Sprintf("%d", v.DiseaseClassId),
+				AppIden:          v.AppIden,
+				DiseaseClassName: v.DiseaseClassName,
+				Sort:             v.Sort,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/model/BaseArea.go

@@ -7,15 +7,15 @@ import (
 )
 
 type BaseArea struct {
-	Id         int64     `gorm:"column:id;type:bigint(20);primary_key;AUTO_INCREMENT" json:"id"`
+	Id         int64      `gorm:"column:id;type:bigint(20);primary_key;AUTO_INCREMENT" json:"id"`
-	CreateDate time.Time `gorm:"column:create_date;type:datetime;NOT NULL" json:"create_date"`
+	CreateDate *LocalTime `gorm:"column:create_date;type:datetime;NOT NULL" json:"create_date"`
-	ModifyDate time.Time `gorm:"column:modify_date;type:datetime;NOT NULL" json:"modify_date"`
+	ModifyDate *LocalTime `gorm:"column:modify_date;type:datetime;NOT NULL" json:"modify_date"`
-	Orders     int       `gorm:"column:orders;type:int(11)" json:"orders"`
+	Orders     int        `gorm:"column:orders;type:int(11)" json:"orders"`
-	FullName   string    `gorm:"column:full_name;type:longtext;NOT NULL" json:"full_name"`
+	FullName   string     `gorm:"column:full_name;type:longtext;NOT NULL" json:"full_name"`
-	Name       string    `gorm:"column:name;type:varchar(100);NOT NULL" json:"name"`
+	Name       string     `gorm:"column:name;type:varchar(100);NOT NULL" json:"name"`
-	TreePath   string    `gorm:"column:tree_path;type:varchar(255);NOT NULL" json:"tree_path"`
+	TreePath   string     `gorm:"column:tree_path;type:varchar(255);NOT NULL" json:"tree_path"`
-	Parent     int64     `gorm:"column:parent;type:bigint(20)" json:"parent"`
+	Parent     int64      `gorm:"column:parent;type:bigint(20)" json:"parent"`
-	CanClinic  int       `gorm:"column:can_clinic;type:int(11);default:1" json:"can_clinic"`
+	CanClinic  int        `gorm:"column:can_clinic;type:int(11);default:1" json:"can_clinic"`
 	Model
 }
 

api/model/BaseChronicDisease.go

@@ -0,0 +1,32 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-api/global"
+	"time"
+)
+
+// BaseChronicDisease 基础-慢性疾病分类
+type BaseChronicDisease struct {
+	ChronicDiseaseId   int64  `gorm:"column:chronic_disease_id;type:bigint(19);primary_key;comment:主键id" json:"chronic_disease_id"`
+	ChronicDiseaseName string `gorm:"column:chronic_disease_name;type:varchar(255);comment:疾病分类名称" json:"chronic_disease_name"`
+	Model
+}
+
+func (m *BaseChronicDisease) TableName() string {
+	return "base_chronic_disease"
+}
+
+func (m *BaseChronicDisease) BeforeCreate(tx *gorm.DB) error {
+	if m.ChronicDiseaseId == 0 {
+		m.ChronicDiseaseId = 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/requests/Basic.go

@@ -1,7 +1,8 @@
 package requests
 
-type BaseClassRequest struct {
+type BasicRequest struct {
 	GetBaseClassList // 获取分类列表
+	GetAreaList      // 获取地区列表
 }
 
 // GetBaseClassList 获取分类列表
@@ -10,3 +11,10 @@ type GetBaseClassList struct {
 	ClassBrief        string `json:"class_brief" form:"class_brief" label:"分类简介"`
 	IsRecommendSearch *int   `json:"is_recommend_search" form:"is_recommend_search" label:"是否推荐搜索"`
 }
+
+// GetAreaList 获取地区列表
+type GetAreaList struct {
+	AreaId   string `json:"id" form:"id" label:"地区编号"`
+	AreaName string `json:"name" form:"name" label:"名称"`
+	ParentId string `json:"parent" form:"parent" label:"上级编号"`
+}

api/requests/Public.go

@@ -13,5 +13,5 @@ type GetPhoneCode struct {
 
 // GetOssSign 获取oss签名
 type GetOssSign struct {
-	Scene int `json:"scene" form:"scene" validate:"required,oneof=1 2 3 4" label:"场景"` // （1:头像 2:证书 3:名片）
+	Scene int `json:"scene" form:"scene" validate:"required,oneof=1 2 3 4" label:"场景"` // （1:头像）
 }

api/router/router.go

@@ -137,21 +137,40 @@ func adminRouter(r *gin.Engine, api controller.Api) {
 
 // basicRouter 基础数据-验证权限
 func basicRouter(r *gin.Engine, api controller.Api) {
-
-}
-
-// privateRouter 私有路由-验证权限
-func privateRouter(r *gin.Engine, api controller.Api) {
 	// 分类
 	classGroup := r.Group("/class")
 	{
 		// 获取分类列表
-		classGroup.GET("/list", api.BaseClass.GetBaseClassList)
+		classGroup.GET("/list", api.Basic.GetBaseClassList)
 
 		// 获取分类详情
-		classGroup.GET("/:class_id", api.BaseClass.GetBaseClass)
+		classGroup.GET("/:class_id", api.Basic.GetBaseClass)
 	}
 
+	// 地区
+	areaGroup := r.Group("/area")
+	{
+		// 获取地区列表
+		areaGroup.GET("/list", api.Basic.GetAreaList)
+	}
+
+	// 慢性疾病
+	chronicGroup := r.Group("/chronic")
+	{
+		// 获取慢性疾病列表
+		chronicGroup.GET("/list", api.Basic.GetChronicDiseaseList)
+	}
+
+	// 疾病分类
+	diseaseGroup := r.Group("/disease")
+	{
+		// 获取疾病分类列表
+		diseaseGroup.GET("/list", api.Basic.GetDiseaseList)
+	}
+}
+
+// privateRouter 私有路由-验证权限
+func privateRouter(r *gin.Engine, api controller.Api) {
 	// 问题
 	questionGroup := r.Group("/question")
 	{