Merge branch 'dev'

api/controller/ArticleScience.go

@@ -0,0 +1,463 @@
+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"
+)
+
+type ArticleScience struct{}
+
+// GetArticleSciencePage 获取科普文章列表-分页
+func (b *ArticleScience) GetArticleSciencePage(c *gin.Context) {
+	ArticleScienceRequest := requests.ArticleScienceRequest{}
+	req := ArticleScienceRequest.GetArticleSciencePage
+	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
+	}
+
+	// 获取分类数据
+	articleScienceDao := dao.ArticleScienceDao{}
+	articleScience, total, err := articleScienceDao.GetArticleSciencePageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetArticleScienceListDto(articleScience)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// GetArticleScience 获取科普文章详情
+func (b *ArticleScience) GetArticleScience(c *gin.Context) {
+	id := c.Param("article_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	articleId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取科普文章数据
+	articleScienceDao := dao.ArticleScienceDao{}
+	articleScience, err := articleScienceDao.GetArticleScienceById(articleId)
+	if err != nil {
+		responses.FailWithMessage("异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetArticleScienceDto(articleScience)
+
+	// 加载文章来源
+	articleScienceSourceDao := dao.ArticleScienceSourceDao{}
+	articleScienceSource, err := articleScienceSourceDao.GetArticleScienceSourceById(articleScience.SourceId)
+	if err != nil {
+		responses.FailWithMessage("异常", c)
+		return
+	}
+	g.LoadArticleScienceSource(articleScienceSource)
+
+	// 加载文章分类
+	articleScienceClassDao := dao.ArticleScienceClassDao{}
+	maps := make(map[string]interface{})
+	maps["article_id"] = articleScience.ArticleId
+	articleScienceClass, err := articleScienceClassDao.GetArticleScienceClassList(maps)
+	if len(articleScienceClass) > 0 {
+		basicArticleClassDao := dao.BasicArticleClassDao{}
+		for _, class := range articleScienceClass {
+			basicArticleClass, err := basicArticleClassDao.GetBasicArticleClassById(class.BasicClassId)
+			if err != nil {
+				responses.FailWithMessage("异常", c)
+				return
+			}
+
+			// 加载文章分类
+			g.LoadArticleScienceClass(basicArticleClass)
+		}
+
+	}
+
+	responses.OkWithData(g, c)
+}
+
+// AddArticleScience 新增科普文章
+func (b *ArticleScience) AddArticleScience(c *gin.Context) {
+	articleScienceRequest := requests.ArticleScienceRequest{}
+	req := articleScienceRequest.AddArticleScience
+	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
+	}
+
+	// 参数验证
+	for _, item := range req.ArticleScienceClass {
+		if err := global.Validate.Struct(item); err != nil {
+			responses.FailWithMessage(utils.Translate(err), c)
+			return
+		}
+	}
+
+	// 检测来源是否正确
+	sourceId, err := strconv.ParseInt(req.SourceId, 10, 64)
+	if err != nil {
+		responses.FailWithMessage("来源错误", c)
+		return
+	}
+
+	articleScienceSourceDao := dao.ArticleScienceSourceDao{}
+	articleScienceSource, err := articleScienceSourceDao.GetArticleScienceSourceById(sourceId)
+	if err != nil {
+		responses.FailWithMessage("来源错误", c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	articleScience := &model.ArticleScience{
+		ArticleTitle:  req.ArticleTitle,
+		ArticleStatus: req.ArticleStatus,
+		IsTop:         req.IsTop,
+		Sort:          req.Sort,
+		ArticleImage:  utils.RemoveOssDomain(req.ArticleImage),
+		SourceId:      articleScienceSource.SourceId,
+		ArticleUrl:    req.ArticleUrl,
+	}
+
+	articleScienceDao := dao.ArticleScienceDao{}
+	articleScience, err = articleScienceDao.AddArticleScience(tx, articleScience)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 新增文章分类
+	articleScienceClassDao := dao.ArticleScienceClassDao{}
+	for _, i2 := range req.ArticleScienceClass {
+		basicClassId, err := strconv.ParseInt(i2.BasicClassId, 10, 64)
+		if err != nil {
+			responses.FailWithMessage("分类错误", c)
+			return
+		}
+
+		articleScienceClass := &model.ArticleScienceClass{
+			ArticleId:    articleScience.ArticleId,
+			BasicClassId: basicClassId,
+		}
+		articleScienceClass, err = articleScienceClassDao.AddArticleScienceClass(tx, articleScienceClass)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage(err.Error(), c)
+			return
+		}
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// PutArticleScience 修改科普文章
+func (b *ArticleScience) PutArticleScience(c *gin.Context) {
+	articleScienceRequest := requests.ArticleScienceRequest{}
+	req := articleScienceRequest.PutArticleScience
+	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
+	}
+
+	id := c.Param("article_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	articleId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取科普分类数据
+	articleScienceDao := dao.ArticleScienceDao{}
+	articleScience, err := articleScienceDao.GetArticleScienceById(articleId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 修改值
+	articleScienceData := make(map[string]interface{})
+
+	// 文章标题
+	if req.ArticleTitle != articleScience.ArticleTitle {
+		articleScienceData["article_title"] = req.ArticleTitle
+	}
+
+	// 文章状态
+	if req.ArticleStatus != articleScience.ArticleStatus {
+		articleScienceData["article_status"] = req.ArticleStatus
+	}
+
+	// 是否置顶
+	if req.IsTop != articleScience.IsTop {
+		articleScienceData["is_top"] = req.IsTop
+	}
+
+	// 排序值
+	if req.Sort != articleScience.Sort {
+		articleScienceData["sort"] = req.Sort
+	}
+
+	// 文章图片
+	articleImage := utils.RemoveOssDomain(req.ArticleImage)
+	if articleImage != articleScience.ArticleImage {
+		articleScienceData["article_image"] = articleImage
+	}
+
+	// 文章来源
+	sourceId, err := strconv.ParseInt(req.SourceId, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	if sourceId != articleScience.SourceId {
+		articleScienceData["source_id"] = req.SourceId
+	}
+
+	// 文章地址
+	if req.ArticleUrl != articleScience.ArticleUrl {
+		articleScienceData["article_url"] = req.ArticleUrl
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	if len(articleScienceData) > 0 {
+		err = articleScienceDao.EditArticleScienceById(tx, articleId, articleScienceData)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("操作失败", c)
+			return
+		}
+	}
+
+	// 删除文章分类
+	articleScienceClassDao := dao.ArticleScienceClassDao{}
+	maps := make(map[string]interface{})
+	maps["article_id"] = articleScience.ArticleId
+	err = articleScienceClassDao.DeleteArticleScienceClass(tx, maps)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	// 新增文章分类
+	for _, i2 := range req.ArticleScienceClass {
+		basicClassId, err := strconv.ParseInt(i2.BasicClassId, 10, 64)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("分类错误", c)
+			return
+		}
+
+		articleScienceClass := &model.ArticleScienceClass{
+			ArticleId:    articleScience.ArticleId,
+			BasicClassId: basicClassId,
+		}
+		articleScienceClass, err = articleScienceClassDao.AddArticleScienceClass(tx, articleScienceClass)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage(err.Error(), c)
+			return
+		}
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// PutArticleScienceStatus 操作科普文章状态
+func (b *ArticleScience) PutArticleScienceStatus(c *gin.Context) {
+	articleScienceRequest := requests.ArticleScienceRequest{}
+	req := articleScienceRequest.PutArticleScienceStatus
+	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("article_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	articleId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取科普分类数据
+	articleScienceDao := dao.ArticleScienceDao{}
+	articleScience, err := articleScienceDao.GetArticleScienceById(articleId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 检测状态
+	if articleScience.ArticleStatus == req.ArticleStatus {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	articleScienceData := make(map[string]interface{})
+	articleScienceData["article_status"] = req.ArticleStatus
+	err = articleScienceDao.EditArticleScienceById(tx, articleId, articleScienceData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// PutArticleScienceTop 操作科普文章置顶状态
+func (b *ArticleScience) PutArticleScienceTop(c *gin.Context) {
+	articleScienceRequest := requests.ArticleScienceRequest{}
+	req := articleScienceRequest.PutArticleScienceTop
+	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("article_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	articleId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取科普分类数据
+	articleScienceDao := dao.ArticleScienceDao{}
+	articleScience, err := articleScienceDao.GetArticleScienceById(articleId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 检测置顶状态
+	if articleScience.IsTop == req.IsTop {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	articleScienceData := make(map[string]interface{})
+	articleScienceData["is_top"] = req.IsTop
+	err = articleScienceDao.EditArticleScienceById(tx, articleId, articleScienceData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/controller/ArticleScienceSource.go

@@ -0,0 +1,228 @@
+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"
+)
+
+type ArticleScienceSource struct{}
+
+// GetArticleScienceSourcePage 获取科普文章来源列表-分页
+func (b *ArticleScienceSource) GetArticleScienceSourcePage(c *gin.Context) {
+	ArticleScienceSourceRequest := requests.ArticleScienceSourceRequest{}
+	req := ArticleScienceSourceRequest.GetArticleScienceSourcePage
+	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
+	}
+
+	// 获取分类数据
+	articleScienceSourceDao := dao.ArticleScienceSourceDao{}
+	articleScienceSource, total, err := articleScienceSourceDao.GetArticleScienceSourcePageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetArticleScienceSourceListDto(articleScienceSource)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// GetArticleScienceSourceList 获取科普文章来源列表
+func (b *ArticleScienceSource) GetArticleScienceSourceList(c *gin.Context) {
+	ArticleScienceSourceRequest := requests.ArticleScienceSourceRequest{}
+	req := ArticleScienceSourceRequest.GetArticleScienceSourceList
+	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
+	}
+
+	// 获取分类数据
+	articleScienceSourceDao := dao.ArticleScienceSourceDao{}
+	articleScienceSource, err := articleScienceSourceDao.GetArticleScienceSourceListSearch(req)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetArticleScienceSourceListDto(articleScienceSource)
+
+	responses.OkWithData(g, c)
+}
+
+// GetArticleScienceSource 获取科普文章来源详情
+func (b *ArticleScienceSource) GetArticleScienceSource(c *gin.Context) {
+	id := c.Param("source_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	sourceId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取科普文章来源数据
+	articleScienceSourceDao := dao.ArticleScienceSourceDao{}
+	articleScienceSource, err := articleScienceSourceDao.GetArticleScienceSourceById(sourceId)
+	if err != nil {
+		responses.FailWithMessage("异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetArticleScienceSourceDto(articleScienceSource)
+
+	responses.OkWithData(g, c)
+}
+
+// AddArticleScienceSource 新增科普文章来源
+func (b *ArticleScienceSource) AddArticleScienceSource(c *gin.Context) {
+	ArticleScienceSourceRequest := requests.ArticleScienceSourceRequest{}
+	req := ArticleScienceSourceRequest.AddArticleScienceSource
+	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()
+		}
+	}()
+
+	articleScienceSource := &model.ArticleScienceSource{
+		SourceName:  req.SourceName,
+		SourceImage: utils.RemoveOssDomain(req.SourceImage),
+	}
+
+	ArticleScienceSourceDao := dao.ArticleScienceSourceDao{}
+	articleScienceSource, err := ArticleScienceSourceDao.AddArticleScienceSource(tx, articleScienceSource)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// PutArticleScienceSource 修改科普文章来源
+func (b *ArticleScienceSource) PutArticleScienceSource(c *gin.Context) {
+	ArticleScienceSourceRequest := requests.ArticleScienceSourceRequest{}
+	req := ArticleScienceSourceRequest.PutArticleScienceSource
+	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("source_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	sourceId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取科普分类数据
+	articleScienceSourceDao := dao.ArticleScienceSourceDao{}
+	articleScienceSource, err := articleScienceSourceDao.GetArticleScienceSourceById(sourceId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 修改值
+	articleScienceSourceData := make(map[string]interface{})
+
+	// 来源名称
+	if req.SourceName != articleScienceSource.SourceName {
+		articleScienceSourceData["source_name"] = req.SourceName
+	}
+
+	// 来源图片
+	sourceImage := utils.RemoveOssDomain(req.SourceImage)
+	if sourceImage != articleScienceSource.SourceImage {
+		articleScienceSourceData["source_image"] = sourceImage
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	if len(articleScienceSourceData) > 0 {
+		err = articleScienceSourceDao.EditArticleScienceSourceById(tx, sourceId, articleScienceSourceData)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("操作失败", c)
+			return
+		}
+
+		tx.Commit()
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

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.AddBasicArticleClass
+	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)
+	g := dto.GetAreaListDto(area)
-	responses.OkWithData(r, c)
+	responses.OkWithData(g, c)
 }
 
 // AddArea 新增地区

api/controller/base.go

@@ -18,6 +18,7 @@ type Api struct {
 	productManage           // 商品管理
 	couponManage            // 优惠卷管理
 	basicManage             // 基础数据管理
+	articleManage           // 文章管理
 }
 
 // SysSetting 系统设置
@@ -105,3 +106,9 @@ type couponManage struct {
 type basicManage struct {
 	Basic
 }
+
+// 文章管理
+type articleManage struct {
+	ArticleScience
+	ArticleScienceSource
+}

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)
+	g := dto.GetDiseaseClassExpertiseListDto(diseaseClassExpertises)
-	responses.OkWithData(getExpertiseListResponse, c)
+	responses.OkWithData(g, c)
 }

api/dao/ArticleScience.go

@@ -0,0 +1,218 @@
+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 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
+}
+
+// GetArticleSciencePageSearch 获取列表-分页
+func (r *ArticleScienceDao) GetArticleSciencePageSearch(req requests.GetArticleSciencePage, page, pageSize int) (m []*model.ArticleScience, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.ArticleScience{})
+
+	// 来源
+	query = query.Preload("ArticleScienceSource")
+
+	// 分类
+	query = query.Preload("ArticleScienceClass.ArticleScience")
+
+	// 文章标题
+	if req.ArticleTitle != "" {
+		query = query.Where("article_title LIKE ?", "%"+req.ArticleTitle+"%")
+	}
+
+	// 文章状态
+	if req.ArticleStatus != nil {
+		query = query.Where("article_status = ?", req.ArticleStatus)
+	}
+
+	// 是否置顶
+	if req.IsTop != nil {
+		query = query.Where("is_top = ?", req.IsTop)
+	}
+
+	// 文章来源
+	if req.SourceId != "" {
+		query = query.Where("source_id = ?", req.SourceId)
+	}
+
+	// 排序
+	if req.Order != nil {
+		if req.Order.UpdatedAt != "" {
+			query = query.Order("updated_at " + req.Order.UpdatedAt)
+		}
+
+		if req.Order.Sort != "" {
+			query = query.Order("sort " + req.Order.Sort)
+		}
+	}
+
+	// 排序
+	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
+}

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, classId int64) error {
+	if err := tx.Delete(&model.ArticleScienceClass{}, classId).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,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 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
+}
+
+// GetArticleScienceSourcePageSearch 获取列表-分页
+func (r *ArticleScienceSourceDao) GetArticleScienceSourcePageSearch(req requests.GetArticleScienceSourcePage, page, pageSize int) (m []*model.ArticleScienceSource, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.ArticleScienceSource{})
+
+	// 来源名称
+	if req.SourceName != "" {
+		query = query.Where("source_name LIKE ?", "%"+req.SourceName+"%")
+	}
+
+	// 排序
+	if req.Order != nil {
+		if req.Order.UpdatedAt != "" {
+			query = query.Order("updated_at " + req.Order.UpdatedAt)
+		}
+	}
+
+	// 排序
+	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
+}
+
+// GetArticleScienceSourceListSearch 获取列表
+func (r *ArticleScienceSourceDao) GetArticleScienceSourceListSearch(req requests.GetArticleScienceSourceList) (m []*model.ArticleScienceSource, err error) {
+	// 构建查询条件
+	query := global.Db.Model(&model.ArticleScienceSource{})
+
+	// 来源名称
+	if req.SourceName != "" {
+		query = query.Where("source_name LIKE ?", "%"+req.SourceName+"%")
+	}
+
+	// 排序
+	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/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/dao/doctorBankCard.go

@@ -130,11 +130,11 @@ func (r *DoctorBankCardDao) GetDoctorBankCardPage(req requests.GetUserDoctorBank
 
 	// 用户名称
 	if req.UserName != "" {
-		subQuery := global.Db.Model(&model.User{}).
+		doctorSubQuery := global.Db.Model(&model.UserDoctor{}).
 			Select("doctor_id").
 			Where("user_name LIKE ?", "%"+req.UserName+"%")
 
-		query = query.Where(gorm.Expr("doctor_id IN (?)", subQuery))
+		query = query.Where(gorm.Expr("doctor_id IN (?)", doctorSubQuery))
 	}
 
 	// 银行卡号
@@ -204,11 +204,11 @@ func (r *DoctorBankCardDao) GetDoctorBankCardExportListSearch(req requests.UserD
 
 		// 用户名称
 		if req.UserName != "" {
-			subQuery := global.Db.Model(&model.User{}).
+			doctorSubQuery := global.Db.Model(&model.UserDoctor{}).
 				Select("doctor_id").
 				Where("user_name LIKE ?", "%"+req.UserName+"%")
 
-			query = query.Where(gorm.Expr("doctor_id IN (?)", subQuery))
+			query = query.Where(gorm.Expr("doctor_id IN (?)", doctorSubQuery))
 		}
 
 		// 银行卡号

api/dao/orderProduct.go

@@ -68,6 +68,22 @@ func (r *OrderProductDao) GetOrderProductList(maps interface{}) (m []*model.Orde
 	return m, nil
 }
 
+// GetOrderProductNormalList 获取药品订单列表-正常订单
+func (r *OrderProductDao) GetOrderProductNormalList(maps interface{}, createdAt model.LocalTime) (m []*model.OrderProduct, err error) {
+	query := global.Db.Where(maps)
+
+	// 格式化时间为 "Y-m-d H:i:s"
+	at := time.Time(createdAt).Format("2006-01-02 15:04:05")
+	query = query.Where("created_at < ?", at) // 有效使用时间
+
+	query = query.Where("order_product_status in (?)", []string{"1", "2", "3", "4"})
+	err = query.Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // GetOrderProduct 获取药品订单
 func (r *OrderProductDao) GetOrderProduct(maps interface{}) (m *model.OrderProduct, err error) {
 	err = global.Db.Where(maps).First(&m).Error
@@ -334,6 +350,10 @@ func (r *OrderProductDao) GetOrderProductExportListSearch(req requests.OrderProd
 		return db.Omit("open_id", "union_id", "wx_session_key")
 	})
 
+	query = query.Preload("UserDoctor.User", func(db *gorm.DB) *gorm.DB {
+		return db.Select("user_id", "user_name", "mobile")
+	})
+
 	// 处方
 	query = query.Preload("OrderPrescription", func(db *gorm.DB) *gorm.DB {
 		return db.Select("order_prescription_id", "prescription_code")
@@ -349,6 +369,12 @@ func (r *OrderProductDao) GetOrderProductExportListSearch(req requests.OrderProd
 		return db.Select("user_id", "user_name", "mobile")
 	})
 
+	// 药品列表
+	query = query.Preload("OrderProductItem")
+
+	// 药品列表-药品
+	query = query.Preload("OrderProductItem.Product")
+
 	// 当前搜索数据
 	if req.Type == 1 {
 		// 医生姓名
@@ -534,7 +560,7 @@ func (r *OrderProductDao) GetOrderProductExportListSearch(req requests.OrderProd
 	}
 
 	// 排序
-	query = query.Order("created_at desc")
+	query = query.Order("created_at asc")
 
 	err = query.Find(&m).Error
 	if err != nil {

api/dto/ArticleScience.go

@@ -0,0 +1,90 @@
+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:是）
+	Sort                 int                      `json:"sort"`                   // 排序值（越大越靠前）
+	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"`             // 更新时间
+	ArticleScienceSource *ArticleScienceSourceDto `json:"article_science_source"` // 文章来源
+	ArticleScienceClass  []*BasicArticleClassDto  `json:"article_science_class"`  // 文章分类
+}
+
+// GetArticleScienceDto 详情
+func GetArticleScienceDto(m *model.ArticleScience) *ArticleScienceDto {
+	return &ArticleScienceDto{
+		ArticleId:     fmt.Sprintf("%d", m.ArticleId),
+		ArticleTitle:  m.ArticleTitle,
+		ArticleStatus: m.ArticleStatus,
+		IsTop:         m.IsTop,
+		Sort:          m.Sort,
+		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,
+				Sort:          v.Sort,
+				ArticleImage:  utils.AddOssDomain(v.ArticleImage),
+				SourceId:      fmt.Sprintf("%d", v.SourceId),
+				ArticleUrl:    v.ArticleUrl,
+				CreatedAt:     v.CreatedAt,
+				UpdatedAt:     v.UpdatedAt,
+			}
+
+			// 加载文章来源
+			if v.ArticleScienceSource != nil {
+				response = response.LoadArticleScienceSource(v.ArticleScienceSource)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadArticleScienceSource 加载文章来源
+func (r *ArticleScienceDto) LoadArticleScienceSource(m *model.ArticleScienceSource) *ArticleScienceDto {
+	if m != nil {
+		r.ArticleScienceSource = GetArticleScienceSourceDto(m)
+	}
+	return r
+}
+
+// LoadArticleScienceClass 加载文章分类
+func (r *ArticleScienceDto) LoadArticleScienceClass(m *model.BasicArticleClass) *ArticleScienceDto {
+	if m != nil {
+		basicArticleClass := GetBasicArticleClassDto(m)
+
+		r.ArticleScienceClass = append(r.ArticleScienceClass, basicArticleClass)
+	}
+	return r
+}

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,40 @@
+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"`
+	Sort          int    `gorm:"column:sort;type:int(5);default:1;comment:排序值（越大越靠前）" json:"sort"`
+	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
+	ArticleScienceSource *ArticleScienceSource  `gorm:"foreignKey:SourceId;references:source_id" json:"article_science_source"`
+	ArticleScienceClass  []*ArticleScienceClass `gorm:"foreignKey:ArticleId;references:article_id" json:"article_science_class"`
+}
+
+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,35 @@
+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
+	ArticleScience    *ArticleScience    `gorm:"foreignKey:ArticleId;references:article_id" json:"article_science"`
+	BasicArticleClass *BasicArticleClass `gorm:"foreignKey:BasicClassId;references:basic_class_id" json:"basic_article_class"`
+}
+
+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/model/orderProductItem.go

@@ -21,6 +21,7 @@ type OrderProductItem struct {
 	ProductCoverImg     string  `gorm:"column:product_cover_img;type:varchar(255);comment:商品封面图" json:"product_cover_img"`
 	ProductSpec         string  `gorm:"column:product_spec;type:varchar(255);comment:商品规格" json:"product_spec"`
 	Model
+	Product *Product `gorm:"foreignKey:ProductId;references:product_id" json:"product"` // 药品
 }
 
 func (m *OrderProductItem) TableName() string {

api/requests/ArticleScience.go

@@ -0,0 +1,71 @@
+package requests
+
+type ArticleScienceRequest struct {
+	GetArticleSciencePage   // 获取科普文章列表-分页
+	PutArticleScience       // 修改科普文章
+	AddArticleScience       // 新增科普文章
+	PutArticleScienceStatus // 操作科普文章状态
+	PutArticleScienceTop    // 操作科普文章置顶状态
+}
+
+// GetArticleSciencePage 获取科普文章列表-分页
+type GetArticleSciencePage struct {
+	Page          int    `json:"page" form:"page" label:"页码"`
+	PageSize      int    `json:"page_size" form:"page_size" label:"每页个数"`
+	ArticleTitle  string `json:"article_title" form:"article_title" label:"文章标题"`                                          // 文章标题
+	ArticleStatus *int   `json:"article_status" form:"article_status" label:"文章状态" validate:"omitempty,numeric,oneof=1 2"` // 文章状态（1:正常 2:禁用）
+	IsTop         *int   `json:"is_top" form:"is_top" label:"是否置顶" validate:"omitempty,numeric,oneof=0 1"`                 // 是否置顶（0:否 1:是）
+
+	SourceId string                      `json:"source_id" form:"source_id" label:"文章来源"` // 文章来源id
+	Order    *GetArticleSciencePageOrder `json:"order"   form:"order" label:"排序"`
+}
+
+// GetArticleSciencePageOrder 获取科普文章列表-分页-排序条件
+type GetArticleSciencePageOrder struct {
+	UpdatedAt string `json:"updated_at" form:"updated_at" label:"排序"` // 修改时间
+	Sort      string `json:"sort" form:"sort" label:"排序值"`            // 排序值
+}
+
+// PutArticleScience 修改科普文章
+type PutArticleScience struct {
+	ArticleTitle        string                    `json:"article_title" form:"article_title" label:"文章标题" validate:"required"`                      // 文章标题
+	ArticleStatus       int                       `json:"article_status" form:"article_status" label:"文章状态" validate:"omitempty,numeric,oneof=1 2"` // 文章状态（1:正常 2:禁用）
+	IsTop               int                       `json:"is_top" form:"is_top" label:"是否置顶" validate:"omitempty,numeric,oneof=0 1"`
+	Sort                int                       `json:"sort" form:"sort" label:"排序值" validate:"required,numeric,min=1"` // 是否置顶（0:否 1:是）
+	ArticleImage        string                    `json:"article_image"  form:"is_top" label:"文章图片" validate:"required"`
+	SourceId            string                    `json:"source_id"  form:"source_id" label:"文章来源" validate:"required"`
+	ArticleUrl          string                    `json:"article_url"  form:"article_url" label:"文章地址" validate:"required"`
+	ArticleScienceClass []*PutArticleScienceClass `json:"article_science_class"  form:"article_science_class" label:"文章分类" validate:"required"`
+}
+
+// PutArticleScienceClass 修改科普文章-文章分类
+type PutArticleScienceClass struct {
+	BasicClassId string `json:"basic_class_id"  form:"basic_class_id" label:"分类" validate:"required"`
+}
+
+// AddArticleScience 新增科普文章
+type AddArticleScience struct {
+	ArticleTitle        string                    `json:"article_title" form:"article_title" label:"文章标题" validate:"required"`                      // 文章标题
+	ArticleStatus       int                       `json:"article_status" form:"article_status" label:"文章状态" validate:"omitempty,numeric,oneof=1 2"` // 文章状态（1:正常 2:禁用）
+	IsTop               int                       `json:"is_top" form:"is_top" label:"是否置顶" validate:"omitempty,numeric,oneof=0 1"`                 // 是否置顶（0:否 1:是）
+	Sort                int                       `json:"sort" form:"sort" label:"排序值" validate:"required,numeric,min=1"`                           // 是否置顶（0:否 1:是）
+	ArticleImage        string                    `json:"article_image"  form:"is_top" label:"文章图片" validate:"required"`
+	SourceId            string                    `json:"source_id"  form:"source_id" label:"文章来源" validate:"required"`
+	ArticleUrl          string                    `json:"article_url"  form:"article_url" label:"文章地址" validate:"required"`
+	ArticleScienceClass []*AddArticleScienceClass `json:"article_science_class"  form:"article_science_class" label:"文章分类" validate:"required"`
+}
+
+// AddArticleScienceClass 新增科普文章-文章分类
+type AddArticleScienceClass struct {
+	BasicClassId string `json:"basic_class_id"  form:"basic_class_id" label:"分类" validate:"required"`
+}
+
+// PutArticleScienceStatus 操作科普文章状态
+type PutArticleScienceStatus struct {
+	ArticleStatus int `json:"article_status" form:"article_status" label:"状态"  validate:"required,oneof=1 2"` // 文章状态（1:正常 2:禁用）
+}
+
+// PutArticleScienceTop 操作科普文章置顶状态
+type PutArticleScienceTop struct {
+	IsTop int `json:"is_top" form:"is_top" label:"状态" validate:"omitempty,numeric,oneof=0 1"` // 是否置顶（0:否 1:是）
+}

api/requests/ArticleScienceSource.go

@@ -0,0 +1,38 @@
+package requests
+
+type ArticleScienceSourceRequest struct {
+	GetArticleScienceSourcePage // 获取科普文章来源列表-分页
+	GetArticleScienceSourceList // 获取科普文章来源列表
+	PutArticleScienceSource     // 修改科普文章来源
+	AddArticleScienceSource     // 新增科普文章来源
+}
+
+// GetArticleScienceSourcePage 获取科普文章来源列表-分页
+type GetArticleScienceSourcePage struct {
+	Page       int                               `json:"page" form:"page" label:"页码"`
+	PageSize   int                               `json:"page_size" form:"page_size" label:"每页个数"`
+	SourceName string                            `json:"source_name" form:"source_name" label:"来源名称"` // 来源名称
+	Order      *GetArticleScienceSourcePageOrder `json:"order"   form:"order" label:"排序"`
+}
+
+// GetArticleScienceSourcePageOrder 获取科普文章来源列表-分页-排序条件
+type GetArticleScienceSourcePageOrder struct {
+	UpdatedAt string `json:"updated_at" form:"updated_at" label:"排序"` // 修改时间
+}
+
+// GetArticleScienceSourceList 获取科普文章来源列表
+type GetArticleScienceSourceList struct {
+	SourceName string `json:"source_name" form:"source_name" label:"来源名称"` // 来源名称
+}
+
+// PutArticleScienceSource 修改科普文章来源
+type PutArticleScienceSource struct {
+	SourceName  string `json:"source_name" form:"source_name" label:"来源名称" validate:"required"` // 来源名称
+	SourceImage string `json:"source_image" form:"source_image" label:"来源图片"`                   // 来源图片
+}
+
+// AddArticleScienceSource 新增科普文章来源
+type AddArticleScienceSource struct {
+	SourceName  string `json:"source_name" form:"source_name" label:"来源名称" validate:"required"` // 来源名称
+	SourceImage string `json:"source_image" form:"source_image" label:"来源图片"`                   // 来源图片
+}

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/requests/admin.go

@@ -18,7 +18,7 @@ type Login struct {
 // GetOssSign 获取oss签名
 type GetOssSign struct {
 	UserType int `json:"user_type" form:"user_type" validate:"required,oneof=1 2 3 4" label:"用户类型"` // （1:患者 2:医生 3:药师 4:后台）
-	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:头像 2:证书 3:名片 4:文章）
 }
 
 // GetDecryptCardNum 获取用户身份证号

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,69 @@ 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)
+		}
+	}
+
+	// 文章管理
+	articleGroup := adminGroup.Group("/article")
+	{
+		// 科普文章
+		scienceGroup := articleGroup.Group("science")
+		{
+			// 获取科普文章列表-分页
+			scienceGroup.POST("/page", api.ArticleScience.GetArticleSciencePage)
+
+			// 获取科普文章详情
+			scienceGroup.GET("/:article_id", api.ArticleScience.GetArticleScience)
+
+			// 修改科普文章
+			scienceGroup.PUT("/:article_id", api.ArticleScience.PutArticleScience)
+
+			// 新增科普文章
+			scienceGroup.POST("", api.ArticleScience.AddArticleScience)
+
+			// 操作科普文章状态
+			scienceGroup.PUT("/status/:article_id", api.ArticleScience.PutArticleScienceStatus)
+
+			// 操作科普文章置顶状态
+			scienceGroup.PUT("/top/:article_id", api.ArticleScience.PutArticleScienceTop)
+
+			// 科普文章来源
+			sourceGroup := scienceGroup.Group("source")
+			{
+				// 获取科普文章来源列表-分页
+				sourceGroup.POST("/page", api.ArticleScienceSource.GetArticleScienceSourcePage)
+
+				// 获取科普文章来源列表
+				sourceGroup.GET("/list", api.ArticleScienceSource.GetArticleScienceSourceList)
+
+				// 获取科普文章来源详情
+				sourceGroup.GET("/:source_id", api.ArticleScienceSource.GetArticleScienceSource)
+
+				// 修改科普文章来源
+				sourceGroup.PUT("/:source_id", api.ArticleScienceSource.PutArticleScienceSource)
+
+				// 新增科普文章来源
+				sourceGroup.POST("", api.ArticleScienceSource.AddArticleScienceSource)
+			}
+		}
 	}
 }

api/service/admin.go

@@ -87,6 +87,8 @@ func (a *AdminService) GetOssSign(getOssSignRequest requests.GetOssSign) (*aliyu
 			dir = dir + "cert/"
 		} else if getOssSignRequest.Scene == 3 {
 			dir = dir + "card/"
+		} else if getOssSignRequest.Scene == 4 {
+			dir = dir + "article/"
 		}
 	}
 

api/service/export.go

@@ -32,12 +32,12 @@ type DoctorWithdrawalData struct {
 	BankCardAddress         string  // 银行地址
 	ExamineStatus           string  // 审核状态（1:审核中 2:审核通过 3:审核未通过）
 	ExamineFailReason       string  // 审核失败原因
-	ExamineTime             time.Time // 审核日期
+	ExamineTime             string  // 审核日期
 	ExamineBy               string  // 审核人员名称
 	PaymentStatus           string  // 财务打款状态（0:否 1:是）
-	PaymentTime             time.Time // 财务打款时间
+	PaymentTime             string  // 财务打款时间
 	PaymentBy               string  // 财务打款人员id（后台用户id）
-	CreatedAt               time.Time // 创建时间
+	CreatedAt               string  // 创建时间
 }
 
 // DoctorWithdrawalOrderData 提现记录-关联订单
@@ -48,7 +48,7 @@ type DoctorWithdrawalOrderData struct {
 	PatientAge         string  // 患者年龄-就诊人
 	PatientMobile      string  // 患者电话
 	PayChannel         string  // 支付渠道（1:小程序支付 2:微信扫码支付 3:模拟支付）
-	PayTime            time.Time // 支付时间
+	PayTime            string  // 支付时间
 	InquiryNo          string  // 系统订单编号
 	EscrowTradeNo      string  // 第三方支付流水号
 	AmountTotal        float64 // 订单金额
@@ -64,10 +64,10 @@ type UserDoctorData struct {
 	Status                      string  // 状态（0:禁用 1:正常 2:删除）
 	IdcardStatus                string  // 实名认证状态（0:未认证 1:认证通过 2:认证失败）
 	IdenAuthStatus              string  // 身份认证状态（0:未认证 1:认证通过 2:审核中 3:认证失败）
-	IdenAuthTime                time.Time // 审核时间
+	IdenAuthTime                string  // 审核时间
 	IdenAuthFailReason          string  // 身份认证失败原因
 	MultiPointStatus            string  // 医生多点执业认证状态（0:未认证 1:认证通过 2:审核中 3:认证失败）
-	MultiPointTime              time.Time // 审核时间
+	MultiPointTime              string  // 审核时间
 	MultiPointFailReason        string  // 多点执业认证失败原因
 	IsRecommend                 string  // 是否首页推荐（0:否 1:是）
 	Avatar                      string  // 头像
@@ -87,7 +87,7 @@ type UserDoctorData struct {
 	QrCode                      string  // 分享二维码
 	BeGoodAt                    string  // 擅长
 	BriefIntroduction           string  // 医生简介
-	CreatedAt                   time.Time // 创建时间
+	CreatedAt                   string  // 创建时间
 	Mobile                      string  // 手机号
 	Age                         string  // 年龄
 	Sex                         string  // 性别（0:未知 1:男 2:女）
@@ -105,8 +105,8 @@ type UserDoctorData struct {
 	IdCardFront                 string  // 身份证正面图片
 	IdCardBack                  string  // 身份证背面图片
 	SignImage                   string  // 签名图片
-	CertApplicationTime         time.Time // ca证书申请时间
+	CertApplicationTime         string  // ca证书申请时间
-	CertExpireTime              time.Time // ca证书过期时间
+	CertExpireTime              string  // ca证书过期时间
 	BankName                    string  // 开户银行名称
 	BankCardCode                string  // 开户银行卡号
 	BankCardAddress             string  // 开户银行地址
@@ -121,7 +121,7 @@ type DoctorBankCardData struct {
 	Province     string // 省份
 	City         string // 城市
 	County       string // 区县
-	CreatedAt    time.Time // 创建时间
+	CreatedAt    string // 创建时间
 }
 
 // DoctorAccountData 医生账户
@@ -158,19 +158,19 @@ type OrderInquiryForAccount struct {
 	CouponAmountTotal   float64 // 优惠卷总金额
 	PaymentAmountTotal  float64 // 实际付款金额
 	DoctorAmount        float64 // 医生收益
-	PayTime             time.Time // 支付时间
+	PayTime             string  // 支付时间
-	ReceptionTime       time.Time // 接诊时间（已接诊）
+	ReceptionTime       string  // 接诊时间（已接诊）
-	CompleteTime        time.Time // 订单完成时间（问诊完成时间）
+	CompleteTime        string  // 订单完成时间（问诊完成时间）
-	FinishTime          time.Time // 订单结束时间
+	FinishTime          string  // 订单结束时间
 	StatisticsStatus    string  // 订单统计状态（0:未统计 1:已统计 2:统计失败）
-	StatisticsTime      time.Time // 订单统计时间
+	StatisticsTime      string  // 订单统计时间
 	IsWithdrawal        string  // 是否提现（0:否 1:是 2:提现中）
-	WithdrawalTime      time.Time // 提现时间
+	WithdrawalTime      string  // 提现时间
-	CancelTime          time.Time // 订单取消时间
+	CancelTime          string  // 订单取消时间
 	CancelReason        string  // 取消订单原因（1:医生未接诊 2:主动取消 3:无可分配医生 4:客服取消 5:支付超时）
 	CancelRemarks       string  // 取消订单备注（自动添加）
 	EntryStatus         string  // 入账状态（0:未入账 1:已入账 2:入账中 3:入账失败）
-	CreatedAt           time.Time // 创建时间
+	CreatedAt           string  // 创建时间
 }
 
 // UserPatientData 患者列表
@@ -181,7 +181,7 @@ type UserPatientData struct {
 	Avatar             string // 头像
 	DisableReason      string // 禁用理由
 	PatientFamilyCount string // 家庭成员数量
-	CreatedAt          time.Time // 创建时间
+	CreatedAt          string // 创建时间
 }
 
 // PatientFamilyData 就诊人列表
@@ -204,7 +204,7 @@ type PatientFamilyData struct {
 	MaritalStatus string `json:"marital_status"` // 婚姻状况（0:未婚 1:已婚 2:离异）
 	NationName    string `json:"nation_name"`    // 民族名称
 	JobName       string `json:"job_name"`       // 职业名称
-	CreatedAt     time.Time `json:"created_at"`     // 创建时间
+	CreatedAt     string `json:"created_at"`     // 创建时间
 }
 
 // OrderInquiry 问诊订单
@@ -228,57 +228,71 @@ type OrderInquiry struct {
 	CouponAmountTotal   float64 // 优惠卷总金额
 	PaymentAmountTotal  float64 // 实际付款金额
 	DoctorAmount        float64 // 医生收益
-	PayTime             time.Time // 支付时间
+	PayTime             string  // 支付时间
-	ReceptionTime       time.Time // 接诊时间（已接诊）
+	ReceptionTime       string  // 接诊时间（已接诊）
-	CompleteTime        time.Time // 订单完成时间（问诊完成时间）
+	CompleteTime        string  // 订单完成时间（问诊完成时间）
-	FinishTime          time.Time // 订单结束时间
+	FinishTime          string  // 订单结束时间
 	StatisticsStatus    string  // 订单统计状态（0:未统计 1:已统计 2:统计失败）
-	StatisticsTime      time.Time // 订单统计时间
+	StatisticsTime      string  // 订单统计时间
 	IsWithdrawal        string  // 是否提现（0:否 1:是 2:提现中）
-	WithdrawalTime      time.Time // 提现时间
+	WithdrawalTime      string  // 提现时间
-	CancelTime          time.Time // 订单取消时间
+	CancelTime          string  // 订单取消时间
 	CancelReason        string  // 取消订单原因（1:医生未接诊 2:主动取消 3:无可分配医生 4:客服取消 5:支付超时）
 	CancelRemarks       string  // 取消订单备注（自动添加）
 	EntryStatus         string  // 入账状态（0:未入账 1:已入账 2:入账中 3:入账失败）
-	CreatedAt           time.Time // 创建时间
+	CreatedAt           string  // 创建时间
 }
 
 // OrderProductData 药品订单
 type OrderProductData struct {
 	OrderProductNo           string                 // 订单编号
+	OrderProductStatus       string                 // 订单状态（1:待支付 2:待发货 3:已发货 4:已签收 5:已取消）
+	AmountTotal              float64                // 订单金额
+	CouponAmountTotal        float64                // 优惠卷总金额
+	PaymentAmountTotal       float64                // 实际付款金额
+	LogisticsFee             float64                // 运费金额
+	CreatedAt                string                 // 创建时间
+	Remarks                  string                 // 订单备注
 	DoctorName               string                 // 医生姓名
+	DoctorMobile             string                 // 医生电话
 	PatientName              string                 // 患者姓名-就诊人
 	PatientSex               string                 // 患者性别-就诊人（0:未知 1:男 2:女）
 	PatientAge               string                 // 患者年龄-就诊人
 	PatientMobile            string                 // 患者电话
+	HistoryBuyCount          string                 // 历史购买次数
+	HistoryBuyOrderProductNo string                 // 历史购买单号（逗号分隔）
 	EscrowTradeNo            string                 // 第三方支付流水号
-	PrescriptionCode     string    // 处方编号
-	OrderProductStatus   string    // 订单状态（1:待支付 2:待发货 3:已发货 4:已签收 5:已取消）
-	PayChannel           string    // 支付渠道（1:小程序支付 2:微信扫码支付）;NOT NULL
 	PayStatus                string                 // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
-	CancelReason         string    // 订单取消原因（1:主动取消 2:复核失败/库存不足 3:支付超时 4:客服取消）
+	PayTime                  string                 // 支付时间
-	AmountTotal          float64   // 订单金额
+	PayChannel               string                 // 支付渠道（1:小程序支付 2:微信扫码支付）;NOT NULL
-	PaymentAmountTotal   float64   // 实际付款金额
+	PrescriptionCode         string                 // 处方编号
-	LogisticsFee         float64   // 运费金额
+	ReportPreStatus          string                 // 上报处方平台状态（0:未上报 1:已上报 2:上报失败））
+	ReportPreTime            string                 // 上报处方平台时间
+	ReportPreFailReason      string                 // 上报失败原因
 	LogisticsNo              string                 // 物流编号
 	LogisticsCompanyCode     string                 // 快递公司编码
-	ProductNames         string    // 药品列表
+	DeliveryTime             string                 // 发货时间
-	DeliveryTime         time.Time // 发货时间
+	ProductItem              []OrderProductItemData // 药品列表
-	PayTime              time.Time // 支付时间
-	Remarks              string    // 订单备注
 	RefundStatus             string                 // 商品订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭  6:退款异常）
-	CancelTime           time.Time // 订单取消时间
+	CancelTime               string                 // 订单取消时间
 	CancelRemarks            string                 // 订单取消备注（自动添加）
-	ReportPreStatus      string    // 上报处方平台状态（0:未上报 1:已上报 2:上报失败））
+	CancelReason             string                 // 订单取消原因（1:主动取消 2:复核失败/库存不足 3:支付超时 4:客服取消）
-	ReportPreTime        time.Time // 上报处方平台时间
+	ConsigneeName            string                 // 收货人姓名
-	ReportPreFailReason  string    // 上报失败原因
+	ConsigneeTel             string                 // 收货人电话
 	Province                 string                 // 省份
 	City                     string                 // 城市
 	County                   string                 // 区县
 	Address                  string                 // 详细地址
-	ConsigneeName        string    // 收货人姓名
+}
-	ConsigneeTel         string    // 收货人电话
+
-	CreatedAt            time.Time // 创建时间
+// OrderProductItemData 药品订单-药品列表
+type OrderProductItemData struct {
+	ProductName         string  // 商品名称
+	ProductPlatformCode string  // 处方平台商品编码
+	ProductSpec         string  // 商品规格
+	AvailableDays       float64 // 可用天数(3)
+	ProductAmount       string  // 药品数量
+	ProductPrice        float64 // 商品价格
 }
 
 // OrderServicePackageDto 订单-服务包
@@ -297,16 +311,16 @@ type OrderServicePackageDto struct {
 	CancelReason        string  // 取消订单原因（1:医生未接受服务 2:主动取消 4:客服取消 5:支付超时）
 	AmountTotal         float64 // 订单金额
 	PaymentAmountTotal  float64 // 实际付款金额
-	PayTime             time.Time // 支付时间
+	PayTime             string  // 支付时间
-	StartTime           time.Time // 开始服务时间
+	StartTime           string  // 开始服务时间
-	FinishTime          time.Time // 结束服务时间
+	FinishTime          string  // 结束服务时间
 	RefundStatus        string  // 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
-	CancelTime          time.Time // 订单取消时间
+	CancelTime          string  // 订单取消时间
 	CancelRemarks       string  // 取消订单备注
 	AddFinishStatus     string  // 添加完成订单延迟队列状态（0:未添加 1:已添加 2:添加失败）
-	AddFinishTime       time.Time // 添加完成订单延迟队列时间
+	AddFinishTime       string  // 添加完成订单延迟队列时间
 	AddFinishFailReason string  // 添加完成订单延迟队列失败原因
-	CreatedAt           time.Time // 创建时间
+	CreatedAt           string  // 创建时间
 }
 
 // OrderPrescriptionData 处方
@@ -315,14 +329,14 @@ type OrderPrescriptionData struct {
 	PharmacistName        string // 药师姓名
 	PrescriptionStatus    string // 处方状态（1:待审核 2:待使用 3:已失效 4:已使用）
 	PharmacistAuditStatus string // 药师审核状态（0:审核中 1:审核成功 2:审核驳回）
-	PharmacistVerifyTime  time.Time // 药师审核时间
+	PharmacistVerifyTime  string // 药师审核时间
 	PharmacistFailReason  string // 药师审核驳回原因
 	PlatformAuditStatus   string // 处方平台审核状态（0:审核中 1:审核成功 2:审核驳回）
-	PlatformFailTime      time.Time // 平台审核失败时间
+	PlatformFailTime      string // 平台审核失败时间
 	PlatformFailReason    string // 处方平台驳回原因
 	IsAutoPharVerify      string // 是否药师自动审核（0:否 1:是）
-	DoctorCreatedTime     time.Time // 医生开具处方时间
+	DoctorCreatedTime     string // 医生开具处方时间
-	ExpiredTime           time.Time // 处方过期时间
+	ExpiredTime           string // 处方过期时间
 	IsDelete              string // 是否删除（0:否 1:是）
 	PrescriptionCode      string // 处方编号
 	ProductNames          string // 药品列表
@@ -332,7 +346,7 @@ type OrderPrescriptionData struct {
 	PatientMobile         string // 患者电话
 	DoctorAdvice          string // 医嘱
 	OrderPrescriptionIcd  string // 处方诊断疾病
-	CreatedAt             time.Time // 创建时间
+	CreatedAt             string // 创建时间
 }
 
 // ProductData 系统商品
@@ -357,7 +371,7 @@ type ProductData struct {
 	FrequencyUse        string  // 使用频率(例：1天3次)
 	AvailableDays       float64 // 可用天数(3)
 	ProductRemarks      string  // 商品备注
-	CreatedAt           time.Time // 创建时间
+	CreatedAt           string  // 创建时间
 }
 
 // DoctorWithdrawal 提现记录
@@ -383,7 +397,7 @@ func (r *ExportService) DoctorWithdrawal(doctorWithdrawals []*model.DoctorWithdr
 		{Value: "申请时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30},
 	}
 
-	var interfaceSlice []interface{}
+	var dataSlice []interface{}
 	for _, v := range doctorWithdrawals {
 		// 审核状态
 		examineStatus := utils.WithdrawalExamineStatusToString(v.ExamineStatus)
@@ -402,7 +416,7 @@ func (r *ExportService) DoctorWithdrawal(doctorWithdrawals []*model.DoctorWithdr
 		paymentStatus := "未知"
 		if v.PaymentStatus == 0 {
 			paymentStatus = "未打款"
-		} else if v.ExamineStatus == 1 {
+		} else if v.PaymentStatus == 1 {
 			paymentStatus = "已打款"
 		}
 
@@ -441,22 +455,19 @@ func (r *ExportService) DoctorWithdrawal(doctorWithdrawals []*model.DoctorWithdr
 		}
 
 		// 时间处理
-		var examineTime time.Time
+		var examineTime string
 		if v.ExamineTime != (model.LocalTime{}) {
-			t := time.Time(v.ExamineTime)
+			examineTime = time.Time(v.ExamineTime).Format("2006-01-02 15:04:05")
-			examineTime = t
 		}
 
-		var paymentTime time.Time
+		var paymentTime string
 		if v.PaymentTime != (model.LocalTime{}) {
-			t := time.Time(v.PaymentTime)
+			paymentTime = time.Time(v.PaymentTime).Format("2006-01-02 15:04:05")
-			paymentTime = t
 		}
 
-		var createdAt time.Time
+		var createdAt string
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			createdAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			createdAt = t
 		}
 
 		doctorWithdrawalData := DoctorWithdrawalData{
@@ -480,10 +491,10 @@ func (r *ExportService) DoctorWithdrawal(doctorWithdrawals []*model.DoctorWithdr
 			CreatedAt:               createdAt,
 		}
 
-		interfaceSlice = append(interfaceSlice, doctorWithdrawalData)
+		dataSlice = append(dataSlice, doctorWithdrawalData)
 	}
 
-	file, err := utils.Export(header, interfaceSlice)
+	file, err := utils.Export(header, dataSlice)
 	if err != nil {
 		return "", err
 	}
@@ -522,7 +533,7 @@ func (r *ExportService) DoctorWithdrawalOrder(doctorWithdrawalOrders []*model.Do
 		{Value: "医生收益", CellType: "float", NumberFmt: "0.0000", ColWidth: 18},
 	}
 
-	var interfaceSlice []interface{}
+	var dataSlice []interface{}
 	for _, v := range doctorWithdrawalOrders {
 		// 医生姓名
 		doctorName := ""
@@ -542,7 +553,7 @@ func (r *ExportService) DoctorWithdrawalOrder(doctorWithdrawalOrders []*model.Do
 		var couponAmountTotal float64
 		var paymentAmountTotal float64
 		var doctorAmount float64
-		var payTime time.Time
+		var payTime string
 		if v.Order.OrderInquiry != nil {
 			patientName = v.Order.OrderInquiry.PatientName
 
@@ -573,8 +584,7 @@ func (r *ExportService) DoctorWithdrawalOrder(doctorWithdrawalOrders []*model.Do
 			// 时间处理
 
 			if v.Order.OrderInquiry.PayTime != (model.LocalTime{}) {
-				t := time.Time(v.Order.OrderInquiry.PayTime)
+				payTime = time.Time(v.Order.OrderInquiry.PayTime).Format("2006-01-02 15:04:05")
-				payTime = t
 			}
 		}
 
@@ -594,10 +604,10 @@ func (r *ExportService) DoctorWithdrawalOrder(doctorWithdrawalOrders []*model.Do
 			DoctorAmount:       doctorAmount,
 		}
 
-		interfaceSlice = append(interfaceSlice, doctorWithdrawalOrderData)
+		dataSlice = append(dataSlice, doctorWithdrawalOrderData)
 	}
 
-	file, err := utils.Export(header, interfaceSlice)
+	file, err := utils.Export(header, dataSlice)
 	if err != nil {
 		return "", err
 	}
@@ -673,7 +683,7 @@ func (r *ExportService) UserDoctor(userDoctors []*model.UserDoctor) (string, err
 		{Value: "银行地址", CellType: "string", NumberFmt: "", ColWidth: 46},
 	}
 
-	var interfaceSlice []interface{}
+	var dataSlice []interface{}
 	for _, v := range userDoctors {
 		userDoctorData := UserDoctorData{
 			UserName:                    v.UserName,
@@ -844,20 +854,17 @@ func (r *ExportService) UserDoctor(userDoctors []*model.UserDoctor) (string, err
 
 		// 身份审核时间
 		if v.IdenAuthTime != (model.LocalTime{}) {
-			t := time.Time(v.IdenAuthTime)
+			userDoctorData.IdenAuthTime = time.Time(v.IdenAuthTime).Format("2006-01-02 15:04:05")
-			userDoctorData.IdenAuthTime = t
 		}
 
 		// 多点审核时间
 		if v.MultiPointTime != (model.LocalTime{}) {
-			t := time.Time(v.MultiPointTime)
+			userDoctorData.MultiPointTime = time.Time(v.MultiPointTime).Format("2006-01-02 15:04:05")
-			userDoctorData.MultiPointTime = t
 		}
 
 		// 创建时间
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			userDoctorData.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			userDoctorData.CreatedAt = t
 		}
 
 		// 获取ca证书
@@ -866,14 +873,12 @@ func (r *ExportService) UserDoctor(userDoctors []*model.UserDoctor) (string, err
 		if userCaCert != nil {
 			// ca证书申请时间
 			if userCaCert.CertApplicationTime != (model.LocalTime{}) {
-				t := time.Time(userCaCert.CertApplicationTime)
+				userDoctorData.CertApplicationTime = time.Time(userCaCert.CertApplicationTime).Format("2006-01-02 15:04:05")
-				userDoctorData.CertApplicationTime = t
 			}
 
 			// ca证书过期时间
 			if userCaCert.CertExpireTime != (model.LocalTime{}) {
-				t := time.Time(userCaCert.CertExpireTime)
+				userDoctorData.CertExpireTime = time.Time(userCaCert.CertExpireTime).Format("2006-01-02 15:04:05")
-				userDoctorData.CertExpireTime = t
 			}
 		}
 
@@ -914,10 +919,10 @@ func (r *ExportService) UserDoctor(userDoctors []*model.UserDoctor) (string, err
 			}
 		}
 
-		interfaceSlice = append(interfaceSlice, userDoctorData)
+		dataSlice = append(dataSlice, userDoctorData)
 	}
 
-	file, err := utils.Export(header, interfaceSlice)
+	file, err := utils.Export(header, dataSlice)
 	if err != nil {
 		return "", err
 	}
@@ -976,8 +981,7 @@ func (r *ExportService) UserDoctorBankCard(d []*model.DoctorBankCard) (string, e
 
 		// 创建时间
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
 		dataSlice = append(dataSlice, data)
@@ -1148,43 +1152,35 @@ func (r *ExportService) OrderInquiryForAccount(d []*model.OrderInquiry) (string,
 		}
 
 		if v.PayTime != (model.LocalTime{}) {
-			t := time.Time(v.PayTime)
+			data.PayTime = time.Time(v.PayTime).Format("2006-01-02 15:04:05")
-			data.PayTime = t
 		}
 
 		if v.ReceptionTime != (model.LocalTime{}) {
-			t := time.Time(v.ReceptionTime)
+			data.ReceptionTime = time.Time(v.ReceptionTime).Format("2006-01-02 15:04:05")
-			data.ReceptionTime = t
 		}
 
 		if v.CompleteTime != (model.LocalTime{}) {
-			t := time.Time(v.CompleteTime)
+			data.CompleteTime = time.Time(v.CompleteTime).Format("2006-01-02 15:04:05")
-			data.CompleteTime = t
 		}
 
 		if v.FinishTime != (model.LocalTime{}) {
-			t := time.Time(v.FinishTime)
+			data.FinishTime = time.Time(v.FinishTime).Format("2006-01-02 15:04:05")
-			data.FinishTime = t
 		}
 
 		if v.StatisticsTime != (model.LocalTime{}) {
-			t := time.Time(v.StatisticsTime)
+			data.StatisticsTime = time.Time(v.StatisticsTime).Format("2006-01-02 15:04:05")
-			data.StatisticsTime = t
 		}
 
 		if v.WithdrawalTime != (model.LocalTime{}) {
-			t := time.Time(v.WithdrawalTime)
+			data.WithdrawalTime = time.Time(v.WithdrawalTime).Format("2006-01-02 15:04:05")
-			data.WithdrawalTime = t
 		}
 
 		if v.CancelTime != (model.LocalTime{}) {
-			t := time.Time(v.CancelTime)
+			data.CancelTime = time.Time(v.CancelTime).Format("2006-01-02 15:04:05")
-			data.CancelTime = t
 		}
 
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
 		// 处理入账状态（0:未入账 1:已入账 2:入账中 3:入账失败 4:入账取消）
@@ -1244,8 +1240,7 @@ func (r *ExportService) UserPatient(d []*model.UserPatient) (string, error) {
 		}
 
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
 		if len(v.PatientFamily) > 0 {
@@ -1331,8 +1326,7 @@ func (r *ExportService) PatientFamily(d []*model.PatientFamily) (string, error)
 		}
 
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
 		dataSlice = append(dataSlice, data)
@@ -1437,43 +1431,35 @@ func (r *ExportService) OrderInquiry(d []*model.OrderInquiry) (string, error) {
 		}
 
 		if v.PayTime != (model.LocalTime{}) {
-			t := time.Time(v.PayTime)
+			data.PayTime = time.Time(v.PayTime).Format("2006-01-02 15:04:05")
-			data.PayTime = t
 		}
 
 		if v.ReceptionTime != (model.LocalTime{}) {
-			t := time.Time(v.ReceptionTime)
+			data.ReceptionTime = time.Time(v.ReceptionTime).Format("2006-01-02 15:04:05")
-			data.ReceptionTime = t
 		}
 
 		if v.CompleteTime != (model.LocalTime{}) {
-			t := time.Time(v.CompleteTime)
+			data.CompleteTime = time.Time(v.CompleteTime).Format("2006-01-02 15:04:05")
-			data.CompleteTime = t
 		}
 
 		if v.FinishTime != (model.LocalTime{}) {
-			t := time.Time(v.FinishTime)
+			data.FinishTime = time.Time(v.FinishTime).Format("2006-01-02 15:04:05")
-			data.FinishTime = t
 		}
 
 		if v.StatisticsTime != (model.LocalTime{}) {
-			t := time.Time(v.StatisticsTime)
+			data.StatisticsTime = time.Time(v.StatisticsTime).Format("2006-01-02 15:04:05")
-			data.StatisticsTime = t
 		}
 
 		if v.WithdrawalTime != (model.LocalTime{}) {
-			t := time.Time(v.WithdrawalTime)
+			data.WithdrawalTime = time.Time(v.WithdrawalTime).Format("2006-01-02 15:04:05")
-			data.WithdrawalTime = t
 		}
 
 		if v.CancelTime != (model.LocalTime{}) {
-			t := time.Time(v.CancelTime)
+			data.CancelTime = time.Time(v.CancelTime).Format("2006-01-02 15:04:05")
-			data.CancelTime = t
 		}
 
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
 		// 处理入账状态（0:未入账 1:已入账 2:入账中 3:入账失败 4:入账取消）
@@ -1510,42 +1496,53 @@ func (r *ExportService) OrderInquiry(d []*model.OrderInquiry) (string, error) {
 // OrderProduct 药品订单
 func (r *ExportService) OrderProduct(d []*model.OrderProduct) (string, error) {
 	header := []utils.HeaderCellData{
-		{Value: "系统订单编号", CellType: "string", NumberFmt: "", ColWidth: 25},
+		{Value: "系统订单编号", CellType: "string", NumberFmt: "", ColWidth: 25, Colour: "#FFD700"},
-		{Value: "医生姓名", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "订单状态", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#FFD700"},
-		{Value: "患者姓名-就诊人", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "订单金额", CellType: "float64", NumberFmt: "0.0000", ColWidth: 18, Colour: "#FFD700"},
-		{Value: "患者性别-就诊人", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "优惠卷总金额", CellType: "float64", NumberFmt: "0.0000", ColWidth: 18, Colour: "#FFD700"},
-		{Value: "患者年龄-就诊人", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "实际付款金额", CellType: "float64", NumberFmt: "0.0000", ColWidth: 18, Colour: "#FFD700"},
-		{Value: "患者电话", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "运费金额", CellType: "float64", NumberFmt: "0.0000", ColWidth: 18, Colour: "#FFD700"},
-		{Value: "第三方支付流水号", CellType: "string", NumberFmt: "", ColWidth: 35},
+		{Value: "创建时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30, Colour: "#FFD700"},
-		{Value: "处方编号", CellType: "string", NumberFmt: "", ColWidth: 28},
+		{Value: "订单备注", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#FFD700"},
-		{Value: "订单状态", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "医生姓名", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#EE9A49"},
-		{Value: "支付渠道", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "医生手机号", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#EE9A49"},
-		{Value: "支付状态", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "患者姓名-就诊人", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#40E0D0"},
-		{Value: "订单取消原因", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "患者性别-就诊人", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#40E0D0"},
-		{Value: "订单金额", CellType: "float64", NumberFmt: "0.0000", ColWidth: 18},
+		{Value: "患者年龄-就诊人", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#40E0D0"},
-		{Value: "实际付款金额", CellType: "float64", NumberFmt: "0.0000", ColWidth: 18},
+		{Value: "患者电话", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#40E0D0"},
-		{Value: "运费金额", CellType: "float64", NumberFmt: "0.0000", ColWidth: 18},
+		{Value: "历史购买次数", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#40E0D0"},
-		{Value: "物流编号", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "历史购买单号", CellType: "string", NumberFmt: "", ColWidth: 40, Colour: "#40E0D0"},
-		{Value: "快递公司编码", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "第三方支付流水号", CellType: "string", NumberFmt: "", ColWidth: 35, Colour: "#90EE90"},
-		{Value: "药品", CellType: "string", NumberFmt: "", ColWidth: 35},
+		{Value: "支付状态", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#90EE90"},
-		{Value: "发货时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30},
+		{Value: "支付时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30, Colour: "#90EE90"},
-		{Value: "支付时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30},
+		{Value: "支付渠道", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#90EE90"},
-		{Value: "订单备注", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "处方编号", CellType: "string", NumberFmt: "", ColWidth: 28, Colour: "#FFE4E1"},
-		{Value: "退款状态", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "上报处方平台状态", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#FFE4E1"},
-		{Value: "订单取消时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30},
+		{Value: "上报处方平台时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30, Colour: "#FFE4E1"},
-		{Value: "订单取消备注", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "上报失败原因", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#FFE4E1"},
-		{Value: "上报处方平台状态", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "物流编号", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#CAE1FF"},
-		{Value: "上报处方平台时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30},
+		{Value: "快递公司编码", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#CAE1FF"},
-		{Value: "上报失败原因", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "发货时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30, Colour: "#CAE1FF"},
-		{Value: "省份", CellType: "string", NumberFmt: "", ColWidth: 20},
+		{Value: "药品名称", CellType: "string", NumberFmt: "", ColWidth: 40, Colour: "#AB82FF"},
-		{Value: "城市", CellType: "string", NumberFmt: "", ColWidth: 22},
+		{Value: "处方平台编码", CellType: "string", NumberFmt: "", ColWidth: 30, Colour: "#AB82FF"},
-		{Value: "区县", CellType: "string", NumberFmt: "", ColWidth: 25},
+		{Value: "商品规格", CellType: "string", NumberFmt: "", ColWidth: 30, Colour: "#AB82FF"},
-		{Value: "详细地址", CellType: "string", NumberFmt: "", ColWidth: 35},
+		{Value: "用药天数", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#AB82FF"},
-		{Value: "收货人姓名", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "药品数量", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#AB82FF"},
-		{Value: "收货人电话", CellType: "string", NumberFmt: "", ColWidth: 18},
+		{Value: "药品价格", CellType: "float64", NumberFmt: "0.0000", ColWidth: 18, Colour: "#AB82FF"},
-		{Value: "创建时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30},
+		{Value: "退款状态", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#90EE90"},
+		{Value: "订单取消时间", CellType: "date", NumberFmt: "yyyy-mm-dd hh:mm:ss", ColWidth: 30, Colour: "#90EE90"},
+		{Value: "订单取消备注", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#90EE90"},
+		{Value: "订单取消原因", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#90EE90"},
+		{Value: "收货人姓名", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#FFDEAD"},
+		{Value: "收货人电话", CellType: "string", NumberFmt: "", ColWidth: 18, Colour: "#FFDEAD"},
+		{Value: "省份", CellType: "string", NumberFmt: "", ColWidth: 20, Colour: "#FFDEAD"},
+		{Value: "城市", CellType: "string", NumberFmt: "", ColWidth: 22, Colour: "#FFDEAD"},
+		{Value: "区县", CellType: "string", NumberFmt: "", ColWidth: 25, Colour: "#FFDEAD"},
+		{Value: "详细地址", CellType: "string", NumberFmt: "", ColWidth: 35, Colour: "#FFDEAD"},
 	}
 
+	orderProductDao := dao.OrderProductDao{}
+
 	var dataSlice []interface{}
 	for _, v := range d {
 		data := OrderProductData{
@@ -1556,6 +1553,7 @@ func (r *ExportService) OrderProduct(d []*model.OrderProduct) (string, error) {
 			PayStatus:            utils.PayStatusToString(v.PayStatus),
 			CancelReason:         utils.ProductCancelReasonToString(v.CancelReason),
 			AmountTotal:          v.AmountTotal,
+			CouponAmountTotal:    v.CouponAmountTotal,
 			PaymentAmountTotal:   v.PaymentAmountTotal,
 			LogisticsFee:         v.LogisticsFee,
 			LogisticsNo:          v.LogisticsNo,
@@ -1576,6 +1574,11 @@ func (r *ExportService) OrderProduct(d []*model.OrderProduct) (string, error) {
 		if v.UserDoctor != nil {
 			// 医生姓名
 			data.DoctorName = v.UserDoctor.UserName
+
+			if v.UserDoctor.User != nil {
+				// 医生电话
+				data.DoctorMobile = v.UserDoctor.User.Mobile
+			}
 		}
 
 		if v.OrderInquiry != nil {
@@ -1600,44 +1603,54 @@ func (r *ExportService) OrderProduct(d []*model.OrderProduct) (string, error) {
 		}
 
 		if v.DeliveryTime != (model.LocalTime{}) {
-			t := time.Time(v.DeliveryTime)
+			data.DeliveryTime = time.Time(v.DeliveryTime).Format("2006-01-02 15:04:05")
-			data.DeliveryTime = t
 		}
 
 		if v.PayTime != (model.LocalTime{}) {
-			t := time.Time(v.PayTime)
+			data.PayTime = time.Time(v.PayTime).Format("2006-01-02 15:04:05")
-			data.PayTime = t
 		}
 
 		if v.CancelTime != (model.LocalTime{}) {
-			t := time.Time(v.CancelTime)
+			data.CancelTime = time.Time(v.CancelTime).Format("2006-01-02 15:04:05")
-			data.CancelTime = t
 		}
 
 		if v.ReportPreTime != (model.LocalTime{}) {
-			t := time.Time(v.ReportPreTime)
+			data.ReportPreTime = time.Time(v.ReportPreTime).Format("2006-01-02 15:04:05")
-			data.ReportPreTime = t
 		}
 
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
+		// 历史购买次数
+		maps := make(map[string]interface{})
+		maps["patient_id"] = v.PatientId
+		orderProducts, err := orderProductDao.GetOrderProductNormalList(maps, v.CreatedAt)
+		if err != nil {
+			return "", err
+		}
+		data.HistoryBuyCount = fmt.Sprintf("%d", len(orderProducts))
+
+		// 历史购买单号（逗号分隔）
+		var HistoryBuyOrderProductNo []string
+		for _, product := range orderProducts {
+			HistoryBuyOrderProductNo = append(HistoryBuyOrderProductNo, fmt.Sprintf("%s", product.OrderProductNo))
+		}
+
+		data.HistoryBuyOrderProductNo = strings.Join(HistoryBuyOrderProductNo, "，")
+
 		// 处理药品列表
-		orderProductItemDao := dao.OrderProductItemDao{}
+		for _, item := range v.OrderProductItem {
-		orderProductItems, err := orderProductItemDao.GetOrderProductItemByOrderProductId(v.OrderProductId)
+			productItem := OrderProductItemData{
-		if err == nil || len(orderProductItems) > 0 {
+				ProductName:         item.ProductName,
-			var products []string
+				ProductPlatformCode: item.ProductPlatformCode,
-			for _, v := range orderProductItems {
+				ProductSpec:         item.ProductSpec,
-				amount := fmt.Sprintf("%d", v.Amount)
+				AvailableDays:       item.Product.AvailableDays,
-				productPrice := fmt.Sprintf("%.2f", v.ProductPrice)
+				ProductAmount:       fmt.Sprintf("%d", item.Amount),
-				product := v.ProductName + "(N:" + amount + " " + "P:" + productPrice + ")"
+				ProductPrice:        item.ProductPrice,
-
-				products = append(products, product)
 			}
 
-			data.ProductNames = strings.Join(products, "; ")
+			data.ProductItem = append(data.ProductItem, productItem)
 		}
 
 		dataSlice = append(dataSlice, data)
@@ -1726,33 +1739,27 @@ func (r *ExportService) OrderServicePackage(d []*model.OrderServicePackage) (str
 		}
 
 		if v.PayTime != (model.LocalTime{}) {
-			t := time.Time(v.PayTime)
+			data.PayTime = time.Time(v.PayTime).Format("2006-01-02 15:04:05")
-			data.PayTime = t
 		}
 
 		if v.StartTime != (model.LocalTime{}) {
-			t := time.Time(v.StartTime)
+			data.StartTime = time.Time(v.StartTime).Format("2006-01-02 15:04:05")
-			data.StartTime = t
 		}
 
 		if v.FinishTime != (model.LocalTime{}) {
-			t := time.Time(v.FinishTime)
+			data.FinishTime = time.Time(v.FinishTime).Format("2006-01-02 15:04:05")
-			data.FinishTime = t
 		}
 
 		if v.CancelTime != (model.LocalTime{}) {
-			t := time.Time(v.CancelTime)
+			data.CancelTime = time.Time(v.CancelTime).Format("2006-01-02 15:04:05")
-			data.CancelTime = t
 		}
 
 		if v.AddFinishTime != (model.LocalTime{}) {
-			t := time.Time(v.AddFinishTime)
+			data.AddFinishTime = time.Time(v.AddFinishTime).Format("2006-01-02 15:04:05")
-			data.AddFinishTime = t
 		}
 
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
 		dataSlice = append(dataSlice, data)
@@ -1850,28 +1857,23 @@ func (r *ExportService) OrderPrescription(d []*model.OrderPrescription) (string,
 		}
 
 		if v.PharmacistVerifyTime != (model.LocalTime{}) {
-			t := time.Time(v.PharmacistVerifyTime)
+			data.PharmacistVerifyTime = time.Time(v.PharmacistVerifyTime).Format("2006-01-02 15:04:05")
-			data.PharmacistVerifyTime = t
 		}
 
 		if v.PlatformFailTime != (model.LocalTime{}) {
-			t := time.Time(v.PlatformFailTime)
+			data.PlatformFailTime = time.Time(v.PlatformFailTime).Format("2006-01-02 15:04:05")
-			data.PlatformFailTime = t
 		}
 
 		if v.DoctorCreatedTime != (model.LocalTime{}) {
-			t := time.Time(v.DoctorCreatedTime)
+			data.DoctorCreatedTime = time.Time(v.DoctorCreatedTime).Format("2006-01-02 15:04:05")
-			data.DoctorCreatedTime = t
 		}
 
 		if v.ExpiredTime != (model.LocalTime{}) {
-			t := time.Time(v.ExpiredTime)
+			data.ExpiredTime = time.Time(v.ExpiredTime).Format("2006-01-02 15:04:05")
-			data.ExpiredTime = t
 		}
 
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
 		// 处理厨房药品列表
@@ -1968,8 +1970,7 @@ func (r *ExportService) Product(d []*model.Product) (string, error) {
 		}
 
 		if v.CreatedAt != (model.LocalTime{}) {
-			t := time.Time(v.CreatedAt)
+			data.CreatedAt = time.Time(v.CreatedAt).Format("2006-01-02 15:04:05")
-			data.CreatedAt = t
 		}
 
 		dataSlice = append(dataSlice, data)

utils/export.go

@@ -5,106 +5,36 @@ import (
 	"fmt"
 	"github.com/xuri/excelize/v2"
 	"reflect"
-	"strconv"
 )
 
-// func Export(widths []int) (bool, error) {
-// 	f := excelize.NewFile()
-// 	defer func() {
-// 		_ = f.Close()
-// 	}()
-//
-// 	// 创建一个工作表
-// 	index, err := f.NewSheet("Sheet1")
-// 	if err != nil {
-// 		return false, err
-// 	}
-//
-// 	// 设置工作簿的默认工作表
-// 	f.SetActiveSheet(index)
-//
-// 	// 单元格对齐样式
-// 	alignment := &excelize.Alignment{
-// 		Horizontal: "center",
-// 		Vertical:   "center",
-// 	}
-//
-// 	// 单元格颜色填充样式
-// 	fill := excelize.Fill{
-// 		Type:    "pattern",
-// 		Pattern: 1,
-// 		Color:   []string{"#c9daf8"},
-// 		Shading: 0,
-// 	}
-//
-// 	// 第一行的左、右、下边框
-// 	border := []excelize.Border{
-// 		{
-// 			Type:  "left,right,bottom",
-// 			Color: "",
-// 			Style: 1,
-// 		},
-// 	}
-//
-// 	// 工作表样式
-// 	style, err := f.NewStyle(
-// 		&excelize.Style{
-// 			Fill:      fill,
-// 			Alignment: alignment,
-// 			Border:    border,
-// 		},
-// 	)
-// 	if err != nil {
-// 		return false, err
-// 	}
-//
-// 	// 依次设置每一列的列宽
-// 	widths = []int{18, 18, 18, 18, 18, 20, 23, 46, 18, 30, 30, 18, 18, 30, 18, 30}
-// 	for col, width := range widths {
-// 		// 获取列名
-// 		colName, err := excelize.ColumnNumberToName(col + 1)
-// 		if err != nil {
-// 			return false, err
-// 		}
-//
-// 		// 设置列宽
-// 		err = f.SetColWidth("Sheet1", colName, colName, float64(width))
-// 		if err != nil {
-// 			return false, err
-// 		}
-//
-// 		// 设置列背景颜色
-// 		err = f.SetCellStyle("Sheet1", colName+"1", colName+"1", style)
-// 		if err != nil {
-// 			return false, err
-// 		}
-// 	}
-//
-// 	// 设置行高
-// 	err = f.SetRowStyle("Sheet1", 1, 10, style)
-// 	if err != nil {
-// 		return false, err
-// 	}
-//
-// 	if err := f.SaveAs("output.xlsx"); err != nil {
-// 		return false, err
-// 	}
-//
-// 	return true, nil
-// }
-
 // HeaderCellData 表头内容
 type HeaderCellData struct {
 	Value     string // 值
 	CellType  string // 类型
 	NumberFmt string // 格式化方式
 	ColWidth  int    // 列宽
+	Colour    string // 颜色
 }
 
-func Export(header []HeaderCellData, data []interface{}) (*bytes.Buffer, error) {
+// GenerateSheet 生成表格
-	sheetName := "Sheet1"
+func GenerateSheet(header []HeaderCellData, sheetName string) (f *excelize.File, err error) {
+	// 创建工作表
+	err, f = createSheet(sheetName)
+	if err != nil {
+		return nil, err
+	}
 
-	f := excelize.NewFile()
+	// 设置表头
+	if err := setHeader(f, sheetName, header); err != nil {
+		return nil, err
+	}
+
+	return f, nil
+}
+
+// 创建工作表
+func createSheet(sheetName string) (err error, f *excelize.File) {
+	f = excelize.NewFile()
 	defer func() {
 		_ = f.Close()
 	}()
@@ -112,7 +42,7 @@ func Export(header []HeaderCellData, data []interface{}) (*bytes.Buffer, error)
 	// 创建一个工作表
 	index, err := f.NewSheet(sheetName)
 	if err != nil {
-		return nil, err
+		return err, nil
 	}
 
 	// 设置工作簿的默认工作表
@@ -121,168 +51,97 @@ func Export(header []HeaderCellData, data []interface{}) (*bytes.Buffer, error)
 	// 设置工作表默认字体
 	err = f.SetDefaultFont("宋体")
 	if err != nil {
-		return nil, err
+		return err, nil
-	}
-
-	// 统一单元格对齐样式
-	alignment := &excelize.Alignment{
-		Horizontal: "center",
-		Vertical:   "center",
 	}
 
 	// 设置行高 35-第一行
 	err = f.SetRowHeight(sheetName, 1, 35)
 	if err != nil {
-		return nil, err
+		return err, nil
 	}
 
-	// 处理工作表表头
+	return nil, f
+}
+
+// 设置表头
+func setHeader(f *excelize.File, sheetName string, header []HeaderCellData) error {
 	for c, cell := range header {
 		// 获取列名
 		colName, err := excelize.ColumnNumberToName(c + 1)
 		if err != nil {
-			return nil, err
+			return err
 		}
 
 		// 添加单元格的值
-		err = f.SetCellValue(sheetName, colName+"1", cell.Value)
+		if err := f.SetCellValue(sheetName, colName+"1", cell.Value); err != nil {
-		if err != nil {
+			return err
-			return nil, err
 		}
 
 		// 单元格颜色填充样式
-		fill := excelize.Fill{
+		var fill excelize.Fill
+		if cell.Colour != "" {
+			fill = excelize.Fill{
 				Type:    "pattern",
 				Pattern: 1,
-			Color:   []string{"#c9daf8"},
+				Color:   []string{cell.Colour},
 				Shading: 0,
 			}
+		}
 
 		// 第一行的左、右、下边框
 		border := []excelize.Border{
-			{
+			{Type: "left", Color: "#000000", Style: 1},
-				Type:  "left",
+			{Type: "right", Color: "#000000", Style: 1},
-				Color: "#000000",
+			{Type: "bottom", Color: "#000000", Style: 1},
-				Style: 1,
-			},
-			{
-				Type:  "right",
-				Color: "#000000",
-				Style: 1,
-			},
-			{
-				Type:  "bottom",
-				Color: "#000000",
-				Style: 1,
-			},
 		}
 
 		// 设置单元格值类型和格式
-		style, _ := f.NewStyle(&excelize.Style{
+		style, err := f.NewStyle(&excelize.Style{
-			Alignment: alignment, // 字体居中
+			Alignment: &excelize.Alignment{
-			Fill:      fill,      // 背景颜色
+				Horizontal: "center",
-			Border:    border,    // 边框
+				Vertical:   "center",
+			},
+			Fill:   fill,
+			Border: border,
 		})
-		err = f.SetCellStyle(sheetName, colName+"1", colName+"1", style)
+		if err != nil {
+			return err
+		}
+
+		if err := f.SetCellStyle(sheetName, colName+"1", colName+"1", style); err != nil {
+			return err
+		}
+
+		if err := f.SetColWidth(sheetName, colName, colName, float64(cell.ColWidth)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Export 导出
+func Export(header []HeaderCellData, data []interface{}) (b *bytes.Buffer, err error) {
+	sheetName := "Sheet1"
+	// 生成表格
+	f, err := GenerateSheet(header, sheetName)
 	if err != nil {
 		return nil, err
 	}
 
-		// 设置列宽
+	alignment := &excelize.Alignment{
-		err = f.SetColWidth(sheetName, colName, colName, float64(cell.ColWidth))
+		Horizontal: "center",
+		Vertical:   "center",
+	}
+
+	row := 1
+	for _, item := range data {
+		var err error
+		row, err = fillDataWithMerge(f, sheetName, header, item, row, alignment)
 		if err != nil {
 			return nil, err
 		}
 	}
 
-	// 设置单元格格式
-	row := len(data)
-	for i, cell := range header {
-		// 获取列名
-		colName, err := excelize.ColumnNumberToName(i + 1)
-		if err != nil {
-			return nil, err
-		}
-
-		// 字体居中
-		style := &excelize.Style{}
-		style = &excelize.Style{
-			Alignment: alignment,
-		}
-
-		if cell.CellType == "float" {
-			style.NumFmt = 2
-			customNumFmt := "0.000"
-			style.CustomNumFmt = &customNumFmt
-		}
-
-		if cell.CellType == "date" {
-			style.NumFmt = 22
-			customNumFmt := "yyyy-mm-dd hh:mm:ss"
-			style.CustomNumFmt = &customNumFmt
-		}
-
-		newStyle, _ := f.NewStyle(style)
-		err = f.SetCellStyle(sheetName, colName+"2", colName+strconv.Itoa(row), newStyle)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// 填充数据
-	for r, rowData := range data {
-		rv := reflect.ValueOf(rowData)
-		for c := 0; c < rv.NumField(); c++ {
-			cellValue := rv.Field(c).Interface()
-			// 获取列名
-			colName, err := excelize.ColumnNumberToName(c + 1)
-			if err != nil {
-				return nil, err
-			}
-
-			axis := colName + fmt.Sprintf("%d", r+2)
-
-			// 设置单元格值
-			err = f.SetCellValue(sheetName, axis, cellValue)
-			if err != nil {
-				return nil, err
-			}
-
-			// 设置单元格值类型
-			cellType := header[c].CellType
-
-			// 字体居中
-			style := &excelize.Style{}
-			style = &excelize.Style{
-				Alignment: alignment,
-			}
-
-			if cellType == "float" {
-				style.NumFmt = 2
-				customNumFmt := "0.000"
-				style.CustomNumFmt = &customNumFmt
-			}
-
-			if cellType == "date" {
-				style.NumFmt = 22
-				customNumFmt := "yyyy-mm-dd hh:mm:ss"
-				style.CustomNumFmt = &customNumFmt
-			}
-
-			newStyle, _ := f.NewStyle(style)
-			err = f.SetCellStyle(sheetName, axis, axis, newStyle)
-			if err != nil {
-				return nil, err
-			}
-
-			// 设置行高 35-第一行
-			err = f.SetRowHeight(sheetName, r+2, 35)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
 	buffer, err := f.WriteToBuffer()
 	if err != nil {
 		return nil, err
@@ -291,8 +150,224 @@ func Export(header []HeaderCellData, data []interface{}) (*bytes.Buffer, error)
 	return buffer, nil
 
 	// 保存文件
-	// if err := f.SaveAs("output.xlsx"); err != nil {
+	//if err := f.SaveAs("output.xlsx"); err != nil {
 	//	return nil, err
-	// }
+	//}
-	// return nil, errors.New("已导出文件")
+	//return nil, errors.New("已导出文件")
+}
+
+// 填充数据
+func fillDataWithMerge(f *excelize.File, sheetName string, header []HeaderCellData, data interface{}, row int, alignment *excelize.Alignment) (int, error) {
+	v := reflect.ValueOf(data)
+
+	// 判断是否是结构体或指向结构体的指针
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+	if v.Kind() != reflect.Struct {
+		panic("data must be a struct or a pointer to struct")
+	}
+
+	var axis string // 坐标值
+
+	colOffset := 0             // 列偏移量
+	mergeNum := 0              // 合并单元格数量。默认为0，每次+1，当存在切片时启用
+	var mergeNumSlice []string // 需合并单元格列名。默认为空，当存在切片时启用["A","B"]
+	filedNumSlice := 1         // 切片数量，默认为1,此数量为其余需合并的数量
+	for i := 0; i < v.NumField(); i++ {
+		field := v.Field(i)
+
+		// 获取字段类型
+		valueType := field.Kind()
+		if valueType != reflect.Slice {
+			// 获取字段值
+			cellValue := field.Interface()
+
+			// 获取列名
+			colName, err := excelize.ColumnNumberToName(colOffset + 1)
+			if err != nil {
+				return 0, err
+			}
+
+			// 获取坐标，+1表示去除header行
+			axis = colName + fmt.Sprintf("%d", row+1)
+
+			// 填入值
+			err = f.SetCellValue(sheetName, axis, cellValue)
+			if err != nil {
+				return 0, err
+			}
+
+			// 设置单元格样式
+			err = setCellStyle(f, sheetName, axis, header[i], alignment)
+			if err != nil {
+				return 0, err
+			}
+
+			// 设置行高 35-第一行
+			err = f.SetRowHeight(sheetName, row+1, 35)
+			if err != nil {
+				return 0, err
+			}
+
+			// 合并单元格数量
+			mergeNum = mergeNum + 1
+			mergeNumSlice = append(mergeNumSlice, colName)
+		} else {
+			var sliceFieldNum int // 切片字段数量
+
+			// 最大切片数量，此数量为其余需合并的数量
+			if filedNumSlice < field.Len() {
+				filedNumSlice = field.Len()
+			}
+
+			for j := 0; j < field.Len(); j++ {
+				item := field.Index(j).Interface()
+				v1 := reflect.ValueOf(item)
+
+				for i2 := 0; i2 < field.Index(j).NumField(); i2++ {
+					// 获取字段值
+					cellValue := v1.Field(i2).Interface()
+
+					// 获取列名
+					colName, err := excelize.ColumnNumberToName(i + i2 + 1)
+					if err != nil {
+						return 0, err
+					}
+
+					// 获取坐标，+1表示去除header行
+					axis = colName + fmt.Sprintf("%d", row+j+1)
+
+					// 填入值
+					err = f.SetCellValue(sheetName, axis, cellValue)
+					if err != nil {
+						return 0, err
+					}
+
+					// 设置单元格样式
+					err = setCellStyle(f, sheetName, axis, header[i+i2], alignment)
+					if err != nil {
+						return row, err
+					}
+
+					// 设置行高 35-第一行
+					err = f.SetRowHeight(sheetName, row+j+1, 35)
+					if err != nil {
+						return row, err
+					}
+
+					sliceFieldNum = i2
+				}
+
+			}
+
+			// 列偏移量需增加上切片字段数量
+			colOffset = colOffset + sliceFieldNum
+		}
+
+		colOffset++
+	}
+
+	// 合并单元格
+	if filedNumSlice > 1 {
+		for _, s := range mergeNumSlice {
+			// 设置单元格样式
+			for i := 0; i < filedNumSlice; i++ {
+				axis = s + fmt.Sprintf("%d", row+i+1)
+				err := setCellStyle(f, sheetName, axis, header[row+i], alignment)
+				if err != nil {
+					return row, err
+				}
+			}
+
+			startCell := s + fmt.Sprintf("%d", row+1)
+			endCell := s + fmt.Sprintf("%d", row+filedNumSlice)
+			err := f.MergeCell(sheetName, startCell, endCell)
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	// 行数 = 切片数量，如不存在切片filedNumSlice默认为1
+	row = row + filedNumSlice
+
+	// 返回当前处理到的行数
+	return row, nil
+}
+
+// 设置单元格样式
+func setCellStyle(f *excelize.File, sheetName, axis string, header HeaderCellData, alignment *excelize.Alignment) error {
+	// 获取现有样式id
+	styleID, err := f.GetCellStyle(sheetName, axis)
+	if err != nil {
+		return err
+	}
+
+	// 处理样式问题
+	var style *excelize.Style
+	if styleID == 0 {
+		// 新样式
+		style = &excelize.Style{
+			Alignment: alignment,
+		}
+	} else {
+		// 存在现有样式，直接获取
+		style, err = f.GetStyle(styleID)
+		if err != nil {
+			return err
+		}
+	}
+
+	if header.CellType == "float" {
+		style.NumFmt = 2
+		customNumFmt := "0.000"
+		style.CustomNumFmt = &customNumFmt
+	}
+
+	if header.CellType == "date" {
+		style.NumFmt = 22
+		customNumFmt := "yyyy-mm-dd hh:mm:ss"
+		style.CustomNumFmt = &customNumFmt
+	}
+
+	// 颜色-可用，但是目前无需使用
+	if header.Colour != "" {
+		// 单元格颜色
+		//fill := excelize.Fill{
+		//	Type:    "pattern",
+		//	Pattern: 1,
+		//	Color:   []string{header.Colour},
+		//	Shading: 0,
+		//}
+		//
+		//style.Fill = fill
+		//
+		//// 字体颜色
+		//font := &excelize.Font{
+		//	Color: header.Colour,
+		//}
+		//
+		//style.Font = font
+	}
+
+	// 边框
+	border := []excelize.Border{
+		{Type: "left", Color: "#000000", Style: 1},
+		{Type: "right", Color: "#000000", Style: 1},
+		{Type: "bottom", Color: "#000000", Style: 1},
+	}
+
+	style.Border = border
+
+	newStyle, err := f.NewStyle(style)
+	if err != nil {
+		return err
+	}
+
+	if err := f.SetCellStyle(sheetName, axis, axis, newStyle); err != nil {
+		return err
+	}
+
+	return nil
 }

utils/exportbak.go

@@ -0,0 +1,298 @@
+package utils
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/xuri/excelize/v2"
+	"reflect"
+	"strconv"
+)
+
+// func Export(widths []int) (bool, error) {
+// 	f := excelize.NewFile()
+// 	defer func() {
+// 		_ = f.Close()
+// 	}()
+//
+// 	// 创建一个工作表
+// 	index, err := f.NewSheet("Sheet1")
+// 	if err != nil {
+// 		return false, err
+// 	}
+//
+// 	// 设置工作簿的默认工作表
+// 	f.SetActiveSheet(index)
+//
+// 	// 单元格对齐样式
+// 	alignment := &excelize.Alignment{
+// 		Horizontal: "center",
+// 		Vertical:   "center",
+// 	}
+//
+// 	// 单元格颜色填充样式
+// 	fill := excelize.Fill{
+// 		Type:    "pattern",
+// 		Pattern: 1,
+// 		Color:   []string{"#c9daf8"},
+// 		Shading: 0,
+// 	}
+//
+// 	// 第一行的左、右、下边框
+// 	border := []excelize.Border{
+// 		{
+// 			Type:  "left,right,bottom",
+// 			Color: "",
+// 			Style: 1,
+// 		},
+// 	}
+//
+// 	// 工作表样式
+// 	style, err := f.NewStyle(
+// 		&excelize.Style{
+// 			Fill:      fill,
+// 			Alignment: alignment,
+// 			Border:    border,
+// 		},
+// 	)
+// 	if err != nil {
+// 		return false, err
+// 	}
+//
+// 	// 依次设置每一列的列宽
+// 	widths = []int{18, 18, 18, 18, 18, 20, 23, 46, 18, 30, 30, 18, 18, 30, 18, 30}
+// 	for col, width := range widths {
+// 		// 获取列名
+// 		colName, err := excelize.ColumnNumberToName(col + 1)
+// 		if err != nil {
+// 			return false, err
+// 		}
+//
+// 		// 设置列宽
+// 		err = f.SetColWidth("Sheet1", colName, colName, float64(width))
+// 		if err != nil {
+// 			return false, err
+// 		}
+//
+// 		// 设置列背景颜色
+// 		err = f.SetCellStyle("Sheet1", colName+"1", colName+"1", style)
+// 		if err != nil {
+// 			return false, err
+// 		}
+// 	}
+//
+// 	// 设置行高
+// 	err = f.SetRowStyle("Sheet1", 1, 10, style)
+// 	if err != nil {
+// 		return false, err
+// 	}
+//
+// 	if err := f.SaveAs("output.xlsx"); err != nil {
+// 		return false, err
+// 	}
+//
+// 	return true, nil
+// }
+
+// HeaderCellData1 表头内容
+type HeaderCellData1 struct {
+	Value     string // 值
+	CellType  string // 类型
+	NumberFmt string // 格式化方式
+	ColWidth  int    // 列宽
+}
+
+func Export2(header []HeaderCellData1, data []interface{}) (*bytes.Buffer, error) {
+	sheetName := "Sheet1"
+
+	f := excelize.NewFile()
+	defer func() {
+		_ = f.Close()
+	}()
+
+	// 创建一个工作表
+	index, err := f.NewSheet(sheetName)
+	if err != nil {
+		return nil, err
+	}
+
+	// 设置工作簿的默认工作表
+	f.SetActiveSheet(index)
+
+	// 设置工作表默认字体
+	err = f.SetDefaultFont("宋体")
+	if err != nil {
+		return nil, err
+	}
+
+	// 统一单元格对齐样式
+	alignment := &excelize.Alignment{
+		Horizontal: "center",
+		Vertical:   "center",
+	}
+
+	// 设置行高 35-第一行
+	err = f.SetRowHeight(sheetName, 1, 35)
+	if err != nil {
+		return nil, err
+	}
+
+	// 处理工作表表头
+	for c, cell := range header {
+		// 获取列名
+		colName, err := excelize.ColumnNumberToName(c + 1)
+		if err != nil {
+			return nil, err
+		}
+
+		// 添加单元格的值
+		err = f.SetCellValue(sheetName, colName+"1", cell.Value)
+		if err != nil {
+			return nil, err
+		}
+
+		// 单元格颜色填充样式
+		fill := excelize.Fill{
+			Type:    "pattern",
+			Pattern: 1,
+			Color:   []string{"#c9daf8"},
+			Shading: 0,
+		}
+
+		// 第一行的左、右、下边框
+		border := []excelize.Border{
+			{
+				Type:  "left",
+				Color: "#000000",
+				Style: 1,
+			},
+			{
+				Type:  "right",
+				Color: "#000000",
+				Style: 1,
+			},
+			{
+				Type:  "bottom",
+				Color: "#000000",
+				Style: 1,
+			},
+		}
+
+		// 设置单元格值类型和格式
+		style, _ := f.NewStyle(&excelize.Style{
+			Alignment: alignment, // 字体居中
+			Fill:      fill,      // 背景颜色
+			Border:    border,    // 边框
+		})
+		err = f.SetCellStyle(sheetName, colName+"1", colName+"1", style)
+		if err != nil {
+			return nil, err
+		}
+
+		// 设置列宽
+		err = f.SetColWidth(sheetName, colName, colName, float64(cell.ColWidth))
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// 设置单元格格式
+	row := len(data)
+	for i, cell := range header {
+		// 获取列名
+		colName, err := excelize.ColumnNumberToName(i + 1)
+		if err != nil {
+			return nil, err
+		}
+
+		// 字体居中
+		style := &excelize.Style{}
+		style = &excelize.Style{
+			Alignment: alignment,
+		}
+
+		if cell.CellType == "float" {
+			style.NumFmt = 2
+			customNumFmt := "0.000"
+			style.CustomNumFmt = &customNumFmt
+		}
+
+		if cell.CellType == "date" {
+			style.NumFmt = 22
+			customNumFmt := "yyyy-mm-dd hh:mm:ss"
+			style.CustomNumFmt = &customNumFmt
+		}
+
+		newStyle, _ := f.NewStyle(style)
+		err = f.SetCellStyle(sheetName, colName+"2", colName+strconv.Itoa(row), newStyle)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// 填充数据
+	for r, rowData := range data {
+		rv := reflect.ValueOf(rowData)
+		for c := 0; c < rv.NumField(); c++ {
+			cellValue := rv.Field(c).Interface()
+			// 获取列名
+			colName, err := excelize.ColumnNumberToName(c + 1)
+			if err != nil {
+				return nil, err
+			}
+
+			axis := colName + fmt.Sprintf("%d", r+2)
+
+			// 设置单元格值
+			err = f.SetCellValue(sheetName, axis, cellValue)
+			if err != nil {
+				return nil, err
+			}
+
+			// 设置单元格值类型
+			cellType := header[c].CellType
+
+			// 字体居中
+			style := &excelize.Style{}
+			style = &excelize.Style{
+				Alignment: alignment,
+			}
+
+			if cellType == "float" {
+				style.NumFmt = 2
+				customNumFmt := "0.000"
+				style.CustomNumFmt = &customNumFmt
+			}
+
+			if cellType == "date" {
+				style.NumFmt = 22
+				customNumFmt := "yyyy-mm-dd hh:mm:ss"
+				style.CustomNumFmt = &customNumFmt
+			}
+
+			newStyle, _ := f.NewStyle(style)
+			err = f.SetCellStyle(sheetName, axis, axis, newStyle)
+			if err != nil {
+				return nil, err
+			}
+
+			// 设置行高 35-第一行
+			err = f.SetRowHeight(sheetName, r+2, 35)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	buffer, err := f.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+
+	return buffer, nil
+
+	// 保存文件
+	// if err := f.SaveAs("output.xlsx"); err != nil {
+	// 	return nil, err
+	// }
+	// return nil, errors.New("已导出文件")
+}