From 99d050cda133852005c409d05a38cc9849b5343f Mon Sep 17 00:00:00 2001 From: wucongxing8150 <815046773@qq.com> Date: Wed, 16 Oct 2024 08:51:14 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E7=A7=91=E6=99=AE=E5=88=86?= =?UTF-8?q?=E7=B1=BB=E7=AE=A1=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- api/controller/BasicArticleClass.go | 232 ++++++++++++++++++++++++ api/controller/area.go | 6 +- api/controller/basic.go | 3 +- api/controller/diseaseClassExpertise.go | 4 +- api/dao/ArticleScience.go | 158 ++++++++++++++++ api/dao/ArticleScienceClass.go | 158 ++++++++++++++++ api/dao/ArticleScienceSource.go | 158 ++++++++++++++++ api/dao/BasicArticleClass.go | 213 ++++++++++++++++++++++ api/dto/ArticleScience.go | 62 +++++++ api/dto/ArticleScienceClass.go | 49 +++++ api/dto/ArticleScienceSource.go | 50 +++++ api/dto/BasicArticleClass.go | 49 +++++ api/model/ArticleScience.go | 37 ++++ api/model/ArticleScienceClass.go | 33 ++++ api/model/ArticleScienceSource.go | 33 ++++ api/model/BasicArticleClass.go | 33 ++++ api/requests/BasicArticleClass.go | 43 +++++ api/router/router.go | 135 ++++++++------ 18 files changed, 1393 insertions(+), 63 deletions(-) create mode 100644 api/controller/BasicArticleClass.go create mode 100644 api/dao/ArticleScience.go create mode 100644 api/dao/ArticleScienceClass.go create mode 100644 api/dao/ArticleScienceSource.go create mode 100644 api/dao/BasicArticleClass.go create mode 100644 api/dto/ArticleScience.go create mode 100644 api/dto/ArticleScienceClass.go create mode 100644 api/dto/ArticleScienceSource.go create mode 100644 api/dto/BasicArticleClass.go create mode 100644 api/model/ArticleScience.go create mode 100644 api/model/ArticleScienceClass.go create mode 100644 api/model/ArticleScienceSource.go create mode 100644 api/model/BasicArticleClass.go create mode 100644 api/requests/BasicArticleClass.go diff --git a/api/controller/BasicArticleClass.go b/api/controller/BasicArticleClass.go new file mode 100644 index 0000000..b236a62 --- /dev/null +++ b/api/controller/BasicArticleClass.go @@ -0,0 +1,232 @@ +package controller + +import ( + "github.com/gin-gonic/gin" + "hospital-admin-api/api/dao" + "hospital-admin-api/api/dto" + "hospital-admin-api/api/model" + "hospital-admin-api/api/requests" + "hospital-admin-api/api/responses" + "hospital-admin-api/global" + "hospital-admin-api/utils" + "strconv" +) + +// BasicArticleClass 科普分类 +type BasicArticleClass struct { +} + +// GetBasicArticleClassPage 获取科普分类列表-分页 +func (b *BasicArticleClass) GetBasicArticleClassPage(c *gin.Context) { + basicArticleClassRequest := requests.BasicArticleClassRequest{} + req := basicArticleClassRequest.GetBasicArticleClassPage + 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 + } + + if req.Page == 0 { + req.Page = 1 + } + + if req.PageSize == 0 { + req.PageSize = 20 + } + + // 获取分类数据 + basicArticleClassDao := dao.BasicArticleClassDao{} + basicArticleClass, total, err := basicArticleClassDao.GetBasicArticleClassPageSearch(req, req.Page, req.PageSize) + if err != nil { + responses.FailWithMessage(err.Error(), c) + return + } + + // 处理返回值 + g := dto.GetBasicArticleClassListDto(basicArticleClass) + + result := make(map[string]interface{}) + result["page"] = req.Page + result["page_size"] = req.PageSize + result["total"] = total + result["data"] = g + responses.OkWithData(result, c) +} + +// GetBasicArticleClassList 获取科普分类列表 +func (b *BasicArticleClass) GetBasicArticleClassList(c *gin.Context) { + basicArticleClassRequest := requests.BasicArticleClassRequest{} + req := basicArticleClassRequest.GetBasicArticleClassList + 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 + } + + // 获取分类数据 + basicArticleClassDao := dao.BasicArticleClassDao{} + basicArticleClass, err := basicArticleClassDao.GetBasicArticleClassListSearch(req) + if err != nil { + responses.FailWithMessage(err.Error(), c) + return + } + + // 处理返回值 + g := dto.GetBasicArticleClassListDto(basicArticleClass) + if err != nil { + responses.FailWithMessage(err.Error(), c) + return + } + + responses.OkWithData(g, c) +} + +// GetBasicArticleClass 获取科普分类详情 +func (b *BasicArticleClass) GetBasicArticleClass(c *gin.Context) { + id := c.Param("basic_class_id") + if id == "" { + responses.FailWithMessage("缺少参数", c) + return + } + + // 将 id 转换为 int64 类型 + basicClassId, err := strconv.ParseInt(id, 10, 64) + if err != nil { + responses.Fail(c) + return + } + + // 获取科普分类数据 + basicArticleClassDao := dao.BasicArticleClassDao{} + basicArticleClass, err := basicArticleClassDao.GetBasicArticleClassById(basicClassId) + if err != nil { + responses.FailWithMessage("分类异常", c) + return + } + + // 处理返回值 + g := dto.GetBasicArticleClassDto(basicArticleClass) + + responses.OkWithData(g, c) +} + +// PutBasicArticleClass 修改科普分类 +func (b *BasicArticleClass) PutBasicArticleClass(c *gin.Context) { + basicArticleClassRequest := requests.BasicArticleClassRequest{} + req := basicArticleClassRequest.PutBasicArticleClass + 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 + } + + id := c.Param("basic_class_id") + if id == "" { + responses.FailWithMessage("缺少参数", c) + return + } + + // 将 id 转换为 int64 类型 + basicClassId, err := strconv.ParseInt(id, 10, 64) + if err != nil { + responses.Fail(c) + return + } + + // 获取科普分类数据 + basicArticleClassDao := dao.BasicArticleClassDao{} + basicArticleClass, err := basicArticleClassDao.GetBasicArticleClassById(basicClassId) + if err != nil { + responses.FailWithMessage("分类异常", c) + return + } + + // 修改值 + basicArticleClassData := make(map[string]interface{}) + + // 分类名称 + if req.BasicClassName != basicArticleClass.BasicClassName { + basicArticleClassData["basic_class_name"] = req.BasicClassName + } + + // 排序值 + if req.BasicClassSort != basicArticleClass.BasicClassSort { + basicArticleClassData["basic_class_sort"] = req.BasicClassSort + } + + if len(basicArticleClassData) > 0 { + // 开始事务 + tx := global.Db.Begin() + defer func() { + if r := recover(); r != nil { + tx.Rollback() + } + }() + + err = basicArticleClassDao.EditBasicArticleClassById(tx, basicClassId, basicArticleClassData) + if err != nil { + tx.Rollback() + responses.FailWithMessage("操作失败", c) + return + } + + tx.Commit() + } + + responses.Ok(c) +} + +// AddBasicArticleClass 新增科普分类 +func (b *BasicArticleClass) AddBasicArticleClass(c *gin.Context) { + basicArticleClassRequest := requests.BasicArticleClassRequest{} + req := basicArticleClassRequest.PutBasicArticleClass + 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 + } + + // 开始事务 + tx := global.Db.Begin() + defer func() { + if r := recover(); r != nil { + tx.Rollback() + } + }() + + basicArticleClass := &model.BasicArticleClass{ + BasicClassName: req.BasicClassName, + BasicClassSort: req.BasicClassSort, + } + + basicArticleClassDao := dao.BasicArticleClassDao{} + basicArticleClass, err := basicArticleClassDao.AddBasicArticleClass(tx, basicArticleClass) + if err != nil { + tx.Rollback() + responses.FailWithMessage(err.Error(), c) + return + } + + tx.Commit() + responses.Ok(c) +} diff --git a/api/controller/area.go b/api/controller/area.go index abf04c6..e3fc958 100644 --- a/api/controller/area.go +++ b/api/controller/area.go @@ -15,7 +15,7 @@ import ( type Area struct{} // GetAreaList 获取地区列表 -func (b *Area) GetAreaList(c *gin.Context) { +func (r *Area) GetAreaList(c *gin.Context) { areaRequest := requests.AreaRequest{} req := areaRequest.GetAreaList if err := c.ShouldBind(&req); err != nil { @@ -43,8 +43,8 @@ func (b *Area) GetAreaList(c *gin.Context) { } // 处理返回值 - r := dto.GetAreaListDto(area) - responses.OkWithData(r, c) + g := dto.GetAreaListDto(area) + responses.OkWithData(g, c) } // AddArea 新增地区 diff --git a/api/controller/basic.go b/api/controller/basic.go index 9683a6b..4e9765e 100644 --- a/api/controller/basic.go +++ b/api/controller/basic.go @@ -1,5 +1,6 @@ package controller type Basic struct { - Area // 省市区 + Area // 省市区 + BasicArticleClass // 科普分类 } diff --git a/api/controller/diseaseClassExpertise.go b/api/controller/diseaseClassExpertise.go index 2143af5..e1cd05f 100644 --- a/api/controller/diseaseClassExpertise.go +++ b/api/controller/diseaseClassExpertise.go @@ -36,6 +36,6 @@ func (b *DiseaseClassExpertise) GetExpertiseList(c *gin.Context) { } // 处理返回值 - getExpertiseListResponse := dto.GetDiseaseClassExpertiseListDto(diseaseClassExpertises) - responses.OkWithData(getExpertiseListResponse, c) + g := dto.GetDiseaseClassExpertiseListDto(diseaseClassExpertises) + responses.OkWithData(g, c) } diff --git a/api/dao/ArticleScience.go b/api/dao/ArticleScience.go new file mode 100644 index 0000000..9853ed8 --- /dev/null +++ b/api/dao/ArticleScience.go @@ -0,0 +1,158 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hospital-admin-api/api/model" + "hospital-admin-api/global" +) + +type ArticleScienceDao struct { +} + +// GetArticleScienceById 获取数据-id +func (r *ArticleScienceDao) GetArticleScienceById(articleId int64) (m *model.ArticleScience, err error) { + err = global.Db.First(&m, articleId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleSciencePreloadById 获取数据-加载全部关联-id +func (r *ArticleScienceDao) GetArticleSciencePreloadById(articleId int64) (m *model.ArticleScience, err error) { + err = global.Db.Preload(clause.Associations).First(&m, articleId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteArticleScience 删除 +func (r *ArticleScienceDao) DeleteArticleScience(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.ArticleScience{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteArticleScienceById 删除-id +func (r *ArticleScienceDao) DeleteArticleScienceById(tx *gorm.DB, articleId int64) error { + if err := tx.Delete(&model.ArticleScience{}, articleId).Error; err != nil { + return err + } + return nil +} + +// EditArticleScience 修改 +func (r *ArticleScienceDao) EditArticleScience(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.ArticleScience{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditArticleScienceById 修改-id +func (r *ArticleScienceDao) EditArticleScienceById(tx *gorm.DB, articleId int64, data interface{}) error { + err := tx.Model(&model.ArticleScience{}).Where("article_id = ?", articleId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetArticleScienceList 获取列表 +func (r *ArticleScienceDao) GetArticleScienceList(maps interface{}) (m []*model.ArticleScience, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleScienceCount 获取数量 +func (r *ArticleScienceDao) GetArticleScienceCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.ArticleScience{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetArticleScienceListRand 获取列表-随机 +func (r *ArticleScienceDao) GetArticleScienceListRand(maps interface{}, limit int) (m []*model.ArticleScience, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddArticleScience 新增 +func (r *ArticleScienceDao) AddArticleScience(tx *gorm.DB, model *model.ArticleScience) (*model.ArticleScience, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetArticleScience 获取 +func (r *ArticleScienceDao) GetArticleScience(maps interface{}) (m *model.ArticleScience, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleScienceOrderLimitList 获取列表-排序、限制数量 +func (r *ArticleScienceDao) GetArticleScienceOrderLimitList(maps interface{}, orderField string, limit int) (m []*model.ArticleScience, err error) { + err = global.Db.Where(maps).Order(orderField).Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// Inc 自增 +func (r *ArticleScienceDao) Inc(tx *gorm.DB, articleId int64, field string, numeral int) error { + err := tx.Model(&model.ArticleScience{}).Where("article_id = ?", articleId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error + if err != nil { + return err + } + return nil +} + +// Dec 自减 +func (r *ArticleScienceDao) Dec(tx *gorm.DB, articleId int64, field string, numeral int) error { + err := tx.Model(&model.ArticleScience{}).Where("article_id = ?", articleId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error + if err != nil { + return err + } + return nil +} + +// GetArticleScienceSum 获取数量 +func (r *ArticleScienceDao) GetArticleScienceSum(maps interface{}, field string) (total float64, err error) { + var result struct { + Sum float64 + } + + err = global.Db.Model(&model.ArticleScience{}).Where(maps).Select("SUM(" + field + ") as sum").Scan(&result).Error + if err != nil { + return 0, err + } + + return result.Sum, nil +} + +// GetArticleScienceListByTime 获取列表-开始时间/过期时间 +func (r *ArticleScienceDao) GetArticleScienceListByTime(maps interface{}, startTime, endTime, field string) (m []*model.ArticleScience, err error) { + err = global.Db.Where(maps).Where(field+" BETWEEN ? AND ?", startTime, endTime).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/ArticleScienceClass.go b/api/dao/ArticleScienceClass.go new file mode 100644 index 0000000..52c2d75 --- /dev/null +++ b/api/dao/ArticleScienceClass.go @@ -0,0 +1,158 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hospital-admin-api/api/model" + "hospital-admin-api/global" +) + +type ArticleScienceClassDao struct { +} + +// GetArticleScienceClassById 获取数据-id +func (r *ArticleScienceClassDao) GetArticleScienceClassById(classId int64) (m *model.ArticleScienceClass, err error) { + err = global.Db.First(&m, classId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleScienceClassPreloadById 获取数据-加载全部关联-id +func (r *ArticleScienceClassDao) GetArticleScienceClassPreloadById(classId int64) (m *model.ArticleScienceClass, err error) { + err = global.Db.Preload(clause.Associations).First(&m, classId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteArticleScienceClass 删除 +func (r *ArticleScienceClassDao) DeleteArticleScienceClass(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.ArticleScienceClass{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteArticleScienceClassById 删除-id +func (r *ArticleScienceClassDao) DeleteArticleScienceClassById(tx *gorm.DB, articleId int64) error { + if err := tx.Delete(&model.ArticleScienceClass{}, articleId).Error; err != nil { + return err + } + return nil +} + +// EditArticleScienceClass 修改 +func (r *ArticleScienceClassDao) EditArticleScienceClass(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.ArticleScienceClass{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditArticleScienceClassById 修改-id +func (r *ArticleScienceClassDao) EditArticleScienceClassById(tx *gorm.DB, classId int64, data interface{}) error { + err := tx.Model(&model.ArticleScienceClass{}).Where("class_id = ?", classId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetArticleScienceClassList 获取列表 +func (r *ArticleScienceClassDao) GetArticleScienceClassList(maps interface{}) (m []*model.ArticleScienceClass, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleScienceClassCount 获取数量 +func (r *ArticleScienceClassDao) GetArticleScienceClassCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.ArticleScienceClass{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetArticleScienceClassListRand 获取列表-随机 +func (r *ArticleScienceClassDao) GetArticleScienceClassListRand(maps interface{}, limit int) (m []*model.ArticleScienceClass, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddArticleScienceClass 新增 +func (r *ArticleScienceClassDao) AddArticleScienceClass(tx *gorm.DB, model *model.ArticleScienceClass) (*model.ArticleScienceClass, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetArticleScienceClass 获取 +func (r *ArticleScienceClassDao) GetArticleScienceClass(maps interface{}) (m *model.ArticleScienceClass, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleScienceClassOrderLimitList 获取列表-排序、限制数量 +func (r *ArticleScienceClassDao) GetArticleScienceClassOrderLimitList(maps interface{}, orderField string, limit int) (m []*model.ArticleScienceClass, err error) { + err = global.Db.Where(maps).Order(orderField).Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// Inc 自增 +func (r *ArticleScienceClassDao) Inc(tx *gorm.DB, classId int64, field string, numeral int) error { + err := tx.Model(&model.ArticleScienceClass{}).Where("class_id = ?", classId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error + if err != nil { + return err + } + return nil +} + +// Dec 自减 +func (r *ArticleScienceClassDao) Dec(tx *gorm.DB, classId int64, field string, numeral int) error { + err := tx.Model(&model.ArticleScienceClass{}).Where("class_id = ?", classId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error + if err != nil { + return err + } + return nil +} + +// GetArticleScienceClassSum 获取数量 +func (r *ArticleScienceClassDao) GetArticleScienceClassSum(maps interface{}, field string) (total float64, err error) { + var result struct { + Sum float64 + } + + err = global.Db.Model(&model.ArticleScienceClass{}).Where(maps).Select("SUM(" + field + ") as sum").Scan(&result).Error + if err != nil { + return 0, err + } + + return result.Sum, nil +} + +// GetArticleScienceClassListByTime 获取列表-开始时间/过期时间 +func (r *ArticleScienceClassDao) GetArticleScienceClassListByTime(maps interface{}, startTime, endTime, field string) (m []*model.ArticleScienceClass, err error) { + err = global.Db.Where(maps).Where(field+" BETWEEN ? AND ?", startTime, endTime).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/ArticleScienceSource.go b/api/dao/ArticleScienceSource.go new file mode 100644 index 0000000..ed5168d --- /dev/null +++ b/api/dao/ArticleScienceSource.go @@ -0,0 +1,158 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hospital-admin-api/api/model" + "hospital-admin-api/global" +) + +type ArticleScienceSourceDao struct { +} + +// GetArticleScienceSourceById 获取数据-id +func (r *ArticleScienceSourceDao) GetArticleScienceSourceById(sourceId int64) (m *model.ArticleScienceSource, err error) { + err = global.Db.First(&m, sourceId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleScienceSourcePreloadById 获取数据-加载全部关联-id +func (r *ArticleScienceSourceDao) GetArticleScienceSourcePreloadById(sourceId int64) (m *model.ArticleScienceSource, err error) { + err = global.Db.Preload(clause.Associations).First(&m, sourceId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteArticleScienceSource 删除 +func (r *ArticleScienceSourceDao) DeleteArticleScienceSource(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.ArticleScienceSource{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteArticleScienceSourceById 删除-id +func (r *ArticleScienceSourceDao) DeleteArticleScienceSourceById(tx *gorm.DB, sourceId int64) error { + if err := tx.Delete(&model.ArticleScienceSource{}, sourceId).Error; err != nil { + return err + } + return nil +} + +// EditArticleScienceSource 修改 +func (r *ArticleScienceSourceDao) EditArticleScienceSource(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.ArticleScienceSource{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditArticleScienceSourceById 修改-id +func (r *ArticleScienceSourceDao) EditArticleScienceSourceById(tx *gorm.DB, sourceId int64, data interface{}) error { + err := tx.Model(&model.ArticleScienceSource{}).Where("source_id = ?", sourceId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetArticleScienceSourceList 获取列表 +func (r *ArticleScienceSourceDao) GetArticleScienceSourceList(maps interface{}) (m []*model.ArticleScienceSource, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleScienceSourceCount 获取数量 +func (r *ArticleScienceSourceDao) GetArticleScienceSourceCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.ArticleScienceSource{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetArticleScienceSourceListRand 获取列表-随机 +func (r *ArticleScienceSourceDao) GetArticleScienceSourceListRand(maps interface{}, limit int) (m []*model.ArticleScienceSource, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddArticleScienceSource 新增 +func (r *ArticleScienceSourceDao) AddArticleScienceSource(tx *gorm.DB, model *model.ArticleScienceSource) (*model.ArticleScienceSource, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetArticleScienceSource 获取 +func (r *ArticleScienceSourceDao) GetArticleScienceSource(maps interface{}) (m *model.ArticleScienceSource, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetArticleScienceSourceOrderLimitList 获取列表-排序、限制数量 +func (r *ArticleScienceSourceDao) GetArticleScienceSourceOrderLimitList(maps interface{}, orderField string, limit int) (m []*model.ArticleScienceSource, err error) { + err = global.Db.Where(maps).Order(orderField).Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// Inc 自增 +func (r *ArticleScienceSourceDao) Inc(tx *gorm.DB, sourceId int64, field string, numeral int) error { + err := tx.Model(&model.ArticleScienceSource{}).Where("source_id = ?", sourceId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error + if err != nil { + return err + } + return nil +} + +// Dec 自减 +func (r *ArticleScienceSourceDao) Dec(tx *gorm.DB, sourceId int64, field string, numeral int) error { + err := tx.Model(&model.ArticleScienceSource{}).Where("source_id = ?", sourceId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error + if err != nil { + return err + } + return nil +} + +// GetArticleScienceSourceSum 获取数量 +func (r *ArticleScienceSourceDao) GetArticleScienceSourceSum(maps interface{}, field string) (total float64, err error) { + var result struct { + Sum float64 + } + + err = global.Db.Model(&model.ArticleScienceSource{}).Where(maps).Select("SUM(" + field + ") as sum").Scan(&result).Error + if err != nil { + return 0, err + } + + return result.Sum, nil +} + +// GetArticleScienceSourceListByTime 获取列表-开始时间/过期时间 +func (r *ArticleScienceSourceDao) GetArticleScienceSourceListByTime(maps interface{}, startTime, endTime, field string) (m []*model.ArticleScienceSource, err error) { + err = global.Db.Where(maps).Where(field+" BETWEEN ? AND ?", startTime, endTime).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dao/BasicArticleClass.go b/api/dao/BasicArticleClass.go new file mode 100644 index 0000000..b6cba1e --- /dev/null +++ b/api/dao/BasicArticleClass.go @@ -0,0 +1,213 @@ +package dao + +import ( + "gorm.io/gorm" + "gorm.io/gorm/clause" + "hospital-admin-api/api/model" + "hospital-admin-api/api/requests" + "hospital-admin-api/global" +) + +type BasicArticleClassDao struct { +} + +// GetBasicArticleClassById 获取数据-id +func (r *BasicArticleClassDao) GetBasicArticleClassById(BasicClassId int64) (m *model.BasicArticleClass, err error) { + err = global.Db.First(&m, BasicClassId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetBasicArticleClassPreloadById 获取数据-加载全部关联-id +func (r *BasicArticleClassDao) GetBasicArticleClassPreloadById(BasicClassId int64) (m *model.BasicArticleClass, err error) { + err = global.Db.Preload(clause.Associations).First(&m, BasicClassId).Error + if err != nil { + return nil, err + } + return m, nil +} + +// DeleteBasicArticleClass 删除 +func (r *BasicArticleClassDao) DeleteBasicArticleClass(tx *gorm.DB, maps interface{}) error { + err := tx.Where(maps).Delete(&model.BasicArticleClass{}).Error + if err != nil { + return err + } + return nil +} + +// DeleteBasicArticleClassById 删除-id +func (r *BasicArticleClassDao) DeleteBasicArticleClassById(tx *gorm.DB, BasicArticleClassId int64) error { + if err := tx.Delete(&model.BasicArticleClass{}, BasicArticleClassId).Error; err != nil { + return err + } + return nil +} + +// EditBasicArticleClass 修改 +func (r *BasicArticleClassDao) EditBasicArticleClass(tx *gorm.DB, maps interface{}, data interface{}) error { + err := tx.Model(&model.BasicArticleClass{}).Where(maps).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// EditBasicArticleClassById 修改-id +func (r *BasicArticleClassDao) EditBasicArticleClassById(tx *gorm.DB, BasicClassId int64, data interface{}) error { + err := tx.Model(&model.BasicArticleClass{}).Where("basic_class_id = ?", BasicClassId).Updates(data).Error + if err != nil { + return err + } + return nil +} + +// GetBasicArticleClassList 获取列表 +func (r *BasicArticleClassDao) GetBasicArticleClassList(maps interface{}) (m []*model.BasicArticleClass, err error) { + err = global.Db.Where(maps).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetBasicArticleClassCount 获取数量 +func (r *BasicArticleClassDao) GetBasicArticleClassCount(maps interface{}) (total int64, err error) { + err = global.Db.Model(&model.BasicArticleClass{}).Where(maps).Count(&total).Error + if err != nil { + return 0, err + } + return total, nil +} + +// GetBasicArticleClassListRand 获取列表-随机 +func (r *BasicArticleClassDao) GetBasicArticleClassListRand(maps interface{}, limit int) (m []*model.BasicArticleClass, err error) { + err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// AddBasicArticleClass 新增 +func (r *BasicArticleClassDao) AddBasicArticleClass(tx *gorm.DB, model *model.BasicArticleClass) (*model.BasicArticleClass, error) { + if err := tx.Create(model).Error; err != nil { + return nil, err + } + return model, nil +} + +// GetBasicArticleClass 获取 +func (r *BasicArticleClassDao) GetBasicArticleClass(maps interface{}) (m *model.BasicArticleClass, err error) { + err = global.Db.Where(maps).First(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetBasicArticleClassOrderLimitList 获取列表-排序、限制数量 +func (r *BasicArticleClassDao) GetBasicArticleClassOrderLimitList(maps interface{}, orderField string, limit int) (m []*model.BasicArticleClass, err error) { + err = global.Db.Where(maps).Order(orderField).Limit(limit).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// Inc 自增 +func (r *BasicArticleClassDao) Inc(tx *gorm.DB, BasicArticleClassId int64, field string, numeral int) error { + err := tx.Model(&model.BasicArticleClass{}).Where("basic_class_id = ?", BasicArticleClassId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error + if err != nil { + return err + } + return nil +} + +// Dec 自减 +func (r *BasicArticleClassDao) Dec(tx *gorm.DB, BasicArticleClassId int64, field string, numeral int) error { + err := tx.Model(&model.BasicArticleClass{}).Where("basic_class_id = ?", BasicArticleClassId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error + if err != nil { + return err + } + return nil +} + +// GetBasicArticleClassSum 获取数量 +func (r *BasicArticleClassDao) GetBasicArticleClassSum(maps interface{}, field string) (total float64, err error) { + var result struct { + Sum float64 + } + + err = global.Db.Model(&model.BasicArticleClass{}).Where(maps).Select("SUM(" + field + ") as sum").Scan(&result).Error + if err != nil { + return 0, err + } + + return result.Sum, nil +} + +// GetBasicArticleClassListByTime 获取列表-开始时间/过期时间 +func (r *BasicArticleClassDao) GetBasicArticleClassListByTime(maps interface{}, startTime, endTime, field string) (m []*model.BasicArticleClass, err error) { + err = global.Db.Where(maps).Where(field+" BETWEEN ? AND ?", startTime, endTime).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} + +// GetBasicArticleClassPageSearch 获取列表-分页 +func (r *BasicArticleClassDao) GetBasicArticleClassPageSearch(req requests.GetBasicArticleClassPage, page, pageSize int) (m []*model.BasicArticleClass, total int64, err error) { + var totalRecords int64 + + // 构建查询条件 + query := global.Db.Model(&model.BasicArticleClass{}) + + // 分类名称 + if req.BasicClassName != "" { + query = query.Where("basic_class_name LIKE ?", "%"+req.BasicClassName+"%") + } + + // 排序 + if req.Order != nil { + if req.Order.BasicClassSort != "" { + query = query.Order("basic_class_sort " + req.Order.BasicClassSort) + } + } + + // 排序 + query = query.Order("created_at desc") + + // 查询总数量 + if err := query.Count(&totalRecords).Error; err != nil { + return nil, 0, err + } + + err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error + if err != nil { + return nil, 0, err + } + return m, totalRecords, nil +} + +// GetBasicArticleClassListSearch 获取列表 +func (r *BasicArticleClassDao) GetBasicArticleClassListSearch(req requests.GetBasicArticleClassList) (m []*model.BasicArticleClass, err error) { + // 构建查询条件 + query := global.Db.Model(&model.BasicArticleClass{}) + + /// 分类名称 + if req.BasicClassName != "" { + query = query.Where("basic_class_name LIKE ?", "%"+req.BasicClassName+"%") + } + + // 排序 + query = query.Order("created_at desc") + + err = query.Scopes(model.Paginate(1, 10)).Find(&m).Error + if err != nil { + return nil, err + } + return m, nil +} diff --git a/api/dto/ArticleScience.go b/api/dto/ArticleScience.go new file mode 100644 index 0000000..7c8bf73 --- /dev/null +++ b/api/dto/ArticleScience.go @@ -0,0 +1,62 @@ +package dto + +import ( + "fmt" + "hospital-admin-api/api/model" + "hospital-admin-api/utils" +) + +// ArticleScienceDto 文章-科普 +type ArticleScienceDto struct { + ArticleId string `json:"article_id"` // 主键id + ArticleTitle string `json:"article_title"` // 文章标题 + ArticleStatus int `json:"article_status"` // 文章状态（1:正常 2:禁用） + IsTop int `json:"is_top"` // 是否置顶（0:否 1:是） + ArticleImage string `json:"article_image"` // 文章图片（1张） + SourceId string `json:"source_id"` // 文章来源id + ArticleUrl string `json:"article_url"` // 文章地址 + CreatedAt model.LocalTime `json:"created_at"` // 创建时间 + UpdatedAt model.LocalTime `json:"updated_at"` // 更新时间 +} + +// GetArticleScienceDto 详情 +func GetArticleScienceDto(m *model.ArticleScience) *ArticleScienceDto { + return &ArticleScienceDto{ + ArticleId: fmt.Sprintf("%d", m.ArticleId), + ArticleTitle: m.ArticleTitle, + ArticleStatus: m.ArticleStatus, + IsTop: m.IsTop, + ArticleImage: utils.AddOssDomain(m.ArticleImage), + SourceId: fmt.Sprintf("%d", m.SourceId), + ArticleUrl: m.ArticleUrl, + CreatedAt: m.CreatedAt, + UpdatedAt: m.UpdatedAt, + } +} + +// GetArticleScienceListDto 列表 +func GetArticleScienceListDto(m []*model.ArticleScience) []*ArticleScienceDto { + // 处理返回值 + responses := make([]*ArticleScienceDto, len(m)) + + if len(m) > 0 { + for i, v := range m { + response := &ArticleScienceDto{ + ArticleId: fmt.Sprintf("%d", v.ArticleId), + ArticleTitle: v.ArticleTitle, + ArticleStatus: v.ArticleStatus, + IsTop: v.IsTop, + ArticleImage: utils.AddOssDomain(v.ArticleImage), + SourceId: fmt.Sprintf("%d", v.SourceId), + ArticleUrl: v.ArticleUrl, + CreatedAt: v.CreatedAt, + UpdatedAt: v.UpdatedAt, + } + + // 将转换后的结构体添加到新切片中 + responses[i] = response + } + } + + return responses +} diff --git a/api/dto/ArticleScienceClass.go b/api/dto/ArticleScienceClass.go new file mode 100644 index 0000000..0244dcd --- /dev/null +++ b/api/dto/ArticleScienceClass.go @@ -0,0 +1,49 @@ +package dto + +import ( + "fmt" + "hospital-admin-api/api/model" +) + +// ArticleScienceClassDto 文章-科普-分类 +type ArticleScienceClassDto struct { + ClassId string `json:"class_id"` // 主键id + ArticleId string `json:"article_id"` // 文章-科普id + BasicClassId string `json:"basic_class_id"` // 基础数据-科普-分类id + CreatedAt model.LocalTime `json:"created_at"` // 创建时间 + UpdatedAt model.LocalTime `json:"updated_at"` // 更新时间 +} + +// GetArticleScienceClassDto 详情 +func GetArticleScienceClassDto(m *model.ArticleScienceClass) *ArticleScienceClassDto { + return &ArticleScienceClassDto{ + ClassId: fmt.Sprintf("%d", m.BasicClassId), + ArticleId: fmt.Sprintf("%d", m.BasicClassId), + BasicClassId: fmt.Sprintf("%d", m.BasicClassId), + CreatedAt: m.CreatedAt, + UpdatedAt: m.UpdatedAt, + } +} + +// GetArticleScienceClassListDto 列表 +func GetArticleScienceClassListDto(m []*model.ArticleScienceClass) []*ArticleScienceClassDto { + // 处理返回值 + responses := make([]*ArticleScienceClassDto, len(m)) + + if len(m) > 0 { + for i, v := range m { + response := &ArticleScienceClassDto{ + ClassId: fmt.Sprintf("%d", v.BasicClassId), + ArticleId: fmt.Sprintf("%d", v.BasicClassId), + BasicClassId: fmt.Sprintf("%d", v.BasicClassId), + CreatedAt: v.CreatedAt, + UpdatedAt: v.UpdatedAt, + } + + // 将转换后的结构体添加到新切片中 + responses[i] = response + } + } + + return responses +} diff --git a/api/dto/ArticleScienceSource.go b/api/dto/ArticleScienceSource.go new file mode 100644 index 0000000..1fdaf29 --- /dev/null +++ b/api/dto/ArticleScienceSource.go @@ -0,0 +1,50 @@ +package dto + +import ( + "fmt" + "hospital-admin-api/api/model" + "hospital-admin-api/utils" +) + +// ArticleScienceSourceDto 文章-科普-来源 +type ArticleScienceSourceDto struct { + SourceId string `json:"source_id"` // 主键id + SourceName string `json:"source_name"` // 来源名称 + SourceImage string `json:"source_image"` // 来源图片 + CreatedAt model.LocalTime `json:"created_at"` // 创建时间 + UpdatedAt model.LocalTime `json:"updated_at"` // 更新时间 +} + +// GetArticleScienceSourceDto 详情 +func GetArticleScienceSourceDto(m *model.ArticleScienceSource) *ArticleScienceSourceDto { + return &ArticleScienceSourceDto{ + SourceId: fmt.Sprintf("%d", m.SourceId), + SourceName: m.SourceName, + SourceImage: utils.AddOssDomain(m.SourceImage), + CreatedAt: m.CreatedAt, + UpdatedAt: m.UpdatedAt, + } +} + +// GetArticleScienceSourceListDto 列表 +func GetArticleScienceSourceListDto(m []*model.ArticleScienceSource) []*ArticleScienceSourceDto { + // 处理返回值 + responses := make([]*ArticleScienceSourceDto, len(m)) + + if len(m) > 0 { + for i, v := range m { + response := &ArticleScienceSourceDto{ + SourceId: fmt.Sprintf("%d", v.SourceId), + SourceName: v.SourceName, + SourceImage: utils.AddOssDomain(v.SourceImage), + CreatedAt: v.CreatedAt, + UpdatedAt: v.UpdatedAt, + } + + // 将转换后的结构体添加到新切片中 + responses[i] = response + } + } + + return responses +} diff --git a/api/dto/BasicArticleClass.go b/api/dto/BasicArticleClass.go new file mode 100644 index 0000000..b327382 --- /dev/null +++ b/api/dto/BasicArticleClass.go @@ -0,0 +1,49 @@ +package dto + +import ( + "fmt" + "hospital-admin-api/api/model" +) + +// BasicArticleClassDto 基础数据-科普-分类 +type BasicArticleClassDto struct { + BasicClassId string `json:"basic_class_id"` // 主键id + BasicClassName string `json:"basic_class_name"` // 分类名称 + BasicClassSort uint `json:"basic_class_sort"` // 排序（越大排序越靠前） + CreatedAt model.LocalTime `json:"created_at"` // 创建时间 + UpdatedAt model.LocalTime `json:"updated_at"` // 更新时间 +} + +// GetBasicArticleClassDto 详情 +func GetBasicArticleClassDto(m *model.BasicArticleClass) *BasicArticleClassDto { + return &BasicArticleClassDto{ + BasicClassId: fmt.Sprintf("%d", m.BasicClassId), + BasicClassName: m.BasicClassName, + BasicClassSort: m.BasicClassSort, + CreatedAt: m.CreatedAt, + UpdatedAt: m.UpdatedAt, + } +} + +// GetBasicArticleClassListDto 列表 +func GetBasicArticleClassListDto(m []*model.BasicArticleClass) []*BasicArticleClassDto { + // 处理返回值 + responses := make([]*BasicArticleClassDto, len(m)) + + if len(m) > 0 { + for i, v := range m { + response := &BasicArticleClassDto{ + BasicClassId: fmt.Sprintf("%d", v.BasicClassId), + BasicClassName: v.BasicClassName, + BasicClassSort: v.BasicClassSort, + CreatedAt: v.CreatedAt, + UpdatedAt: v.UpdatedAt, + } + + // 将转换后的结构体添加到新切片中 + responses[i] = response + } + } + + return responses +} diff --git a/api/model/ArticleScience.go b/api/model/ArticleScience.go new file mode 100644 index 0000000..e2d1346 --- /dev/null +++ b/api/model/ArticleScience.go @@ -0,0 +1,37 @@ +package model + +import ( + "gorm.io/gorm" + "hospital-admin-api/global" + "time" +) + +// ArticleScience 文章-科普 +type ArticleScience struct { + ArticleId int64 `gorm:"column:article_id;type:bigint(19);primary_key;comment:主键id" json:"article_id"` + ArticleTitle string `gorm:"column:article_title;type:varchar(255);comment:文章标题" json:"article_title"` + ArticleStatus int `gorm:"column:article_status;type:tinyint(1);default:1;comment:文章状态（1:正常 2:禁用）" json:"article_status"` + IsTop int `gorm:"column:is_top;type:tinyint(1);default:0;comment:是否置顶（0:否 1:是）" json:"is_top"` + ArticleImage string `gorm:"column:article_image;type:varchar(255);comment:文章图片（1张）" json:"article_image"` + SourceId int64 `gorm:"column:source_id;type:bigint(19);comment:文章来源id;NOT NULL" json:"source_id"` + ArticleUrl string `gorm:"column:article_url;type:varchar(255);comment:文章地址;NOT NULL" json:"article_url"` + Model +} + +func (m *ArticleScience) TableName() string { + return "gdxz_article_science" +} + +func (m *ArticleScience) BeforeCreate(tx *gorm.DB) error { + if m.ArticleId == 0 { + m.ArticleId = 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 +} diff --git a/api/model/ArticleScienceClass.go b/api/model/ArticleScienceClass.go new file mode 100644 index 0000000..7a0e2e1 --- /dev/null +++ b/api/model/ArticleScienceClass.go @@ -0,0 +1,33 @@ +package model + +import ( + "gorm.io/gorm" + "hospital-admin-api/global" + "time" +) + +// ArticleScienceClass 文章-科普-分类 +type ArticleScienceClass struct { + ClassId int64 `gorm:"column:class_id;type:bigint(19);primary_key;comment:主键id" json:"class_id"` + ArticleId int64 `gorm:"column:article_id;type:bigint(19);comment:文章-科普id;NOT NULL" json:"article_id"` + BasicClassId int64 `gorm:"column:basic_class_id;type:bigint(19);comment:基础数据-科普-分类id;NOT NULL" json:"basic_class_id"` + Model +} + +func (m *ArticleScienceClass) TableName() string { + return "gdxz_article_science_class" +} + +func (m *ArticleScienceClass) BeforeCreate(tx *gorm.DB) error { + if m.ClassId == 0 { + m.ClassId = 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 +} diff --git a/api/model/ArticleScienceSource.go b/api/model/ArticleScienceSource.go new file mode 100644 index 0000000..4442866 --- /dev/null +++ b/api/model/ArticleScienceSource.go @@ -0,0 +1,33 @@ +package model + +import ( + "gorm.io/gorm" + "hospital-admin-api/global" + "time" +) + +// ArticleScienceSource 文章-科普-来源 +type ArticleScienceSource struct { + SourceId int64 `gorm:"column:source_id;type:bigint(19);primary_key;comment:主键id" json:"source_id"` + SourceName string `gorm:"column:source_name;type:varchar(200);comment:来源名称" json:"source_name"` + SourceImage string `gorm:"column:source_image;type:varchar(200);comment:来源图片" json:"source_image"` + Model +} + +func (m *ArticleScienceSource) TableName() string { + return "gdxz_article_science_source" +} + +func (m *ArticleScienceSource) BeforeCreate(tx *gorm.DB) error { + if m.SourceId == 0 { + m.SourceId = 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 +} diff --git a/api/model/BasicArticleClass.go b/api/model/BasicArticleClass.go new file mode 100644 index 0000000..187d93d --- /dev/null +++ b/api/model/BasicArticleClass.go @@ -0,0 +1,33 @@ +package model + +import ( + "gorm.io/gorm" + "hospital-admin-api/global" + "time" +) + +// BasicArticleClass 基础数据-科普-分类 +type BasicArticleClass struct { + BasicClassId int64 `gorm:"column:basic_class_id;type:bigint(19);primary_key;comment:主键id" json:"basic_class_id"` + BasicClassName string `gorm:"column:basic_class_name;type:varchar(255);comment:分类名称" json:"basic_class_name"` + BasicClassSort uint `gorm:"column:basic_class_sort;type:int(5);default:1;comment:排序（越大排序越靠前）" json:"basic_class_sort"` + Model +} + +func (m *BasicArticleClass) TableName() string { + return "gdxz_basic_article_class" +} + +func (m *BasicArticleClass) BeforeCreate(tx *gorm.DB) error { + if m.BasicClassId == 0 { + m.BasicClassId = 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 +} diff --git a/api/requests/BasicArticleClass.go b/api/requests/BasicArticleClass.go new file mode 100644 index 0000000..92258e1 --- /dev/null +++ b/api/requests/BasicArticleClass.go @@ -0,0 +1,43 @@ +package requests + +type BasicArticleClassRequest struct { + GetBasicArticleClassPage // 获取科普分类列表-分页 + GetBasicArticleClassList // 获取科普分类列表 + PutBasicArticleClass // 修改科普分类 + AddBasicArticleClass // 新增科普分类 +} + +// GetBasicArticleClassPage 获取科普分类列表-分页 +type GetBasicArticleClassPage struct { + Page int `json:"page" form:"page" label:"页码"` + PageSize int `json:"page_size" form:"page_size" label:"每页个数"` + BasicClassName string `json:"basic_class_name" form:"basic_class_name" label:"分类名称"` + Order *GetBasicArticleClassPageOrder `json:"order" form:"order" label:"排序"` +} + +// GetBasicArticleClassPageOrder 获取科普分类列表-分页-排序条件 +type GetBasicArticleClassPageOrder struct { + BasicClassSort string `json:"basic_class_sort" form:"basic_class_sort" label:"排序"` // 排序（越大排序越靠前） +} + +// GetBasicArticleClassList 获取科普分类列表 +type GetBasicArticleClassList struct { + BasicClassName string `json:"basic_class_name" form:"basic_class_name" label:"分类名称"` +} + +// GetBasicArticleClassListOrder 获取科普分类列表-排序条件 +type GetBasicArticleClassListOrder struct { + BasicClassSort string `json:"basic_class_sort" form:"basic_class_sort" label:"排序"` // 排序（越大排序越靠前） +} + +// PutBasicArticleClass 修改科普分类 +type PutBasicArticleClass struct { + BasicClassName string `json:"basic_class_name" form:"basic_class_name" label:"分类名称" validate:"required"` + BasicClassSort uint `json:"basic_class_sort" form:"basic_class_sort" label:"排序值" validate:"required,number,min=1"` +} + +// AddBasicArticleClass 新增科普分类 +type AddBasicArticleClass struct { + BasicClassName string `json:"basic_class_name" form:"basic_class_name" label:"分类名称" validate:"required"` + BasicClassSort uint `json:"basic_class_sort" form:"basic_class_sort" label:"排序值" validate:"required,number,min=1"` +} diff --git a/api/router/router.go b/api/router/router.go index 4438bcd..0a67a9f 100644 --- a/api/router/router.go +++ b/api/router/router.go @@ -127,66 +127,68 @@ func adminRouter(r *gin.Engine, api controller.Api) { // basicRouter 基础数据-验证权限 func basicRouter(r *gin.Engine, api controller.Api) { + // 此处为基础数据的获取数据 basicGroup := r.Group("/basic") - - // 科室管理-基础数据 - departmentGroup := basicGroup.Group("/department") { - // 自定义科室 - customGroup := departmentGroup.Group("/custom") + // 科室管理-基础数据 + departmentGroup := basicGroup.Group("/department") { - // 获取自定义科室列表 - customGroup.GET("/list", api.Department.GetDepartmentCustomList) + // 自定义科室 + customGroup := departmentGroup.Group("/custom") + { + // 获取自定义科室列表 + customGroup.GET("/list", api.Department.GetDepartmentCustomList) + } } + + // 医院管理-基础数据 + hospitalGroup := basicGroup.Group("/hospital") + { + // 获取医院列表-限制条数 + hospitalGroup.GET("/list", api.Hospital.GetHospitalList) + } + + // 医生专长管理-基础数据 + expertiseGroup := basicGroup.Group("/expertise") + { + // 获取医生专长列表 + expertiseGroup.GET("/list", api.DiseaseClassExpertise.GetExpertiseList) + + // 获取医生专长列表-分页 + + // 医生专长详情 + + // 修改医生专长 + + // 新增医生专长 + } + + // 银行管理-基础数据 + bankGroup := basicGroup.Group("/bank") + { + // 获取银行列表 + bankGroup.GET("/list", api.Bank.GetBankList) + + // 获取银行列表-分页 + + // 银行详情 + + // 修改银行 + + // 新增银行 + } + + //// 地区管理-基础数据 + //areaGroup := basicGroup.Group("/area") + //{ + // // 获取地区列表 + // areaGroup.GET("/list", api.Basic.Area.GetAreaList) + // + // // 修改地区 + // + // // 新增地区 + //} } - - // 医院管理-基础数据 - hospitalGroup := basicGroup.Group("/hospital") - { - // 获取医院列表-限制条数 - hospitalGroup.GET("/list", api.Hospital.GetHospitalList) - } - - // 专长管理-基础数据 - expertiseGroup := basicGroup.Group("/expertise") - { - // 获取专长列表 - expertiseGroup.GET("/list", api.DiseaseClassExpertise.GetExpertiseList) - - // 获取专长列表-分页 - - // 专长详情 - - // 修改专长 - - // 新增专长 - } - - // 银行管理-基础数据 - bankGroup := basicGroup.Group("/bank") - { - // 获取银行列表 - bankGroup.GET("/list", api.Bank.GetBankList) - - // 获取银行列表-分页 - - // 银行详情 - - // 修改银行 - - // 新增银行 - } - - //// 地区管理-基础数据 - //areaGroup := basicGroup.Group("/area") - //{ - // // 获取地区列表 - // areaGroup.GET("/list", api.Basic.Area.GetAreaList) - // - // // 修改地区 - // - // // 新增地区 - //} } // privateRouter 私有路由-验证权限 @@ -820,14 +822,14 @@ func privateRouter(r *gin.Engine, api controller.Api) { } } - // 基础数据 + // 基础数据管理 basicGroup := adminGroup.Group("/basic") { // 地区管理 areaGroup := basicGroup.Group("/area") { // 获取地区列表 - areaGroup.GET("", api.Area.GetAreaList) + areaGroup.GET("", api.Basic.Area.GetAreaList) // 新增地区 areaGroup.POST("", api.Basic.Area.AddArea) @@ -854,5 +856,24 @@ func privateRouter(r *gin.Engine, api controller.Api) { // 修改医院 hospitalGroup.PUT("/:hospital_id", api.Hospital.PutHospital) } + + // 科普分类管理 + articleClassGroup := basicGroup.Group("/article/class") + { + // 获取基础分类列表-分页 + articleClassGroup.POST("/page", api.Basic.BasicArticleClass.GetBasicArticleClassPage) + + // 获取基础分类列表 + articleClassGroup.POST("/list", api.Basic.BasicArticleClass.GetBasicArticleClassList) + + // 获取基础分类详情 + articleClassGroup.GET("/:basic_class_id", api.Basic.BasicArticleClass.GetBasicArticleClass) + + // 修改基础分类 + articleClassGroup.PUT("/:basic_class_id", api.Basic.BasicArticleClass.PutBasicArticleClass) + + // 新增基础分类 + articleClassGroup.POST("", api.Basic.BasicArticleClass.AddBasicArticleClass) + } } }