knowledge-api/api/dao/QuestionQaItem.go

package dao

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

type QuestionQaItemDao struct {
}

// GetQuestionQaItemById 获取数据-id
func (r *QuestionQaItemDao) GetQuestionQaItemById(itemId int64) (m *model.QuestionQaItem, err error) {
	err = global.Db.First(&m, itemId).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemListByQaId 获取数据-QaId
func (r *QuestionQaItemDao) GetQuestionQaItemListByQaId(qaId int64) (m []*model.QuestionQaItem, err error) {
	err = global.Db.Where("qa_id = ?", qaId).Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

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

// DeleteQuestionQaItemById 删除-Id
func (r *QuestionQaItemDao) DeleteQuestionQaItemById(tx *gorm.DB, itemId int64) error {
	if err := tx.Delete(&model.QuestionQaItem{}, itemId).Error; err != nil {
		return err
	}
	return nil
}

// DeleteQuestionQaItemByQaId 删除-QaId
func (r *QuestionQaItemDao) DeleteQuestionQaItemByQaId(tx *gorm.DB, qaId int64) error {
	if err := tx.Where("qa_id = ?", qaId).Delete(&model.QuestionQaItem{}).Error; err != nil {
		return err
	}
	return nil
}

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

// EditQuestionQaItemById 修改-id
func (r *QuestionQaItemDao) EditQuestionQaItemById(tx *gorm.DB, itemId int64, data interface{}) error {
	err := tx.Model(&model.QuestionQaItem{}).Where("item_id = ?", itemId).Updates(data).Error
	if err != nil {
		return err
	}
	return nil
}

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

// GetQuestionQaItemPreloadList 获取列表-加载全部关联
func (r *QuestionQaItemDao) GetQuestionQaItemPreloadList(maps interface{}) (m []*model.QuestionQaItem, err error) {
	err = global.Db.Preload(clause.Associations).Where(maps).Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

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

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

// GetQuestionQaItemPageSearch 获取列表-分页
func (r *QuestionQaItemDao) GetQuestionQaItemPageSearch(req requests.GetQuestionQaItemPage, page, pageSize int) (m []*model.QuestionQaItem, total int64, err error) {
	var totalRecords int64

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

	// 题目表
	query = query.Preload("Question", func(db *gorm.DB) *gorm.DB {
		return db.Select("question_id", "question_name", "question_type", "question_source", "difficulty", "first_label_id", "second_label_id")
	})

	// 题库id
	query = query.Where("qa_id = ?", req.QaId)

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

	// 是否必被选中
	if req.IsMustSelect != nil {
		query = query.Where("is_must_select = ?", req.IsMustSelect)
	}

	// 题目名称
	if req.QuestionName != "" {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("question_name LIKE ?", "%"+req.QuestionName+"%")

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 题目类型
	if req.QuestionType != nil {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("question_type = ?", req.QuestionType)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 题目来源
	if req.QuestionSource != nil {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("question_source = ?", req.QuestionSource)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 难度
	if req.Difficulty != nil {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("difficulty = ?", req.Difficulty)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 一级标签id
	if req.FirstLabelId != "" {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("first_label_id = ?", req.FirstLabelId)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 二级标签id
	if req.SecondLabelId != "" {
		subQuery := global.Db.Model(&model.Question{}).
			Select("question_id").
			Where("second_label_id = ?", req.SecondLabelId)

		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
	}

	// 排序
	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("is_must_select desc")
	query = query.Order("item_id 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
}

// GetQuestionQaItemWhereList 获取列表
func (r *QuestionQaItemDao) GetQuestionQaItemWhereList(maps interface{}) (m []*model.QuestionQaItem, err error) {
	query := global.Db.Model(&model.QuestionQaItem{})
	query = query.Where(maps)

	query = query.Preload("Question")

	// 选项
	query = query.Preload("Question.QuestionOption")

	subQuery := global.Db.Model(&model.Question{}).
		Where("kb_question.question_id  = kb_question_qa_item.question_id").
		Where("question_status = ?", 1).
		Where("is_delete = ?", 0).
		Select("1")

	query = query.Where("EXISTS (?)", subQuery)

	err = query.Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemWhereListRand 获取列表-随机
func (r *QuestionQaItemDao) GetQuestionQaItemWhereListRand(maps interface{}) (m []*model.QuestionQaItem, err error) {
	query := global.Db.Model(&model.QuestionQaItem{})
	query = query.Where(maps)

	query = query.Preload("Question")

	// 选项
	query = query.Preload("Question.QuestionOption")

	subQuery := global.Db.Model(&model.Question{}).
		Where("kb_question.question_id  = kb_question_qa_item.question_id").
		Where("question_status = ?", 1).
		Where("is_delete = ?", 0).
		Select("1")

	query = query.Where("EXISTS (?)", subQuery)

	query = query.Order("rand()")

	err = query.Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemWhereListRandLimit 获取列表-随机-限制数量
func (r *QuestionQaItemDao) GetQuestionQaItemWhereListRandLimit(maps interface{}, limit int) (m []*model.QuestionQaItem, err error) {
	query := global.Db.Model(&model.QuestionQaItem{})
	query = query.Where(maps)

	query = query.Preload("Question")

	// 选项
	query = query.Preload("Question.QuestionOption")

	subQuery := global.Db.Model(&model.Question{}).
		Where("kb_question.question_id  = kb_question_qa_item.question_id").
		Where("question_status = ?", 1).
		Where("is_delete = ?", 0).
		Select("1")

	query = query.Where("EXISTS (?)", subQuery)

	query = query.Limit(limit).Order("rand()")

	err = query.Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemNotInListRand 获取列表-随机-排除
func (r *QuestionQaItemDao) GetQuestionQaItemNotInListRand(maps interface{}, questionType int, notQuestionId []int64, limit int) (m []*model.QuestionQaItem, err error) {
	query := global.Db.Model(&model.QuestionQaItem{})
	query = query.Where(maps)

	query = query.Preload("Question")

	// 选项
	query = query.Preload("Question.QuestionOption")

	subQuery := global.Db.Model(&model.Question{}).
		Select("question_id").
		Where("question_status = ?", 1).
		Where("is_delete = ?", 0)

	// 排除选项
	if len(notQuestionId) > 0 {
		subQuery = subQuery.Where("question_id not in (?)", notQuestionId)
	}

	// 题目类型
	if questionType != 0 {
		subQuery = subQuery.Where("question_type = ?", questionType)
	}

	query = query.Where(gorm.Expr("question_id IN (?)", subQuery))

	query = query.Limit(limit).Order("rand()")

	err = query.Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemListByQuestionIdDistinctQaId 获取数据-QuestionId-去重复(QaId)
func (r *QuestionQaItemDao) GetQuestionQaItemListByQuestionIdDistinctQaId(questionId int64) (m []*model.QuestionQaItem, err error) {
	err = global.Db.Where("question_id = ?", questionId).Distinct("qa_id").Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

//subQuery := global.Db.Model(&model.Question{}).
//Where("kb_question.question_id  = kb_question_qa_item.question_id").
//Where("question_status = ?", 1).
//Where("is_delete = ?", 0).
//Select("1")
//
//query = query.Where("EXISTS (?)", subQuery)
//
//query = query.Limit(limit).Order("rand()")

// GetAllNormalQuestionQaItemWhereList 获取正常题库的明细列表
func (r *QuestionQaItemDao) GetAllNormalQuestionQaItemWhereList(maps interface{}) (m []*model.QuestionQaItem, err error) {
	query := global.Db.Model(&model.QuestionQaItem{})
	query = query.Where(maps)

	query = query.Preload("QuestionQa")

	subQuery := global.Db.Model(&model.QuestionQa{}).
		Where("qa_status = ?", 1).
		Select("qa_id")

	query = query.Where("qa_id IN (?)", subQuery)

	err = query.Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}

// GetQuestionQaItemListByQaIdDistinctQuestionId 获取数据-QuestionId-去重复(QaId)
func (r *QuestionQaItemDao) GetQuestionQaItemListByQaIdDistinctQuestionId(qaId []string) (m []*model.QuestionQaItem, err error) {
	err = global.Db.Where("qa_id IN ?", qaId).Distinct("question_id").Find(&m).Error
	if err != nil {
		return nil, err
	}
	return m, nil
}