Study/server/api/v1/learning/knowledge_point.go

package learning

import (
	"strconv"

	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
	"github.com/flipped-aurora/gin-vue-admin/server/model/learning"
	learningReq "github.com/flipped-aurora/gin-vue-admin/server/model/learning/request"
	"github.com/flipped-aurora/gin-vue-admin/server/service"
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

type KnowledgePointApi struct{}

// CreateKnowledgePoint 创建知识点
// @Tags KnowledgePoint
// @Summary 创建知识点
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body learningReq.KnowledgePointCreate true "创建知识点"
// @Success 200 {object} response.Response{msg=string} "创建成功"
// @Router /knowledgePoint/createKnowledgePoint [post]
func (knowledgePointApi *KnowledgePointApi) CreateKnowledgePoint(c *gin.Context) {
	var req learningReq.KnowledgePointCreate
	err := c.ShouldBindJSON(&req)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	knowledgePoint := learning.KnowledgePoint{
		ChapterId:   req.ChapterId,
		Title:       req.Title,
		Content:     req.Content,
		VideoUrl:    req.VideoUrl,
		Attachments: req.Attachments,
		Sort:        req.Sort,
		Duration:    req.Duration,
		Status:      req.Status,
	}

	err = service.ServiceGroupApp.LearningServiceGroup.KnowledgePointService.CreateKnowledgePoint(c.Request.Context(), &knowledgePoint)
	if err != nil {
		global.GVA_LOG.Error("创建失败!", zap.Error(err))
		response.FailWithMessage("创建失败", c)
		return
	}
	response.OkWithMessage("创建成功", c)
}

// DeleteKnowledgePoint 删除知识点
// @Tags KnowledgePoint
// @Summary 删除知识点
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body request.IdsReq true "批量删除知识点"
// @Success 200 {object} response.Response{msg=string} "删除成功"
// @Router /knowledgePoint/deleteKnowledgePoint [delete]
func (knowledgePointApi *KnowledgePointApi) DeleteKnowledgePoint(c *gin.Context) {
	ID := c.Query("ID")
	err := service.ServiceGroupApp.LearningServiceGroup.KnowledgePointService.DeleteKnowledgePoint(c.Request.Context(), ID)
	if err != nil {
		global.GVA_LOG.Error("删除失败!", zap.Error(err))
		response.FailWithMessage("删除失败", c)
		return
	}
	response.OkWithMessage("删除成功", c)
}

// DeleteKnowledgePointByIds 批量删除知识点
// @Tags KnowledgePoint
// @Summary 批量删除知识点
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Success 200 {object} response.Response{msg=string} "批量删除成功"
// @Router /knowledgePoint/deleteKnowledgePointByIds [delete]
func (knowledgePointApi *KnowledgePointApi) DeleteKnowledgePointByIds(c *gin.Context) {
	IDs := c.QueryArray("IDs[]")
	err := service.ServiceGroupApp.LearningServiceGroup.KnowledgePointService.DeleteKnowledgePointByIds(c.Request.Context(), IDs)
	if err != nil {
		global.GVA_LOG.Error("批量删除失败!", zap.Error(err))
		response.FailWithMessage("批量删除失败", c)
		return
	}
	response.OkWithMessage("批量删除成功", c)
}

// UpdateKnowledgePoint 更新知识点
// @Tags KnowledgePoint
// @Summary 更新知识点
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body learningReq.KnowledgePointUpdate true "更新知识点"
// @Success 200 {object} response.Response{msg=string} "更新成功"
// @Router /knowledgePoint/updateKnowledgePoint [put]
func (knowledgePointApi *KnowledgePointApi) UpdateKnowledgePoint(c *gin.Context) {
	var req learningReq.KnowledgePointUpdate
	err := c.ShouldBindJSON(&req)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	knowledgePoint := learning.KnowledgePoint{
		GVA_MODEL:   global.GVA_MODEL{ID: req.ID},
		ChapterId:   req.ChapterId,
		Title:       req.Title,
		Content:     req.Content,
		VideoUrl:    req.VideoUrl,
		Attachments: req.Attachments,
		Sort:        req.Sort,
		Duration:    req.Duration,
		Status:      req.Status,
	}

	err = service.ServiceGroupApp.LearningServiceGroup.KnowledgePointService.UpdateKnowledgePoint(c.Request.Context(), knowledgePoint)
	if err != nil {
		global.GVA_LOG.Error("更新失败!", zap.Error(err))
		response.FailWithMessage("更新失败", c)
		return
	}
	response.OkWithMessage("更新成功", c)
}

// FindKnowledgePoint 用id查询知识点
// @Tags KnowledgePoint
// @Summary 用id查询知识点
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data query learning.KnowledgePoint true "用id查询知识点"
// @Success 200 {object} response.Response{data=learning.KnowledgePoint,msg=string} "查询成功"
// @Router /knowledgePoint/findKnowledgePoint [get]
func (knowledgePointApi *KnowledgePointApi) FindKnowledgePoint(c *gin.Context) {
	ID := c.Query("ID")
	reknowledgePoint, err := service.ServiceGroupApp.LearningServiceGroup.KnowledgePointService.GetKnowledgePoint(c.Request.Context(), ID)
	if err != nil {
		global.GVA_LOG.Error("查询失败!", zap.Error(err))
		response.FailWithMessage("查询失败", c)
		return
	}
	response.OkWithData(reknowledgePoint, c)
}

// GetKnowledgePointList 分页获取知识点列表
// @Tags KnowledgePoint
// @Summary 分页获取知识点列表
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data query learningReq.KnowledgePointSearch true "分页获取知识点列表"
// @Success 200 {object} response.Response{data=response.PageResult,msg=string} "获取成功"
// @Router /knowledgePoint/getKnowledgePointList [get]
func (knowledgePointApi *KnowledgePointApi) GetKnowledgePointList(c *gin.Context) {
	var pageInfo learningReq.KnowledgePointSearch
	err := c.ShouldBindQuery(&pageInfo)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	list, total, err := service.ServiceGroupApp.LearningServiceGroup.KnowledgePointService.GetKnowledgePointInfoList(c.Request.Context(), pageInfo)
	if err != nil {
		global.GVA_LOG.Error("获取失败!", zap.Error(err))
		response.FailWithMessage("获取失败", c)
		return
	}
	response.OkWithDetailed(response.PageResult{
		List:     list,
		Total:    total,
		Page:     pageInfo.Page,
		PageSize: pageInfo.PageSize,
	}, "获取成功", c)
}

// GetKnowledgePointsByChapter 根据章节获取知识点列表
// @Tags KnowledgePoint
// @Summary 根据章节获取知识点列表
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param chapterId query uint true "章节ID"
// @Success 200 {object} response.Response{data=[]learning.KnowledgePoint,msg=string} "获取成功"
// @Router /knowledgePoint/getKnowledgePointsByChapter [get]
func (knowledgePointApi *KnowledgePointApi) GetKnowledgePointsByChapter(c *gin.Context) {
	chapterIdStr := c.Query("chapterId")
	chapterId, err := strconv.ParseUint(chapterIdStr, 10, 32)
	if err != nil {
		response.FailWithMessage("章节ID格式错误", c)
		return
	}
	list, err := service.ServiceGroupApp.LearningServiceGroup.KnowledgePointService.GetKnowledgePointsByChapter(c.Request.Context(), uint(chapterId))
	if err != nil {
		global.GVA_LOG.Error("获取失败!", zap.Error(err))
		response.FailWithMessage("获取失败", c)
		return
	}
	response.OkWithData(list, c)
}