432 lines
9.4 KiB
Go
432 lines
9.4 KiB
Go
package controller
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/gin-gonic/gin"
|
|
"strconv"
|
|
"vote-admin-api/api/dao"
|
|
"vote-admin-api/api/dto"
|
|
"vote-admin-api/api/model"
|
|
"vote-admin-api/api/requests"
|
|
"vote-admin-api/api/responses"
|
|
"vote-admin-api/global"
|
|
"vote-admin-api/utils"
|
|
)
|
|
|
|
type Article struct{}
|
|
|
|
// GetArticlePage 获取图文列表-分页
|
|
func (r *Article) GetArticlePage(c *gin.Context) {
|
|
articleRequest := requests.ArticleRequest{}
|
|
req := articleRequest.GetArticlePage
|
|
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
|
|
}
|
|
|
|
if req.Order != nil {
|
|
if req.Order.VoteNum != "" {
|
|
if req.Order.VoteNum != "desc" && req.Order.VoteNum != "asc" {
|
|
responses.FailWithMessage("排序字段错误", c)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// 获取数据
|
|
articleDao := dao.ArticleDao{}
|
|
articles, total, err := articleDao.GetArticlePageSearch(req, req.Page, req.PageSize)
|
|
if err != nil {
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 处理返回值
|
|
g := dto.GetArticleListDto(articles)
|
|
|
|
result := make(map[string]interface{})
|
|
result["page"] = req.Page
|
|
result["page_size"] = req.PageSize
|
|
result["total"] = total
|
|
result["data"] = g
|
|
responses.OkWithData(result, c)
|
|
}
|
|
|
|
// GetArticle 获取图文详情
|
|
func (r *Article) GetArticle(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
|
|
}
|
|
|
|
// 获取数据
|
|
articleDao := dao.ArticleDao{}
|
|
article, err := articleDao.GetArticleById(articleId)
|
|
if err != nil {
|
|
responses.FailWithMessage("文章错误", c)
|
|
return
|
|
}
|
|
|
|
// 获取作者数据
|
|
articleAuthorDao := dao.ArticleAuthorDao{}
|
|
maps := make(map[string]interface{})
|
|
maps["article_id"] = articleId
|
|
articleAuthors, err := articleAuthorDao.GetArticleAuthorPreloadList(maps)
|
|
if err != nil {
|
|
responses.FailWithMessage("文章错误", c)
|
|
return
|
|
}
|
|
|
|
// 获取排名
|
|
rank, _ := articleDao.GetArticleRank(article.ArticleId)
|
|
|
|
// 处理返回值
|
|
g := dto.GetArticleDto(article)
|
|
|
|
// 加载数据-作者
|
|
g.LoadArticleAuthor(articleAuthors)
|
|
|
|
// 加载数据-作者排名
|
|
g.LoadRank(rank)
|
|
|
|
responses.OkWithData(g, c)
|
|
}
|
|
|
|
// PutArticle 修改图文详情
|
|
func (r *Article) PutArticle(c *gin.Context) {
|
|
articleRequest := requests.ArticleRequest{}
|
|
req := articleRequest.PutArticle
|
|
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
|
|
}
|
|
|
|
if req.VoteNum != nil {
|
|
if *req.VoteNum < 0 {
|
|
responses.FailWithMessage("票数需大于0", c)
|
|
return
|
|
}
|
|
}
|
|
|
|
// 获取订单数据
|
|
articleDao := dao.ArticleDao{}
|
|
article, err := articleDao.GetArticleById(articleId)
|
|
if err != nil {
|
|
responses.FailWithMessage("图文异常", c)
|
|
return
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
fmt.Println(r)
|
|
}
|
|
}()
|
|
|
|
articleData := make(map[string]interface{})
|
|
|
|
// 文章标题
|
|
if article.ArticleTitle != req.ArticleTitle {
|
|
articleData["article_title"] = req.ArticleTitle
|
|
}
|
|
|
|
// 文章状态
|
|
if article.ArticleStatus != req.ArticleStatus {
|
|
articleData["article_status"] = req.ArticleStatus
|
|
}
|
|
|
|
// 文章内容
|
|
if article.ArticleContent != req.ArticleContent {
|
|
articleData["article_content"] = req.ArticleContent
|
|
}
|
|
|
|
// 票数
|
|
if req.VoteNum != nil {
|
|
if article.VoteNum != *req.VoteNum {
|
|
articleData["vote_num"] = *req.VoteNum
|
|
}
|
|
}
|
|
|
|
// 修改
|
|
if len(articleData) > 0 {
|
|
err = articleDao.EditArticleById(tx, articleId, articleData)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
}
|
|
|
|
// 删除作者
|
|
articleAuthorDao := dao.ArticleAuthorDao{}
|
|
maps := make(map[string]interface{})
|
|
maps["article_id"] = articleId
|
|
err = articleAuthorDao.DeleteArticleAuthor(tx, maps)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
baseHospitalDao := dao.BaseHospitalDao{}
|
|
// 新增作者
|
|
for _, author := range req.ArticleAuthor {
|
|
if author.HospitalId == "" {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("请选择作者所属医院", c)
|
|
return
|
|
}
|
|
|
|
if author.AuthorName == "" {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("请输入作者名称", c)
|
|
return
|
|
}
|
|
|
|
// 检测医院
|
|
hospitalId, err := strconv.ParseInt(author.HospitalId, 10, 64)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
baseHospital, err := baseHospitalDao.GetBaseHospitalById(hospitalId)
|
|
if err != nil || baseHospital == nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("医院错误", c)
|
|
return
|
|
}
|
|
|
|
ArticleAuthor := &model.ArticleAuthor{
|
|
ArticleId: articleId,
|
|
AuthorName: author.AuthorName,
|
|
HospitalId: hospitalId,
|
|
}
|
|
ArticleAuthor, err = articleAuthorDao.AddArticleAuthor(tx, ArticleAuthor)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
responses.Ok(c)
|
|
}
|
|
|
|
// AddArticle 新增图文详情
|
|
func (r *Article) AddArticle(c *gin.Context) {
|
|
articleRequest := requests.ArticleRequest{}
|
|
req := articleRequest.AddArticle
|
|
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.VoteNum != nil {
|
|
if *req.VoteNum < 0 {
|
|
responses.FailWithMessage("票数需大于0", c)
|
|
return
|
|
}
|
|
}
|
|
|
|
// 开始事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("操作失败", c)
|
|
return
|
|
}
|
|
}()
|
|
|
|
article := &model.Article{
|
|
ArticleTitle: req.ArticleTitle,
|
|
ArticleStatus: req.ArticleStatus,
|
|
ArticleContent: req.ArticleContent,
|
|
}
|
|
|
|
if req.VoteNum != nil {
|
|
article.VoteNum = *req.VoteNum
|
|
}
|
|
|
|
articleDao := dao.ArticleDao{}
|
|
article, err := articleDao.AddArticle(tx, article)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
// 新增作者
|
|
baseHospitalDao := dao.BaseHospitalDao{}
|
|
articleAuthorDao := dao.ArticleAuthorDao{}
|
|
for _, author := range req.ArticleAuthor {
|
|
if author.HospitalId == "" {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("请选择作者所属医院", c)
|
|
return
|
|
}
|
|
|
|
if author.AuthorName == "" {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("请输入作者名称", c)
|
|
return
|
|
}
|
|
|
|
// 检测医院
|
|
hospitalId, err := strconv.ParseInt(author.HospitalId, 10, 64)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
|
|
baseHospital, err := baseHospitalDao.GetBaseHospitalById(hospitalId)
|
|
if err != nil || baseHospital == nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage("医院错误", c)
|
|
return
|
|
}
|
|
|
|
ArticleAuthor := &model.ArticleAuthor{
|
|
ArticleId: article.ArticleId,
|
|
AuthorName: author.AuthorName,
|
|
HospitalId: hospitalId,
|
|
}
|
|
ArticleAuthor, err = articleAuthorDao.AddArticleAuthor(tx, ArticleAuthor)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
responses.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
responses.Ok(c)
|
|
}
|
|
|
|
// PutArticleStatus 操作图文状态
|
|
func (b *Article) PutArticleStatus(c *gin.Context) {
|
|
//orderSingleRequest := requests.OrderSingleRequest{}
|
|
//req := orderSingleRequest.PutOrderSingleDeleteStatus
|
|
//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
|
|
//}
|
|
//
|
|
//if req.IsDelete != 0 && req.IsDelete != 1 {
|
|
// responses.FailWithMessage("参数错误", c)
|
|
// return
|
|
//}
|
|
//
|
|
//id := c.Param("order_id")
|
|
//if id == "" {
|
|
// responses.FailWithMessage("缺少参数", c)
|
|
// return
|
|
//}
|
|
//
|
|
//// 将 id 转换为 int64 类型
|
|
//orderId, err := strconv.ParseInt(id, 10, 64)
|
|
//if err != nil {
|
|
// responses.Fail(c)
|
|
// return
|
|
//}
|
|
//
|
|
//// 获取订单数据
|
|
//orderSingleDao := dao.OrderSingleDao{}
|
|
//orderSingle, err := orderSingleDao.GetOrderSingleById(orderId)
|
|
//if err != nil {
|
|
// responses.FailWithMessage("订单异常", c)
|
|
// return
|
|
//}
|
|
//
|
|
//// 检测订单状态
|
|
//if orderSingle.OrderStatus == 2 {
|
|
// responses.FailWithMessage("订单不允许删除", c)
|
|
// return
|
|
//}
|
|
//
|
|
//// 检测订单删除状态
|
|
//if orderSingle.IsDelete == req.IsDelete {
|
|
// responses.Ok(c)
|
|
// return
|
|
//}
|
|
//
|
|
//// 开始事务
|
|
//tx := global.Db.Begin()
|
|
//defer func() {
|
|
// if r := recover(); r != nil {
|
|
// tx.Rollback()
|
|
// }
|
|
//}()
|
|
//
|
|
//orderSingleData := make(map[string]interface{})
|
|
//orderSingleData["is_delete"] = 1
|
|
//err = orderSingleDao.EditOrderSingleById(tx, orderId, orderSingleData)
|
|
//if err != nil {
|
|
// tx.Rollback()
|
|
// responses.FailWithMessage("删除失败", c)
|
|
// return
|
|
//}
|
|
//
|
|
//tx.Commit()
|
|
responses.Ok(c)
|
|
}
|