woord-core-service/model/words.go

package model

import (
	"errors"
	"fmt"
	"woord-core-service/global"

	"gorm.io/gorm"
)

var (
	ErrWordNotFound      = fmt.Errorf("单词不存在")
	ErrWordAlreadyExists = fmt.Errorf("单词已存在")
)

// 单词
type Word struct {
	*gorm.Model

	// 单词
	Value string `gorm:"index"`

	// 词义
	Meaning string

	// 附加
	Extra string

	// 是否为易错词
	Star bool

	// 单词所有复习记录
	Memos []Memo

	// 所属词库 ID
	DictID uint
}

type WordResult struct {
	ID         uint   `json:"id"`
	Value      string `json:"value"`
	Meaning    string `json:"meaning"`
	Extra      string `json:"extra"`
	Star       bool   `json:"star"`
	MemosCount uint   `json:"memosCount"`
}

// 列出所有单词
func ListWords(dictID uint) ([]WordResult, error) {
	result := []WordResult{}
	if err := global.DB.Model(&Word{}).Select("*, (?) AS memos_count", global.DB.Model(&Memo{}).Select("COUNT()").Where("word_id = words.id")).Order("id desc").Find(&result, "dict_id = ?", dictID).Error; err != nil {
		return nil, err
	}
	return result, nil
}

// 获取单词
func GetWord(id, userID uint) (*WordResult, error) {
	result := &WordResult{}
	if err := global.DB.Model(&Word{}).Select("*, (?) AS memos_count", global.DB.Model(&Memo{}).Select("COUNT()").Where("word_id = words.id")).Take(result, "id = ? AND (?) = ?", id, global.DB.Model(&Dict{}).Select("user_id").Where("id = dict_id"), userID).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, ErrWordNotFound
		}
		return nil, err
	}
	return result, nil
}

// 创建单词
func CreateWord(value, meaning, extra string, dictID uint) (*WordResult, error) {
	if err := global.DB.Model(&Word{}).Take(&struct{ ID uint }{}, "value = ? AND dict_id = ?", value, dictID).Error; !errors.Is(err, gorm.ErrRecordNotFound) {
		if err != nil {
			return nil, err
		}
		return nil, ErrWordAlreadyExists
	}

	word := &Word{
		Value:   value,
		Meaning: meaning,
		Extra:   extra,
		DictID:  dictID,
	}
	if err := global.DB.Select("value", "meaning", "extra", "dict_id").Create(word).Error; err != nil {
		return nil, err
	}
	return &WordResult{
		ID:      word.ID,
		Value:   word.Value,
		Meaning: word.Meaning,
		Extra:   word.Extra,
	}, nil
}

// 更新单词
func UpdateWord(id uint, value, meaning, extra string, star bool) (*WordResult, error) {
	if err := global.DB.Model(&Word{}).Take(&struct{ ID uint }{}, "id <> ? AND value = ? AND dict_id = (?)", id, value, global.DB.Model(&Word{}).Select("dict_id").Where("id = ?", id)).Error; !errors.Is(err, gorm.ErrRecordNotFound) {
		if err != nil {
			return nil, err
		}
		return nil, ErrWordAlreadyExists
	}

	count := int64(0)
	if err := global.DB.Model(&Memo{}).Where("word_id = ?", id).Count(&count).Error; err != nil {
		return nil, err
	}

	word := &Word{
		Value:   value,
		Meaning: meaning,
		Extra:   extra,
		Star:    star,
	}
	if err := global.DB.Where("id = ?", id).Select("value", "meaning", "extra", "star").Updates(word).Error; err != nil {
		return nil, err
	}
	return &WordResult{
		ID:         word.ID,
		Value:      word.Value,
		Meaning:    word.Meaning,
		Extra:      word.Extra,
		Star:       word.Star,
		MemosCount: uint(count),
	}, nil
}

// 删除单词
func DeleteWord(id uint) error {
	return global.DB.Delete(&Word{}, "id = ?", id).Error
}