surveyService/controller/questionnaire_survey/survey.go

package questionnaire_survey

import (
	"surveyService/response"
	"surveyService/service/questionnaire_survey"
	"surveyService/service/survey_import"
	"surveyService/validators"

	"github.com/gin-gonic/gin"
)

// 修改或创建
func UpdateOrCreate(c *gin.Context) {
	var validator validators.QuestionnaireSurvey
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}
	var updateErr *response.ErrCode
	if validator.ID > 0 {
		updateErr = questionnaire_survey.Update(&validator)
	} else {
		updateErr = questionnaire_survey.Create(&validator)
	}

	if updateErr != nil {
		response.Fail(c, updateErr)
		return
	}

	response.Success(c, map[string]any{})
}

// 分页获取列表
func Paginate(c *gin.Context) {
	type Validator struct {
		Page     int    `json:"page" form:"page" binding:"omitempty,min=1"`
		PageSize int    `json:"pageSize" form:"pageSize" binding:"omitempty,min=1,max=100"`
		Key      string `json:"key" form:"key" binding:"omitempty"`
	}
	var validator Validator
	err := c.ShouldBindQuery(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	surveys, total := questionnaire_survey.Paginate(validator.Page, validator.PageSize, validator.Key)

	var list []*validators.QuestionnaireSurvey = make([]*validators.QuestionnaireSurvey, 0)
	for _, item := range surveys {
		list = append(list, questionnaire_survey.Format(item))
	}

	response.Success(c, map[string]any{
		"list":  list,
		"total": total,
	})
}

// 获取单个
func Detail(c *gin.Context) {
	type Validator struct {
		ID int64 `json:"id" form:"id" binding:"required,min=1"`
	}
	var validator Validator
	err := c.ShouldBindQuery(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	surveyDetail, findErr := questionnaire_survey.Find(validator.ID)
	if findErr != nil {
		response.Fail(c, findErr)
		return
	}

	response.Success(c, map[string]any{
		"detail": questionnaire_survey.Format(surveyDetail),
	})
}

// 获取全部列表
func List(c *gin.Context) {
	type Validator struct {
		Key string `json:"key" form:"key" binding:"omitempty"`
	}
	var validator Validator
	err := c.ShouldBindQuery(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	surveys := questionnaire_survey.List(validator.Key)

	var list []*validators.QuestionnaireSurvey = make([]*validators.QuestionnaireSurvey, 0)
	for _, item := range surveys {
		list = append(list, questionnaire_survey.Format(item))
	}

	response.Success(c, map[string]any{
		"list": list,
	})
}

// 删除
func Delete(c *gin.Context) {
	type Validator struct {
		ID int64 `json:"id" form:"id" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	deleteErr := questionnaire_survey.Delete(validator.ID)
	if deleteErr != nil {
		response.Fail(c, deleteErr)
		return
	}

	response.Success(c, map[string]any{})
}

// 修改PEG.js
func UpdatePeg(c *gin.Context) {
	type Validator struct {
		ID  int64  `json:"id" form:"id" binding:"required"`
		Peg string `json:"peg" form:"peg" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	updateErr := questionnaire_survey.UpdatePeg(validator.ID, validator.Peg)
	if updateErr != nil {
		response.Fail(c, updateErr)
		return
	}

	response.Success(c, map[string]any{})
}

// 修改备注
func UpdateRemark(c *gin.Context) {
	type Validator struct {
		ID     int64  `json:"id" form:"id" binding:"required"`
		Remark string `json:"remark" form:"remark" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	updateErr := questionnaire_survey.UpdateRemark(validator.ID, validator.Remark)
	if updateErr != nil {
		response.Fail(c, updateErr)
		return
	}

	response.Success(c, map[string]any{})
}

// 修改状态
func UpdateStatus(c *gin.Context) {
	type Validator struct {
		ID     int64 `json:"id" form:"id" binding:"required"`
		Status int   `json:"status" form:"status" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	updateErr := questionnaire_survey.UpdateStatus(validator.ID, validator.Status)
	if updateErr != nil {
		response.Fail(c, updateErr)
		return
	}

	response.Success(c, map[string]any{})
}

// 获取关联的问题库列表
func ListQuestionnaireSubject(c *gin.Context) {
	type Validator struct {
		ID int64 `json:"id" form:"id" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	subjects := questionnaire_survey.ListSubjects(validator.ID)
	var list []*validators.SurveyQuestionnaireSubject
	for _, subject := range subjects {
		list = append(list, questionnaire_survey.FormatSurveySubject(subject))
	}

	response.Success(c, map[string]any{
		"list": list,
	})
}

// 批量添加关联的问题库
func AddQuestionnaireSubject(c *gin.Context) {
	type Validator struct {
		ID         int64   `json:"id" form:"id" binding:"required"`
		SubjectIds []int64 `json:"subjectIds" form:"subjectIds" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	addErr := questionnaire_survey.AddSubject(validator.ID, validator.SubjectIds)
	if addErr != nil {
		response.Fail(c, addErr)
		return
	}

	response.Success(c, map[string]any{})
}

// 移除关联的问题库
func DeleteQuestionnaireSubject(c *gin.Context) {
	type Validator struct {
		ID         int64   `json:"id" form:"id" binding:"required"`
		SubjectIds []int64 `json:"subjectIds" form:"subjectIds" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	removeErr := questionnaire_survey.DeleteSubject(validator.ID, validator.SubjectIds)
	if removeErr != nil {
		response.Fail(c, removeErr)
		return
	}

	response.Success(c, map[string]any{})
}

// 批量修改关联问题库的排序
func UpdateQuestionnaireSubjectSort(c *gin.Context) {
	type Validator struct {
		ID         int64   `json:"id" form:"id" binding:"required"`
		SubjectIds []int64 `json:"subjectIds" form:"subjectIds" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	updateErr := questionnaire_survey.UpdateSort(validator.ID, validator.SubjectIds)
	if updateErr != nil {
		response.Fail(c, updateErr)
		return
	}

	response.Success(c, map[string]any{})
}

// 修改关联问题库的是否必填
func UpdateQuestionnaireSubjectIsRequired(c *gin.Context) {
	type Validator struct {
		ID         int64 `json:"id" form:"id" binding:"required"`
		IsRequired int   `json:"isRequired" form:"isRequired" binding:"required"`
	}
	var validator Validator
	err := c.ShouldBind(&validator)
	if err != nil {
		response.FailValidator(c, err)
		return
	}

	updateErr := questionnaire_survey.UpdateIsRequired(validator.ID, validator.IsRequired == 1)
	if updateErr != nil {
		response.Fail(c, updateErr)
		return
	}

	response.Success(c, map[string]any{})
}

func CacheList(c *gin.Context) {

	survey_import.CacheList()

	response.Success(c, map[string]any{})
}