feat: add dict update and delete

controller/dicts.go

@@ -6,7 +6,6 @@ import (
 	"woord-core-service/model"
 
 	"github.com/gin-gonic/gin"
-	"gorm.io/gorm"
 )
 
 type ListDictsResponse struct {
@@ -16,9 +15,7 @@ type ListDictsResponse struct {
 
 // 列出所有词库
 func ListDicts(c *gin.Context) {
-	dicts, err := model.ListDicts(&model.Dict{
-		UserID: c.MustGet(AuthUserKey).(uint),
-	})
+	dicts, err := model.ListDicts(c.MustGet(AuthUserKey).(uint))
 	if err != nil {
 		respondUnknownError(c, err)
 		return
@@ -52,12 +49,7 @@ func GetDict(c *gin.Context) {
 		return
 	}
 
-	dict, err := model.GetDict(&model.Dict{
-		Model: &gorm.Model{
-			ID: request.DictID,
-		},
-		UserID: c.MustGet(AuthUserKey).(uint),
-	})
+	dict, err := model.GetDict(request.DictID, c.MustGet(AuthUserKey).(uint))
 	if err != nil {
 		if errors.Is(err, model.ErrDictNotFound) {
 			respondError(c, http.StatusNotFound, err)
@@ -67,9 +59,7 @@ func GetDict(c *gin.Context) {
 		return
 	}
 
-	words, err := model.ListWords(&model.Word{
-		DictID: request.DictID,
-	})
+	words, err := model.ListWords(request.DictID)
 	if err != nil {
 		respondUnknownError(c, err)
 		return
@@ -86,9 +76,9 @@ func GetDict(c *gin.Context) {
 
 type CreateDictRequest struct {
 	DictName     string `form:"name" binding:"required"`
-	ValueTitle   string `form:"value" binding:"required"`
-	MeaningTitle string `form:"meaning" binding:"required"`
-	ExtraTitle   string `form:"extra"`
+	ValueTitle   string `form:"valueTitle" binding:"required"`
+	MeaningTitle string `form:"meaningTitle" binding:"required"`
+	ExtraTitle   string `form:"extraTitle"`
 }
 
 // 创建词库
@@ -99,13 +89,42 @@ func CreateDict(c *gin.Context) {
 		return
 	}
 
-	dict, err := model.CreateDict(&model.Dict{
-		Name:         request.DictName,
-		ValueTitle:   request.ValueTitle,
-		MeaningTitle: request.MeaningTitle,
-		ExtraTitle:   request.ExtraTitle,
-		UserID:       c.MustGet(AuthUserKey).(uint),
-	})
+	dict, err := model.CreateDict(request.DictName, request.ValueTitle, request.MeaningTitle, request.ExtraTitle, c.MustGet(AuthUserKey).(uint))
+	if err != nil {
+		respondUnknownError(c, err)
+		return
+	}
+
+	respondOK(c, dict)
+}
+
+type UpdateDictRequest struct {
+	DictID       uint   `form:"id" binding:"required"`
+	DictName     string `form:"name" binding:"required"`
+	ValueTitle   string `form:"valueTitle" binding:"required"`
+	MeaningTitle string `form:"meaningTitle" binding:"required"`
+	ExtraTitle   string `form:"extraTitle"`
+}
+
+// 更新词库
+func UpdateDict(c *gin.Context) {
+	var request UpdateDictRequest
+	if err := c.ShouldBind(&request); err != nil {
+		respondError(c, http.StatusBadRequest, err)
+		return
+	}
+
+	_, err := model.GetDict(request.DictID, c.MustGet(AuthUserKey).(uint))
+	if err != nil {
+		if errors.Is(err, model.ErrDictNotFound) {
+			respondError(c, http.StatusNotFound, err)
+		} else {
+			respondUnknownError(c, err)
+		}
+		return
+	}
+
+	dict, err := model.UpdateDict(request.DictID, request.DictName, request.ValueTitle, request.MeaningTitle, request.ExtraTitle)
 	if err != nil {
 		respondUnknownError(c, err)
 		return
@@ -113,3 +132,34 @@ func CreateDict(c *gin.Context) {
 
 	respondOK(c, dict)
 }
+
+type DeleteDictRequest struct {
+	DictID uint `form:"id" binding:"required"`
+}
+
+// 删除词库
+func DeleteDict(c *gin.Context) {
+	var request DeleteDictRequest
+	if err := c.ShouldBind(&request); err != nil {
+		respondError(c, http.StatusBadRequest, err)
+		return
+	}
+
+	_, err := model.GetDict(request.DictID, c.MustGet(AuthUserKey).(uint))
+	if err != nil {
+		if errors.Is(err, model.ErrDictNotFound) {
+			respondError(c, http.StatusNotFound, err)
+		} else {
+			respondUnknownError(c, err)
+		}
+		return
+	}
+
+	err = model.DeleteDict(request.DictID)
+	if err != nil {
+		respondUnknownError(c, err)
+		return
+	}
+
+	respondOK(c, nil)
+}

controller/users.go

@@ -7,7 +7,6 @@ import (
 	"woord-core-service/model"
 
 	"github.com/gin-gonic/gin"
-	"gorm.io/gorm"
 )
 
 type RegisterRequest struct {
@@ -23,10 +22,7 @@ func Register(c *gin.Context) {
 		return
 	}
 
-	user, err := model.CreateUser(&model.User{
-		Name:     request.UserName,
-		Password: request.Password,
-	})
+	user, err := model.CreateUser(request.UserName, request.Password)
 	if err != nil {
 		if errors.Is(err, model.ErrUserNameAlreadyExists) {
 			respondError(c, http.StatusConflict, err)
@@ -52,10 +48,7 @@ func Login(c *gin.Context) {
 		return
 	}
 
-	user, err := model.AuthenticateUser(&model.User{
-		Name:     request.UserName,
-		Password: request.Password,
-	})
+	user, err := model.AuthenticateUser(request.UserName, request.Password)
 	if err != nil {
 		if errors.Is(err, model.ErrWrongUserNameOrPassword) {
 			respondError(c, http.StatusUnauthorized, err)
@@ -78,11 +71,7 @@ func Login(c *gin.Context) {
 
 // 获取当前用户
 func GetCurrentUser(c *gin.Context) {
-	user, err := model.GetUser(&model.User{
-		Model: &gorm.Model{
-			ID: c.MustGet(AuthUserKey).(uint),
-		},
-	})
+	user, err := model.GetUser(c.MustGet(AuthUserKey).(uint))
 	if err != nil {
 		if errors.Is(err, model.ErrUserNotFound) {
 			respondError(c, http.StatusNotFound, err)

controller/words.go

@@ -6,7 +6,6 @@ import (
 	"woord-core-service/model"
 
 	"github.com/gin-gonic/gin"
-	"gorm.io/gorm"
 )
 
 type CreateWordRequest struct {
@@ -24,12 +23,7 @@ func CreateWord(c *gin.Context) {
 		return
 	}
 
-	_, err := model.GetDict(&model.Dict{
-		Model: &gorm.Model{
-			ID: request.DictID,
-		},
-		UserID: c.MustGet(AuthUserKey).(uint),
-	})
+	_, err := model.GetDict(request.DictID, c.MustGet(AuthUserKey).(uint))
 	if err != nil {
 		if errors.Is(err, model.ErrDictNotFound) {
 			respondError(c, http.StatusNotFound, err)
@@ -39,12 +33,7 @@ func CreateWord(c *gin.Context) {
 		return
 	}
 
-	word, err := model.CreateWord(&model.Word{
-		Value:   request.Value,
-		Meaning: request.Meaning,
-		Extra:   request.Extra,
-		DictID:  request.DictID,
-	})
+	word, err := model.CreateWord(request.Value, request.Meaning, request.Extra, request.DictID)
 	if err != nil {
 		if errors.Is(err, model.ErrWordAlreadyExists) {
 			respondError(c, http.StatusConflict, err)
@@ -73,19 +62,19 @@ func UpdateWord(c *gin.Context) {
 		return
 	}
 
-	word, err := model.UpdateWord(&model.Word{
-		Model: &gorm.Model{
-			ID: request.WordID,
-		},
-		Value:   request.Value,
-		Meaning: request.Meaning,
-		Extra:   request.Extra,
-		Star:    request.Star,
-	})
+	_, err := model.GetWord(request.WordID, c.MustGet(AuthUserKey).(uint))
 	if err != nil {
 		if errors.Is(err, model.ErrWordNotFound) {
 			respondError(c, http.StatusNotFound, err)
-		} else if errors.Is(err, model.ErrWordAlreadyExists) {
+		} else {
+			respondUnknownError(c, err)
+		}
+		return
+	}
+
+	word, err := model.UpdateWord(request.WordID, request.Value, request.Meaning, request.Extra, request.Star)
+	if err != nil {
+		if errors.Is(err, model.ErrWordAlreadyExists) {
 			respondError(c, http.StatusConflict, err)
 		} else {
 			respondUnknownError(c, err)
@@ -108,11 +97,7 @@ func DeleteWord(c *gin.Context) {
 		return
 	}
 
-	err := model.DeleteWord(&model.Word{
-		Model: &gorm.Model{
-			ID: request.WordID,
-		},
-	})
+	_, err := model.GetWord(request.WordID, c.MustGet(AuthUserKey).(uint))
 	if err != nil {
 		if errors.Is(err, model.ErrWordNotFound) {
 			respondError(c, http.StatusNotFound, err)
@@ -122,5 +107,11 @@ func DeleteWord(c *gin.Context) {
 		return
 	}
 
+	err = model.DeleteWord(request.WordID)
+	if err != nil {
+		respondUnknownError(c, err)
+		return
+	}
+
 	respondOK(c, nil)
 }

main.go

@@ -48,8 +48,8 @@ func main() {
 		auth.GET("/dict/list", controller.ListDicts)
 		auth.GET("/dict/get", controller.GetDict)
 		auth.POST("/dict/create", controller.CreateDict)
-		auth.PUT("/dict/update")
-		auth.DELETE("/dict/delete")
+		auth.PUT("/dict/update", controller.UpdateDict)
+		auth.DELETE("/dict/delete", controller.DeleteDict)
 
 		auth.POST("/word/create", controller.CreateWord)
 		auth.PUT("/word/update", controller.UpdateWord)

model/dicts.go

@@ -38,25 +38,25 @@ type Dict struct {
 type DictResult struct {
 	ID           uint   `json:"id"`
 	Name         string `json:"name"`
-	ValueTitle   string `json:"value"`
-	MeaningTitle string `json:"meaning"`
-	ExtraTitle   string `json:"extra"`
+	ValueTitle   string `json:"valueTitle"`
+	MeaningTitle string `json:"meaningTitle"`
+	ExtraTitle   string `json:"extraTitle"`
 	WordCount    uint   `json:"wordCount"`
 }
 
 // 列出所有词库
-func ListDicts(dict *Dict) ([]DictResult, error) {
+func ListDicts(userID uint) ([]DictResult, error) {
 	result := []DictResult{}
-	if err := global.DB.Model(&Dict{}).Select("*, (?) AS word_count", global.DB.Model(&Word{}).Select("COUNT()").Where("dict_id = dicts.id")).Order("id desc").Find(&result, dict, "user_id").Error; err != nil {
+	if err := global.DB.Model(&Dict{}).Select("*, (?) AS word_count", global.DB.Model(&Word{}).Select("COUNT()").Where("dict_id = dicts.id")).Order("id desc").Find(&result, "user_id = ?", userID).Error; err != nil {
 		return nil, err
 	}
 	return result, nil
 }
 
 // 获取词库
-func GetDict(dict *Dict) (*DictResult, error) {
+func GetDict(id, userID uint) (*DictResult, error) {
 	result := &DictResult{}
-	if err := global.DB.Model(&Dict{}).Select("*, (?) AS word_count", global.DB.Model(&Word{}).Select("COUNT()").Where("dict_id = dicts.id")).Take(result, dict, "id", "user_id").Error; err != nil {
+	if err := global.DB.Model(&Dict{}).Select("*, (?) AS word_count", global.DB.Model(&Word{}).Select("COUNT()").Where("dict_id = dicts.id")).Take(result, "id = ? AND user_id = ?", id, userID).Error; err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, ErrDictNotFound
 		}
@@ -66,7 +66,14 @@ func GetDict(dict *Dict) (*DictResult, error) {
 }
 
 // 创建词库
-func CreateDict(dict *Dict) (*DictResult, error) {
+func CreateDict(name, valueTitle, meaningTitle, extraTitle string, userID uint) (*DictResult, error) {
+	dict := &Dict{
+		Name:         name,
+		ValueTitle:   valueTitle,
+		MeaningTitle: meaningTitle,
+		ExtraTitle:   extraTitle,
+		UserID:       userID,
+	}
 	if err := global.DB.Select("name", "value_title", "meaning_title", "extra_title", "user_id").Create(dict).Error; err != nil {
 		return nil, err
 	}
@@ -78,3 +85,37 @@ func CreateDict(dict *Dict) (*DictResult, error) {
 		ExtraTitle:   dict.ExtraTitle,
 	}, nil
 }
+
+// 更新词库
+func UpdateDict(id uint, name, valueTitle, meaningTitle, extraTitle string) (*DictResult, error) {
+	count := int64(0)
+	if err := global.DB.Model(&Word{}).Where("dict_id = ?", id).Count(&count).Error; err != nil {
+		return nil, err
+	}
+
+	dict := &Dict{
+		Model: &gorm.Model{
+			ID: id,
+		},
+		Name:         name,
+		ValueTitle:   valueTitle,
+		MeaningTitle: meaningTitle,
+		ExtraTitle:   extraTitle,
+	}
+	if err := global.DB.Model(dict).Select("name", "value_title", "meaning_title", "extra_title").Updates(dict).Error; err != nil {
+		return nil, err
+	}
+	return &DictResult{
+		ID:           dict.ID,
+		Name:         dict.Name,
+		ValueTitle:   dict.ValueTitle,
+		MeaningTitle: dict.MeaningTitle,
+		ExtraTitle:   dict.ExtraTitle,
+		WordCount:    uint(count),
+	}, nil
+}
+
+// 删除词库
+func DeleteDict(id uint) error {
+	return global.DB.Delete(&Dict{}, "id = ?", id).Error
+}

model/users.go

@@ -43,9 +43,9 @@ func hashPassword(password string) string {
 }
 
 // 获取用户
-func GetUser(user *User) (*UserResult, error) {
+func GetUser(id uint) (*UserResult, error) {
 	result := &UserResult{}
-	if err := global.DB.Model(&User{}).Take(result, user, "id").Error; err != nil {
+	if err := global.DB.Model(&User{}).Take(result, "id = ?", id).Error; err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, ErrUserNotFound
 		}
@@ -55,16 +55,20 @@ func GetUser(user *User) (*UserResult, error) {
 }
 
 // 创建用户
-func CreateUser(user *User) (*UserResult, error) {
-	if err := global.DB.Model(&User{}).Take(&struct{ ID uint }{}, user, "name").Error; !errors.Is(err, gorm.ErrRecordNotFound) {
+func CreateUser(name, password string) (*UserResult, error) {
+	if err := global.DB.Model(&User{}).Take(&struct{ ID uint }{}, "name = ?", name).Error; !errors.Is(err, gorm.ErrRecordNotFound) {
 		if err != nil {
 			return nil, err
 		}
 		return nil, ErrUserNameAlreadyExists
 	}
 
-	user.Password = hashPassword(user.Password)
+	password = hashPassword(password)
 
+	user := &User{
+		Name:     name,
+		Password: password,
+	}
 	if err := global.DB.Select("name", "password").Create(user).Error; err != nil {
 		return nil, err
 	}
@@ -75,11 +79,11 @@ func CreateUser(user *User) (*UserResult, error) {
 }
 
 // 认证用户
-func AuthenticateUser(user *User) (*UserResult, error) {
-	user.Password = hashPassword(user.Password)
+func AuthenticateUser(name, password string) (*UserResult, error) {
+	password = hashPassword(password)
 
 	result := &UserResult{}
-	if err := global.DB.Model(&User{}).Take(result, user, "name", "password").Error; err != nil {
+	if err := global.DB.Model(&User{}).Take(result, "name = ? AND password = ?", name, password).Error; err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, ErrWrongUserNameOrPassword
 		}

model/words.go

@@ -42,23 +42,41 @@ type WordResult struct {
 }
 
 // 列出所有单词
-func ListWords(word *Word) ([]WordResult, error) {
+func ListWords(dictID uint) ([]WordResult, error) {
 	result := []WordResult{}
-	if err := global.DB.Model(&Word{}).Order("id desc").Find(&result, word, "dict_id").Error; err != nil {
+	if err := global.DB.Model(&Word{}).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{}).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(word *Word) (*WordResult, error) {
-	if err := global.DB.Model(&Word{}).Take(&struct{ ID uint }{}, word, "value", "dict_id").Error; !errors.Is(err, gorm.ErrRecordNotFound) {
+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
 	}
@@ -71,22 +89,23 @@ func CreateWord(word *Word) (*WordResult, error) {
 }
 
 // 更新单词
-func UpdateWord(word *Word) (*WordResult, error) {
-	dictID := &struct{ DictID uint }{}
-	if err := global.DB.Model(&Word{}).Take(dictID, word, "id").Error; err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, ErrWordNotFound
-		}
-		return nil, err
-	}
-
-	if err := global.DB.Model(&Word{}).Where("id <> ? AND value = ?", word.ID, word.Value).Take(&struct{ ID uint }{}, dictID, "dict_id").Error; !errors.Is(err, gorm.ErrRecordNotFound) {
+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
 	}
 
+	word := &Word{
+		Model: &gorm.Model{
+			ID: id,
+		},
+		Value:   value,
+		Meaning: meaning,
+		Extra:   extra,
+		Star:    star,
+	}
 	if err := global.DB.Model(word).Select("value", "meaning", "extra", "star").Updates(word).Error; err != nil {
 		return nil, err
 	}
@@ -100,13 +119,6 @@ func UpdateWord(word *Word) (*WordResult, error) {
 }
 
 // 删除单词
-func DeleteWord(word *Word) error {
-	if err := global.DB.Model(&Word{}).Take(&struct{ ID uint }{}, word, "id").Error; err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return ErrWordNotFound
-		}
-		return err
-	}
-
-	return global.DB.Delete(word).Error
+func DeleteWord(id uint) error {
+	return global.DB.Delete(&Word{}, "id = ?", id).Error
 }