vote-admin-api/api/controller/Video.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 Video struct{}

// GetVideoPage 获取视频列表-分页
func (r *Video) GetVideoPage(c *gin.Context) {
	VideoRequest := requests.VideoRequest{}
	req := VideoRequest.GetVideoPage
	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
			}
		}
	}

	// 获取数据
	VideoDao := dao.VideoDao{}
	Videos, total, err := VideoDao.GetVideoPageSearch(req, req.Page, req.PageSize)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 处理返回值
	g := dto.GetVideoListDto(Videos)

	result := make(map[string]interface{})
	result["page"] = req.Page
	result["page_size"] = req.PageSize
	result["total"] = total
	result["data"] = g
	responses.OkWithData(result, c)
}

// GetVideo 获取视频详情
func (r *Video) GetVideo(c *gin.Context) {
	id := c.Param("video_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	videoId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取数据
	VideoDao := dao.VideoDao{}
	video, err := VideoDao.GetVideoById(videoId)
	if err != nil {
		responses.FailWithMessage("视频错误", c)
		return
	}

	// 获取作者数据
	VideoAuthorDao := dao.VideoAuthorDao{}
	maps := make(map[string]interface{})
	maps["video_id"] = videoId
	VideoAuthors, err := VideoAuthorDao.GetVideoAuthorPreloadList(maps)
	if err != nil {
		responses.FailWithMessage("视频错误", c)
		return
	}

	// 获取排名
	rank, _ := VideoDao.GetVideoRank(video.VideoId)

	// 处理返回值
	g := dto.GetVideoDto(video)

	// 加载数据-作者
	g.LoadVideoAuthor(VideoAuthors)

	// 加载数据-作者排名
	g.LoadRank(rank)

	responses.OkWithData(g, c)
}

// PutVideo 修改视频详情
func (r *Video) PutVideo(c *gin.Context) {
	VideoRequest := requests.VideoRequest{}
	req := VideoRequest.PutVideo
	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("video_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	videoId, 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
		}
	}

	// 获取订单数据
	videoDao := dao.VideoDao{}
	video, err := videoDao.GetVideoById(videoId)
	if err != nil {
		responses.FailWithMessage("视频异常", c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
			fmt.Println(r)
		}
	}()

	videoData := make(map[string]interface{})

	// 视频标题
	if video.VideoTitle != req.VideoTitle {
		videoData["video_title"] = req.VideoTitle
	}

	// 视频状态
	if video.VideoStatus != req.VideoStatus {
		videoData["video_status"] = req.VideoStatus
	}

	if req.VoteNum != nil {
		if video.VoteNum != *req.VoteNum {
			videoData["vote_num"] = *req.VoteNum
		}
	}

	// 视频编号
	if video.VideoNo != req.VideoNo {
		videoData["video_no"] = req.VideoNo
	}

	// 视频内容
	if video.VideoContent != req.VideoContent {
		videoData["video_content"] = req.VideoContent
	}

	// 修改
	if len(videoData) > 0 {
		err = videoDao.EditVideoById(tx, videoId, videoData)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}
	}

	// 删除作者
	VideoAuthorDao := dao.VideoAuthorDao{}
	maps := make(map[string]interface{})
	maps["video_id"] = videoId
	err = VideoAuthorDao.DeleteVideoAuthor(tx, maps)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage(err.Error(), c)
		return
	}

	baseHospitalDao := dao.BaseHospitalDao{}
	// 新增作者
	for _, author := range req.VideoAuthor {
		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
		}

		videoAuthor := &model.VideoAuthor{
			VideoId:    videoId,
			AuthorName: author.AuthorName,
			HospitalId: hospitalId,
		}
		videoAuthor, err = VideoAuthorDao.AddVideoAuthor(tx, videoAuthor)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}
	}

	tx.Commit()
	responses.Ok(c)
}

// AddVideo 新增视频详情
func (r *Video) AddVideo(c *gin.Context) {
	videoRequest := requests.VideoRequest{}
	req := videoRequest.AddVideo
	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
		}
	}()

	video := &model.Video{
		VideoTitle:   req.VideoTitle,
		VideoStatus:  req.VideoStatus,
		VideoNo:      req.VideoNo,
		VideoContent: req.VideoContent,
	}

	if req.VoteNum != nil {
		video.VoteNum = *req.VoteNum
	}

	videoDao := dao.VideoDao{}
	video, err := videoDao.AddVideo(tx, video)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 新增作者
	baseHospitalDao := dao.BaseHospitalDao{}
	videoAuthorDao := dao.VideoAuthorDao{}
	for _, author := range req.VideoAuthor {
		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
		}

		videoAuthor := &model.VideoAuthor{
			VideoId:    video.VideoId,
			AuthorName: author.AuthorName,
			HospitalId: hospitalId,
		}
		videoAuthor, err = videoAuthorDao.AddVideoAuthor(tx, videoAuthor)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}
	}

	tx.Commit()
	responses.Ok(c)
}