gdxz/hospital-admin-api
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'dev'

Browse Source
This commit is contained in:
wucongxing8150 2024-11-08 08:46:03 +08:00
commit 4e34962e21
31 changed files with 3450 additions and 717 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

463
api/controller/ArticleScience.go Normal file
View File

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

228
api/controller/ArticleScienceSource.go Normal file
View File

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

232
api/controller/BasicArticleClass.go Normal file
View File

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

6
api/controller/area.go
View File

@ -15,7 +15,7 @@ import (
type Area struct{} type Area struct{}
// GetAreaList 获取地区列表 // GetAreaList 获取地区列表
func (b *Area) GetAreaList(c *gin.Context) { func (r *Area) GetAreaList(c *gin.Context) {
areaRequest := requests.AreaRequest{} areaRequest := requests.AreaRequest{}
req := areaRequest.GetAreaList req := areaRequest.GetAreaList
if err := c.ShouldBind(&req); err != nil { 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 新增地区 // AddArea 新增地区

7
api/controller/base.go
View File

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

3
api/controller/basic.go
View File

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

4
api/controller/diseaseClassExpertise.go
View File

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

218
api/dao/ArticleScience.go Normal file
View File

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

158
api/dao/ArticleScienceClass.go Normal file
View File

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

213
api/dao/ArticleScienceSource.go Normal file
View File

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

213
api/dao/BasicArticleClass.go Normal file
View File

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

8
api/dao/doctorBankCard.go
View File

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

28
api/dao/orderProduct.go
View File

@ -68,6 +68,22 @@ func (r *OrderProductDao) GetOrderProductList(maps interface{}) (m []*model.Orde
return m, nil 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 获取药品订单 // GetOrderProduct 获取药品订单
func (r *OrderProductDao) GetOrderProduct(maps interface{}) (m *model.OrderProduct, err error) { func (r *OrderProductDao) GetOrderProduct(maps interface{}) (m *model.OrderProduct, err error) {
err = global.Db.Where(maps).First(&m).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") 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 { query = query.Preload("OrderPrescription", func(db *gorm.DB) *gorm.DB {
return db.Select("order_prescription_id", "prescription_code") 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") return db.Select("user_id", "user_name", "mobile")
}) })
// 药品列表
query = query.Preload("OrderProductItem")
// 药品列表-药品
query = query.Preload("OrderProductItem.Product")
// 当前搜索数据 // 当前搜索数据
if req.Type == 1 { 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 err = query.Find(&m).Error
if err != nil { if err != nil {

90
api/dto/ArticleScience.go Normal file
View File

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

49
api/dto/ArticleScienceClass.go Normal file
View File

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

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

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

49
api/dto/BasicArticleClass.go Normal file
View File

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

40
api/model/ArticleScience.go Normal file
View File

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

35
api/model/ArticleScienceClass.go Normal file
View File

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

33
api/model/ArticleScienceSource.go Normal file
View File

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

33
api/model/BasicArticleClass.go Normal file
View File

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

1
api/model/orderProductItem.go
View File

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

71
api/requests/ArticleScience.go Normal file
View File

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

38
api/requests/ArticleScienceSource.go Normal file
View File

@ -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:"来源图片"` // 来源图片
}

43
api/requests/BasicArticleClass.go Normal file
View File

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

2
api/requests/admin.go
View File

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

180
api/router/router.go
View File

@ -127,66 +127,68 @@ func adminRouter(r *gin.Engine, api controller.Api) {
// basicRouter 基础数据-验证权限 // basicRouter 基础数据-验证权限
func basicRouter(r *gin.Engine, api controller.Api) { func basicRouter(r *gin.Engine, api controller.Api) {
// 此处为基础数据的获取数据
basicGroup := r.Group("/basic") basicGroup := r.Group("/basic")
// 科室管理-基础数据
departmentGroup := basicGroup.Group("/department")
{ {
// 自定义科室 // 科室管理-基础数据
customGroup := departmentGroup.Group("/custom") departmentGroup := basicGroup.Group("/department")
{ {
// 获取自定义科室列表 // 自定义科室
customGroup.GET("/list", api.Department.GetDepartmentCustomList) customGroup := departmentGroup.Group("/custom")
{
// 获取自定义科室列表
customGroup.GET("/list", api.Department.GetDepartmentCustomList)
}
} }
// 医院管理-基础数据
hospitalGroup := basicGroup.Group("/hospital")
{
// 获取医院列表-限制条数
hospitalGroup.GET("/list", api.Hospital.GetHospitalList)
}
// 医生专长管理-基础数据
expertiseGroup := basicGroup.Group("/expertise")
{
// 获取医生专长列表
expertiseGroup.GET("/list", api.DiseaseClassExpertise.GetExpertiseList)
// 获取医生专长列表-分页
// 医生专长详情
// 修改医生专长
// 新增医生专长
}
// 银行管理-基础数据
bankGroup := basicGroup.Group("/bank")
{
// 获取银行列表
bankGroup.GET("/list", api.Bank.GetBankList)
// 获取银行列表-分页
// 银行详情
// 修改银行
// 新增银行
}
//// 地区管理-基础数据
//areaGroup := basicGroup.Group("/area")
//{
// // 获取地区列表
// areaGroup.GET("/list", api.Basic.Area.GetAreaList)
//
// // 修改地区
//
// // 新增地区
//}
} }
// 医院管理-基础数据
hospitalGroup := basicGroup.Group("/hospital")
{
// 获取医院列表-限制条数
hospitalGroup.GET("/list", api.Hospital.GetHospitalList)
}
// 专长管理-基础数据
expertiseGroup := basicGroup.Group("/expertise")
{
// 获取专长列表
expertiseGroup.GET("/list", api.DiseaseClassExpertise.GetExpertiseList)
// 获取专长列表-分页
// 专长详情
// 修改专长
// 新增专长
}
// 银行管理-基础数据
bankGroup := basicGroup.Group("/bank")
{
// 获取银行列表
bankGroup.GET("/list", api.Bank.GetBankList)
// 获取银行列表-分页
// 银行详情
// 修改银行
// 新增银行
}
//// 地区管理-基础数据
//areaGroup := basicGroup.Group("/area")
//{
// // 获取地区列表
// areaGroup.GET("/list", api.Basic.Area.GetAreaList)
//
// // 修改地区
//
// // 新增地区
//}
} }
// privateRouter 私有路由-验证权限 // privateRouter 私有路由-验证权限
@ -820,14 +822,14 @@ func privateRouter(r *gin.Engine, api controller.Api) {
} }
} }
// 基础数据 // 基础数据管理
basicGroup := adminGroup.Group("/basic") basicGroup := adminGroup.Group("/basic")
{ {
// 地区管理 // 地区管理
areaGroup := basicGroup.Group("/area") areaGroup := basicGroup.Group("/area")
{ {
// 获取地区列表 // 获取地区列表
areaGroup.GET("", api.Area.GetAreaList) areaGroup.GET("", api.Basic.Area.GetAreaList)
// 新增地区 // 新增地区
areaGroup.POST("", api.Basic.Area.AddArea) 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) 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)
}
}
} }
} }

2
api/service/admin.go
View File

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

859
api/service/export.go
View File

File diff suppressed because it is too large Load Diff

513
utils/export.go
View File

@ -5,106 +5,36 @@ import (
"fmt" "fmt"
"github.com/xuri/excelize/v2" "github.com/xuri/excelize/v2"
"reflect" "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 表头内容 // HeaderCellData 表头内容
type HeaderCellData struct { type HeaderCellData struct {
Value string // 值 Value string // 值
CellType string // 类型 CellType string // 类型
NumberFmt string // 格式化方式 NumberFmt string // 格式化方式
ColWidth int // 列宽 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() { defer func() {
_ = f.Close() _ = f.Close()
}() }()
@ -112,7 +42,7 @@ func Export(header []HeaderCellData, data []interface{}) (*bytes.Buffer, error)
// 创建一个工作表 // 创建一个工作表
index, err := f.NewSheet(sheetName) index, err := f.NewSheet(sheetName)
if err != nil { if err != nil {
return nil, err return err, nil
} }
// 设置工作簿的默认工作表 // 设置工作簿的默认工作表
@ -121,165 +51,94 @@ func Export(header []HeaderCellData, data []interface{}) (*bytes.Buffer, error)
// 设置工作表默认字体 // 设置工作表默认字体
err = f.SetDefaultFont("宋体") err = f.SetDefaultFont("宋体")
if err != nil { if err != nil {
return nil, err return err, nil
}
// 统一单元格对齐样式
alignment := &excelize.Alignment{
Horizontal: "center",
Vertical: "center",
} }
// 设置行高 35-第一行 // 设置行高 35-第一行
err = f.SetRowHeight(sheetName, 1, 35) err = f.SetRowHeight(sheetName, 1, 35)
if err != nil { 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 { for c, cell := range header {
// 获取列名 // 获取列名
colName, err := excelize.ColumnNumberToName(c + 1) colName, err := excelize.ColumnNumberToName(c + 1)
if err != nil { 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
Type: "pattern", if cell.Colour != "" {
Pattern: 1, fill = excelize.Fill{
Color: []string{"#c9daf8"}, Type: "pattern",
Shading: 0, Pattern: 1,
Color: []string{cell.Colour},
Shading: 0,
}
} }
// 第一行的左、右、下边框 // 第一行的左、右、下边框
border := []excelize.Border{ 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 { if err != nil {
return nil, err return err
} }
// 设置列宽 if err := f.SetCellStyle(sheetName, colName+"1", colName+"1", style); err != nil {
err = f.SetColWidth(sheetName, colName, colName, float64(cell.ColWidth)) return err
if err != nil { }
return nil, err
if err := f.SetColWidth(sheetName, colName, colName, float64(cell.ColWidth)); err != nil {
return err
} }
} }
return nil
}
// 设置单元格格式 // Export 导出
row := len(data) func Export(header []HeaderCellData, data []interface{}) (b *bytes.Buffer, err error) {
for i, cell := range header { sheetName := "Sheet1"
// 获取列名 // 生成表格
colName, err := excelize.ColumnNumberToName(i + 1) f, err := GenerateSheet(header, sheetName)
if err != nil { if err != nil {
return nil, err 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
}
} }
// 填充数据 alignment := &excelize.Alignment{
for r, rowData := range data { Horizontal: "center",
rv := reflect.ValueOf(rowData) Vertical: "center",
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) row := 1
for _, item := range data {
// 设置单元格值 var err error
err = f.SetCellValue(sheetName, axis, cellValue) row, err = fillDataWithMerge(f, sheetName, header, item, row, alignment)
if err != nil { if err != nil {
return nil, err 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
}
} }
} }
@ -291,8 +150,224 @@ func Export(header []HeaderCellData, data []interface{}) (*bytes.Buffer, error)
return buffer, nil return buffer, nil
// 保存文件 // 保存文件
// if err := f.SaveAs("output.xlsx"); err != nil { //if err := f.SaveAs("output.xlsx"); err != nil {
// return nil, err // 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
} }

298
utils/exportbak.go Normal file
View File

@ -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("已导出文件")
}