新增科普分类管理

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

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 新增地区

api/controller/basic.go

@@ -2,4 +2,5 @@ package controller
 
 type Basic struct {
 	Area              // 省市区
+	BasicArticleClass // 科普分类
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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"`
+}

api/router/router.go

@@ -127,8 +127,9 @@ 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")
 		{
@@ -147,19 +148,19 @@ func basicRouter(r *gin.Engine, api controller.Api) {
 			hospitalGroup.GET("/list", api.Hospital.GetHospitalList)
 		}
 
-	// 专长管理-基础数据
+		// 医生专长管理-基础数据
 		expertiseGroup := basicGroup.Group("/expertise")
 		{
-		// 获取专长列表
+			// 获取医生专长列表
 			expertiseGroup.GET("/list", api.DiseaseClassExpertise.GetExpertiseList)
 
-		// 获取专长列表-分页
+			// 获取医生专长列表-分页
 
-		// 专长详情
+			// 医生专长详情
 
-		// 修改专长
+			// 修改医生专长
 
-		// 新增专长
+			// 新增医生专长
 		}
 
 		// 银行管理-基础数据
@@ -187,6 +188,7 @@ func basicRouter(r *gin.Engine, api controller.Api) {
 		//
 		//	// 新增地区
 		//}
+	}
 }
 
 // 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)
+		}
 	}
 }