knowledge-api/api/dao/Question.go

package dao

import (
	"errors"
	"gorm.io/gorm"
	"knowledge/api/model"
	"knowledge/api/requests"
	"knowledge/global"
	"strings"
	"time"
)

type QuestionDao struct {
}

// GetQuestionById 获取数据-id
func (r *QuestionDao) GetQuestionById(questionId int64) (m *model.Question, err error) {
	err = global.Db.First(&m, questionId).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// DeleteQuestion 删除
func (r *QuestionDao) DeleteQuestion(tx *gorm.DB, maps interface{}) error {
	err := tx.Where(maps).Delete(&model.Question{}).Error
	if err != nil {
		return err
	}
	return nil
}

// DeleteQuestionById 删除-id
func (r *QuestionDao) DeleteQuestionById(tx *gorm.DB, questionId int64) error {
	if err := tx.Delete(&model.Question{}, questionId).Error; err != nil {
		return err
	}
	return nil
}

// EditQuestion 修改
func (r *QuestionDao) EditQuestion(tx *gorm.DB, maps interface{}, data interface{}) error {
	err := tx.Model(&model.Question{}).Where(maps).Updates(data).Error
	if err != nil {
		return err
	}
	return nil
}

// EditQuestionById 修改-id
func (r *QuestionDao) EditQuestionById(tx *gorm.DB, questionId int64, data interface{}) error {
	err := tx.Model(&model.Question{}).Where("question_id = ?", questionId).Updates(data).Error
	if err != nil {
		return err
	}
	return nil
}

// GetQuestionList 获取列表
func (r *QuestionDao) GetQuestionList(maps interface{}) (m []*model.Question, err error) {
	err = global.Db.Where(maps).Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionCount 获取数量
func (r *QuestionDao) GetQuestionCount(maps interface{}) (total int64, err error) {
	err = global.Db.Model(&model.Question{}).Where(maps).Count(&total).Error
	if err != nil {
		return 0, err
	}
	return total, nil
}

// GetQuestionListRand 获取列表-随机
func (r *QuestionDao) GetQuestionListRand(maps interface{}, limit int) (m []*model.Question, err error) {
	err = global.Db.Where(maps).Find(&m).Order(gorm.Expr("RAND()")).Limit(limit).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// AddQuestion 新增
func (r *QuestionDao) AddQuestion(tx *gorm.DB, model *model.Question) (*model.Question, error) {
	if err := tx.Create(model).Error; err != nil {
		return nil, err
	}
	return model, nil
}

// GetQuestion 获取
func (r *QuestionDao) GetQuestion(maps interface{}) (m *model.Question, err error) {
	err = global.Db.Where(maps).First(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionPageSearch 获取题目列表-分页
func (r *QuestionDao) GetQuestionPageSearch(req requests.GetQuestionPage, page, pageSize int) (m []*model.Question, total int64, err error) {
	var totalRecords int64

	// 构建查询条件
	query := global.Db.Model(&model.Question{})

	// 一级标签
	query = query.Preload("FirstLabel", func(db *gorm.DB) *gorm.DB {
		return db.Select("label_id", "label_name")
	})

	// 二级标签
	query = query.Preload("SecondLabel", func(db *gorm.DB) *gorm.DB {
		return db.Select("label_id", "label_name")
	})

	// 主键id
	if req.QuestionId != "" {
		query = query.Where("question_id = ?", req.QuestionId)
	}

	// 题目名称
	if req.QuestionName != "" {
		query = query.Where("question_name LIKE ?", "%"+req.QuestionName+"%")
	}

	// 题目类型
	query = query.Where("question_type = ?", req.QuestionType)

	// 状态
	if req.QuestionStatus != nil {
		query = query.Where("question_status = ?", req.QuestionStatus)
	}

	// 难度
	if req.Difficulty != nil {
		query = query.Where("difficulty = ?", req.Difficulty)
	}

	// 题目来源
	query = query.Where("question_source = ?", req.QuestionSource)

	// 一级标签id
	if req.FirstLabelId != nil {
		query = query.Where("first_label_id = ?", req.FirstLabelId)
	}

	// 二级标签id
	if req.SecondLabelId != nil {
		query = query.Where("second_label_id = ?", req.SecondLabelId)
	}

	// 创建时间
	if req.CreatedAt != "" {
		createdAt := strings.Split(req.CreatedAt, "&")
		if len(createdAt) == 2 {
			startTime, _ := time.Parse("2006-01-02", createdAt[0])
			endTime, _ := time.Parse("2006-01-02", createdAt[1])

			endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)

			query = query.Where("created_at BETWEEN ? AND ?", startTime, endTime)
		}
	}

	// 修改时间
	if req.UpdatedAt != "" {
		updatedAt := strings.Split(req.UpdatedAt, "&")
		if len(updatedAt) == 2 {
			startTime, _ := time.Parse("2006-01-02", updatedAt[0])
			endTime, _ := time.Parse("2006-01-02", updatedAt[1])

			endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)

			query = query.Where("updated_at BETWEEN ? AND ?", startTime, endTime)
		}
	}

	// 排序
	if req.Order != nil {
		if req.Order.UpdatedAt != "" {
			if req.Order.UpdatedAt != "desc" && req.Order.UpdatedAt != "asc" {
				return nil, 0, errors.New("排序字段错误")
			}

			query = query.Order("updated_at " + req.Order.UpdatedAt)
		}
	}

	// 排序
	query = query.Order("created_at desc")

	// 查询总数量
	if err := query.Count(&totalRecords).Error; err != nil {
		return nil, 0, err
	}

	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
	if err != nil {
		return nil, 0, err
	}
	return m, totalRecords, nil
}