mirror of https://gitee.com/answerdev/answer.git
545 lines
17 KiB
Go
545 lines
17 KiB
Go
package controller
|
|
|
|
import (
|
|
"github.com/answerdev/answer/internal/base/handler"
|
|
"github.com/answerdev/answer/internal/base/middleware"
|
|
"github.com/answerdev/answer/internal/base/pager"
|
|
"github.com/answerdev/answer/internal/base/reason"
|
|
"github.com/answerdev/answer/internal/base/validator"
|
|
"github.com/answerdev/answer/internal/entity"
|
|
"github.com/answerdev/answer/internal/schema"
|
|
"github.com/answerdev/answer/internal/service"
|
|
"github.com/answerdev/answer/internal/service/permission"
|
|
"github.com/answerdev/answer/internal/service/rank"
|
|
"github.com/answerdev/answer/pkg/converter"
|
|
"github.com/answerdev/answer/pkg/uid"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/segmentfault/pacman/errors"
|
|
)
|
|
|
|
// QuestionController question controller
|
|
type QuestionController struct {
|
|
questionService *service.QuestionService
|
|
rankService *rank.RankService
|
|
}
|
|
|
|
// NewQuestionController new controller
|
|
func NewQuestionController(questionService *service.QuestionService, rankService *rank.RankService) *QuestionController {
|
|
return &QuestionController{questionService: questionService, rankService: rankService}
|
|
}
|
|
|
|
// RemoveQuestion delete question
|
|
// @Summary delete question
|
|
// @Description delete question
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param data body schema.RemoveQuestionReq true "question"
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/question [delete]
|
|
func (qc *QuestionController) RemoveQuestion(ctx *gin.Context) {
|
|
req := &schema.RemoveQuestionReq{}
|
|
if handler.BindAndCheck(ctx, req) {
|
|
return
|
|
}
|
|
req.ID = uid.DeShortID(req.ID)
|
|
req.UserID = middleware.GetLoginUserIDFromContext(ctx)
|
|
req.IsAdmin = middleware.GetIsAdminFromContext(ctx)
|
|
can, err := qc.rankService.CheckOperationPermission(ctx, req.UserID, permission.QuestionDelete, req.ID)
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
if !can {
|
|
handler.HandleResponse(ctx, errors.Forbidden(reason.RankFailToMeetTheCondition), nil)
|
|
return
|
|
}
|
|
|
|
err = qc.questionService.RemoveQuestion(ctx, req)
|
|
handler.HandleResponse(ctx, err, nil)
|
|
}
|
|
|
|
// CloseQuestion Close question
|
|
// @Summary Close question
|
|
// @Description Close question
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param data body schema.CloseQuestionReq true "question"
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/question/status [put]
|
|
func (qc *QuestionController) CloseQuestion(ctx *gin.Context) {
|
|
req := &schema.CloseQuestionReq{}
|
|
if handler.BindAndCheck(ctx, req) {
|
|
return
|
|
}
|
|
req.ID = uid.DeShortID(req.ID)
|
|
req.UserID = middleware.GetLoginUserIDFromContext(ctx)
|
|
can, err := qc.rankService.CheckOperationPermission(ctx, req.UserID, permission.QuestionClose, "")
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
if !can {
|
|
handler.HandleResponse(ctx, errors.Forbidden(reason.RankFailToMeetTheCondition), nil)
|
|
return
|
|
}
|
|
|
|
err = qc.questionService.CloseQuestion(ctx, req)
|
|
handler.HandleResponse(ctx, err, nil)
|
|
}
|
|
|
|
// ReopenQuestion reopen question
|
|
// @Summary reopen question
|
|
// @Description reopen question
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param data body schema.ReopenQuestionReq true "question"
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/question/reopen [put]
|
|
func (qc *QuestionController) ReopenQuestion(ctx *gin.Context) {
|
|
req := &schema.ReopenQuestionReq{}
|
|
if handler.BindAndCheck(ctx, req) {
|
|
return
|
|
}
|
|
req.QuestionID = uid.DeShortID(req.QuestionID)
|
|
req.UserID = middleware.GetLoginUserIDFromContext(ctx)
|
|
can, err := qc.rankService.CheckOperationPermission(ctx, req.UserID, permission.QuestionReopen, "")
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
if !can {
|
|
handler.HandleResponse(ctx, errors.Forbidden(reason.RankFailToMeetTheCondition), nil)
|
|
return
|
|
}
|
|
|
|
err = qc.questionService.ReopenQuestion(ctx, req)
|
|
handler.HandleResponse(ctx, err, nil)
|
|
}
|
|
|
|
// GetQuestion get question details
|
|
// @Summary get question details
|
|
// @Description get question details
|
|
// @Tags Question
|
|
// @Security ApiKeyAuth
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id query string true "Question TagID" default(1)
|
|
// @Success 200 {string} string ""
|
|
// @Router /answer/api/v1/question/info [get]
|
|
func (qc *QuestionController) GetQuestion(ctx *gin.Context) {
|
|
id := ctx.Query("id")
|
|
id = uid.DeShortID(id)
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
req := schema.QuestionPermission{}
|
|
canList, err := qc.rankService.CheckOperationPermissions(ctx, userID, []string{
|
|
permission.QuestionEdit,
|
|
permission.QuestionDelete,
|
|
permission.QuestionClose,
|
|
permission.QuestionReopen,
|
|
})
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
objectOwner := qc.rankService.CheckOperationObjectOwner(ctx, userID, id)
|
|
|
|
req.CanEdit = canList[0] || objectOwner
|
|
req.CanDelete = canList[1]
|
|
req.CanClose = canList[2]
|
|
req.CanReopen = canList[3]
|
|
|
|
info, err := qc.questionService.GetQuestionAndAddPV(ctx, id, userID, req)
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
handler.HandleResponse(ctx, nil, info)
|
|
}
|
|
|
|
// SimilarQuestion godoc
|
|
// @Summary Search Similar Question
|
|
// @Description Search Similar Question
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param question_id query string true "question_id" default()
|
|
// @Success 200 {string} string ""
|
|
// @Router /answer/api/v1/question/similar/tag [get]
|
|
func (qc *QuestionController) SimilarQuestion(ctx *gin.Context) {
|
|
questionID := ctx.Query("question_id")
|
|
questionID = uid.DeShortID(questionID)
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
list, count, err := qc.questionService.SimilarQuestion(ctx, questionID, userID)
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
handler.HandleResponse(ctx, nil, gin.H{
|
|
"list": list,
|
|
"count": count,
|
|
})
|
|
}
|
|
|
|
// QuestionPage get questions by page
|
|
// @Summary get questions by page
|
|
// @Description get questions by page
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param data body schema.QuestionPageReq true "QuestionPageReq"
|
|
// @Success 200 {object} handler.RespBody{data=pager.PageModel{list=[]schema.QuestionPageResp}}
|
|
// @Router /answer/api/v1/question/page [get]
|
|
func (qc *QuestionController) QuestionPage(ctx *gin.Context) {
|
|
req := &schema.QuestionPageReq{}
|
|
if handler.BindAndCheck(ctx, req) {
|
|
return
|
|
}
|
|
req.LoginUserID = middleware.GetLoginUserIDFromContext(ctx)
|
|
|
|
questions, total, err := qc.questionService.GetQuestionPage(ctx, req)
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
handler.HandleResponse(ctx, nil, pager.NewPageModel(total, questions))
|
|
}
|
|
|
|
// AddQuestion add question
|
|
// @Summary add question
|
|
// @Description add question
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param data body schema.QuestionAdd true "question"
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/question [post]
|
|
func (qc *QuestionController) AddQuestion(ctx *gin.Context) {
|
|
req := &schema.QuestionAdd{}
|
|
errFields := handler.BindAndCheckReturnErr(ctx, req)
|
|
if ctx.IsAborted() {
|
|
return
|
|
}
|
|
req.UserID = middleware.GetLoginUserIDFromContext(ctx)
|
|
|
|
canList, err := qc.rankService.CheckOperationPermissions(ctx, req.UserID, []string{
|
|
permission.QuestionAdd,
|
|
permission.QuestionEdit,
|
|
permission.QuestionDelete,
|
|
permission.QuestionClose,
|
|
permission.QuestionReopen,
|
|
permission.TagUseReservedTag,
|
|
})
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
req.CanAdd = canList[0]
|
|
req.CanEdit = canList[1]
|
|
req.CanDelete = canList[2]
|
|
req.CanClose = canList[3]
|
|
req.CanReopen = canList[4]
|
|
req.CanUseReservedTag = canList[5]
|
|
if !req.CanAdd {
|
|
handler.HandleResponse(ctx, errors.Forbidden(reason.RankFailToMeetTheCondition), nil)
|
|
return
|
|
}
|
|
|
|
errList, err := qc.questionService.CheckAddQuestion(ctx, req)
|
|
if err != nil {
|
|
errlist, ok := errList.([]*validator.FormErrorField)
|
|
if ok {
|
|
errFields = append(errFields, errlist...)
|
|
}
|
|
}
|
|
|
|
if len(errFields) > 0 {
|
|
handler.HandleResponse(ctx, errors.BadRequest(reason.RequestFormatError), errFields)
|
|
return
|
|
}
|
|
|
|
resp, err := qc.questionService.AddQuestion(ctx, req)
|
|
if err != nil {
|
|
errlist, ok := resp.([]*validator.FormErrorField)
|
|
if ok {
|
|
errFields = append(errFields, errlist...)
|
|
}
|
|
}
|
|
|
|
if len(errFields) > 0 {
|
|
handler.HandleResponse(ctx, errors.BadRequest(reason.RequestFormatError), errFields)
|
|
return
|
|
}
|
|
|
|
handler.HandleResponse(ctx, err, resp)
|
|
}
|
|
|
|
// UpdateQuestion update question
|
|
// @Summary update question
|
|
// @Description update question
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param data body schema.QuestionUpdate true "question"
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/question [put]
|
|
func (qc *QuestionController) UpdateQuestion(ctx *gin.Context) {
|
|
req := &schema.QuestionUpdate{}
|
|
errFields := handler.BindAndCheckReturnErr(ctx, req)
|
|
if ctx.IsAborted() {
|
|
return
|
|
}
|
|
req.ID = uid.DeShortID(req.ID)
|
|
req.UserID = middleware.GetLoginUserIDFromContext(ctx)
|
|
|
|
canList, err := qc.rankService.CheckOperationPermissions(ctx, req.UserID, []string{
|
|
permission.QuestionEdit,
|
|
permission.QuestionDelete,
|
|
permission.QuestionEditWithoutReview,
|
|
permission.TagUseReservedTag,
|
|
})
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, nil)
|
|
return
|
|
}
|
|
|
|
objectOwner := qc.rankService.CheckOperationObjectOwner(ctx, req.UserID, req.ID)
|
|
req.CanEdit = canList[0] || objectOwner
|
|
req.CanDelete = canList[1]
|
|
req.NoNeedReview = canList[2] || objectOwner
|
|
req.CanUseReservedTag = canList[3]
|
|
if !req.CanEdit {
|
|
handler.HandleResponse(ctx, errors.Forbidden(reason.RankFailToMeetTheCondition), nil)
|
|
return
|
|
}
|
|
|
|
errlist, err := qc.questionService.UpdateQuestionCheckTags(ctx, req)
|
|
if err != nil {
|
|
errFields = append(errFields, errlist...)
|
|
}
|
|
|
|
if len(errFields) > 0 {
|
|
handler.HandleResponse(ctx, errors.BadRequest(reason.RequestFormatError), errFields)
|
|
return
|
|
}
|
|
|
|
resp, err := qc.questionService.UpdateQuestion(ctx, req)
|
|
if err != nil {
|
|
handler.HandleResponse(ctx, err, resp)
|
|
return
|
|
}
|
|
handler.HandleResponse(ctx, nil, &schema.UpdateQuestionResp{WaitForReview: !req.NoNeedReview})
|
|
}
|
|
|
|
// CloseMsgList close question msg list
|
|
// @Summary close question msg list
|
|
// @Description close question msg list
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/question/closemsglist [get]
|
|
func (qc *QuestionController) CloseMsgList(ctx *gin.Context) {
|
|
resp, err := qc.questionService.CloseMsgList(ctx, handler.GetLang(ctx))
|
|
handler.HandleResponse(ctx, err, resp)
|
|
}
|
|
|
|
// SearchByTitleLike add question title like
|
|
// @Summary add question title like
|
|
// @Description add question title like
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param title query string true "title" default(string)
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/question/similar [get]
|
|
func (qc *QuestionController) SearchByTitleLike(ctx *gin.Context) {
|
|
title := ctx.Query("title")
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
resp, err := qc.questionService.SearchByTitleLike(ctx, title, userID)
|
|
handler.HandleResponse(ctx, err, resp)
|
|
}
|
|
|
|
// UserTop godoc
|
|
// @Summary UserTop
|
|
// @Description UserTop
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param username query string true "username" default(string)
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/personal/qa/top [get]
|
|
func (qc *QuestionController) UserTop(ctx *gin.Context) {
|
|
userName := ctx.Query("username")
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
questionList, answerList, err := qc.questionService.SearchUserTopList(ctx, userName, userID)
|
|
handler.HandleResponse(ctx, err, gin.H{
|
|
"question": questionList,
|
|
"answer": answerList,
|
|
})
|
|
}
|
|
|
|
// UserList godoc
|
|
// @Summary UserList
|
|
// @Description UserList
|
|
// @Tags Question
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param username query string true "username" default(string)
|
|
// @Param order query string true "order" Enums(newest,score)
|
|
// @Param page query string true "page" default(0)
|
|
// @Param pagesize query string true "pagesize" default(20)
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /personal/question/page [get]
|
|
func (qc *QuestionController) UserList(ctx *gin.Context) {
|
|
userName := ctx.Query("username")
|
|
order := ctx.Query("order")
|
|
pageStr := ctx.Query("page")
|
|
pageSizeStr := ctx.Query("pagesize")
|
|
page := converter.StringToInt(pageStr)
|
|
pageSize := converter.StringToInt(pageSizeStr)
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
questionList, count, err := qc.questionService.SearchUserList(ctx, userName, order, page, pageSize, userID)
|
|
handler.HandleResponse(ctx, err, gin.H{
|
|
"list": questionList,
|
|
"count": count,
|
|
})
|
|
}
|
|
|
|
// UserAnswerList godoc
|
|
// @Summary UserAnswerList
|
|
// @Description UserAnswerList
|
|
// @Tags api-answer
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param username query string true "username" default(string)
|
|
// @Param order query string true "order" Enums(newest,score)
|
|
// @Param page query string true "page" default(0)
|
|
// @Param pagesize query string true "pagesize" default(20)
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/personal/answer/page [get]
|
|
func (qc *QuestionController) UserAnswerList(ctx *gin.Context) {
|
|
userName := ctx.Query("username")
|
|
order := ctx.Query("order")
|
|
pageStr := ctx.Query("page")
|
|
pageSizeStr := ctx.Query("pagesize")
|
|
page := converter.StringToInt(pageStr)
|
|
pageSize := converter.StringToInt(pageSizeStr)
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
questionList, count, err := qc.questionService.SearchUserAnswerList(ctx, userName, order, page, pageSize, userID)
|
|
handler.HandleResponse(ctx, err, gin.H{
|
|
"list": questionList,
|
|
"count": count,
|
|
})
|
|
}
|
|
|
|
// UserCollectionList godoc
|
|
// @Summary UserCollectionList
|
|
// @Description UserCollectionList
|
|
// @Tags Collection
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param page query string true "page" default(0)
|
|
// @Param pagesize query string true "pagesize" default(20)
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/api/v1/personal/collection/page [get]
|
|
func (qc *QuestionController) UserCollectionList(ctx *gin.Context) {
|
|
pageStr := ctx.Query("page")
|
|
pageSizeStr := ctx.Query("pagesize")
|
|
page := converter.StringToInt(pageStr)
|
|
pageSize := converter.StringToInt(pageSizeStr)
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
questionList, count, err := qc.questionService.SearchUserCollectionList(ctx, page, pageSize, userID)
|
|
handler.HandleResponse(ctx, err, gin.H{
|
|
"list": questionList,
|
|
"count": count,
|
|
})
|
|
}
|
|
|
|
// AdminSearchList godoc
|
|
// @Summary AdminSearchList
|
|
// @Description Status:[available,closed,deleted]
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param page query int false "page size"
|
|
// @Param page_size query int false "page size"
|
|
// @Param status query string false "user status" Enums(available, closed, deleted)
|
|
// @Param query query string false "question id or title"
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/admin/api/question/page [get]
|
|
func (qc *QuestionController) AdminSearchList(ctx *gin.Context) {
|
|
req := &schema.AdminQuestionSearch{}
|
|
if handler.BindAndCheck(ctx, req) {
|
|
return
|
|
}
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
questionList, count, err := qc.questionService.AdminSearchList(ctx, req, userID)
|
|
handler.HandleResponse(ctx, err, gin.H{
|
|
"list": questionList,
|
|
"count": count,
|
|
})
|
|
}
|
|
|
|
// AdminSearchAnswerList godoc
|
|
// @Summary AdminSearchAnswerList
|
|
// @Description Status:[available,deleted]
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param page query int false "page size"
|
|
// @Param page_size query int false "page size"
|
|
// @Param status query string false "user status" Enums(available,deleted)
|
|
// @Param query query string false "answer id or question title"
|
|
// @Param question_id query string false "question id"
|
|
// @Success 200 {object} handler.RespBody
|
|
// @Router /answer/admin/api/answer/page [get]
|
|
func (qc *QuestionController) AdminSearchAnswerList(ctx *gin.Context) {
|
|
req := &entity.AdminAnswerSearch{}
|
|
if handler.BindAndCheck(ctx, req) {
|
|
return
|
|
}
|
|
req.QuestionID = uid.DeShortID(req.QuestionID)
|
|
userID := middleware.GetLoginUserIDFromContext(ctx)
|
|
questionList, count, err := qc.questionService.AdminSearchAnswerList(ctx, req, userID)
|
|
handler.HandleResponse(ctx, err, gin.H{
|
|
"list": questionList,
|
|
"count": count,
|
|
})
|
|
}
|
|
|
|
// AdminSetQuestionStatus godoc
|
|
// @Summary AdminSetQuestionStatus
|
|
// @Description Status:[available,closed,deleted]
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security ApiKeyAuth
|
|
// @Param data body schema.AdminSetQuestionStatusRequest true "AdminSetQuestionStatusRequest"
|
|
// @Router /answer/admin/api/question/status [put]
|
|
// @Success 200 {object} handler.RespBody
|
|
func (qc *QuestionController) AdminSetQuestionStatus(ctx *gin.Context) {
|
|
req := &schema.AdminSetQuestionStatusRequest{}
|
|
if handler.BindAndCheck(ctx, req) {
|
|
return
|
|
}
|
|
req.QuestionID = uid.DeShortID(req.QuestionID)
|
|
err := qc.questionService.AdminSetQuestionStatus(ctx, req.QuestionID, req.StatusStr)
|
|
handler.HandleResponse(ctx, err, gin.H{})
|
|
}
|