464 lines
11 KiB
Go
464 lines
11 KiB
Go
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)
|
|
}
|