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:
wucongxing8150 2024-08-20 16:47:09 +08:00
parent 6dd6172be9
commit 2ad676f9b1
14 changed files with 498 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/controller/Base.go
View File

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

84
api/controller/BaseClass.go
View File

@ -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)
}

164
api/controller/Basic.go Normal file
View File

@ -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)
}

26
api/dao/BaseArea.go
View File

@ -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
}

99
api/dao/BaseChronicDisease.go Normal file
View File

@ -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
}

9
api/dao/BaseDiseaseClass.go
View File

@ -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
}

50
api/dto/BaseArea.go Normal file
View File

@ -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
}

32
api/dto/BaseChronicDisease.go Normal file
View File

@ -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
}

40
api/dto/BaseDiseaseClass.go Normal file
View File

@ -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
}

18
api/model/BaseArea.go
View File

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

32
api/model/BaseChronicDisease.go Normal file
View File

@ -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
}

10
api/requests/BaseClass.go → api/requests/Basic.go
View File

@ -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:"上级编号"`
}

2
api/requests/Public.go
View File

@ -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:头像）
}

33
api/router/router.go
View File

@ -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")
{