Initial commit

server/dao/db.go

@@ -0,0 +1,23 @@
+package dao
+
+import (
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"nysoure/server/model"
+)
+
+var db *gorm.DB
+
+func init() {
+	var err error
+	db, err = gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
+	if err != nil {
+		panic("failed to connect database")
+	}
+
+	_ = db.AutoMigrate(&model.User{}, &model.Resource{}, &model.Image{}, &model.Tag{}, &model.Storage{}, &model.File{}, &model.UploadingFile{}, &model.Statistic{})
+}
+
+func GetDB() *gorm.DB {
+	return db
+}

server/dao/file.go

@@ -0,0 +1,137 @@
+package dao
+
+import (
+	"errors"
+	"gorm.io/gorm"
+	"nysoure/server/model"
+	"time"
+)
+
+func CreateUploadingFile(filename string, description string, fileSize int64, blockSize int64, tempPath string, resourceID, storageID, userID uint) (*model.UploadingFile, error) {
+	blocksCount := (fileSize + blockSize - 1) / blockSize
+	uf := &model.UploadingFile{
+		Filename:         filename,
+		Description:      description,
+		TotalSize:        fileSize,
+		BlockSize:        blockSize,
+		TempPath:         tempPath,
+		Blocks:           make(model.UploadingFileBlocks, blocksCount),
+		TargetResourceID: resourceID,
+		TargetStorageID:  storageID,
+		UserID:           userID,
+	}
+	if err := db.Create(uf).Error; err != nil {
+		return nil, err
+	}
+	return uf, nil
+}
+
+func GetUploadingFile(id uint) (*model.UploadingFile, error) {
+	uf := &model.UploadingFile{}
+	if err := db.Where("id = ?", id).First(uf).Error; err != nil {
+		return nil, err
+	}
+	return uf, nil
+}
+
+func UpdateUploadingBlock(id uint, blockIndex int) error {
+	uf := &model.UploadingFile{}
+	if err := db.Where("id = ?", id).First(uf).Error; err != nil {
+		return err
+	}
+	if blockIndex < 0 || blockIndex >= uf.BlocksCount() {
+		return nil
+	}
+	uf.Blocks[blockIndex] = true
+	return db.Save(uf).Error
+}
+
+func DeleteUploadingFile(id uint) error {
+	uf := &model.UploadingFile{}
+	if err := db.Where("id = ?", id).First(uf).Error; err != nil {
+		return err
+	}
+	if err := db.Delete(uf).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetUploadingFilesOlderThan(time time.Time) ([]model.UploadingFile, error) {
+	var files []model.UploadingFile
+	if err := db.Where("updated_at < ?", time).Find(&files).Error; err != nil {
+		return nil, err
+	}
+	return files, nil
+}
+
+func CreateFile(filename string, description string, resourceID uint, storageID *uint, storageKey string, redirectUrl string) (*model.File, error) {
+	if storageID == nil && redirectUrl == "" {
+		return nil, errors.New("storageID and redirectUrl cannot be both empty")
+	}
+	f := &model.File{
+		Filename:    filename,
+		Description: description,
+		ResourceID:  resourceID,
+		StorageID:   storageID,
+		RedirectUrl: redirectUrl,
+		StorageKey:  storageKey,
+	}
+	if err := db.Create(f).Error; err != nil {
+		return nil, err
+	}
+	return f, nil
+}
+
+func GetFile(id uint) (*model.File, error) {
+	f := &model.File{}
+	if err := db.Where("id = ?", id).First(f).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, model.NewNotFoundError("file not found")
+		}
+		return nil, err
+	}
+	return f, nil
+}
+
+func GetFilesByResourceID(rID uint) ([]model.File, error) {
+	var files []model.File
+	if err := db.Where("resource_id = ?", rID).Find(&files).Error; err != nil {
+		return nil, err
+	}
+	return files, nil
+}
+
+func DeleteFile(id uint) error {
+	f := &model.File{}
+	if err := db.Where("id = ?", id).First(f).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return model.NewNotFoundError("file not found")
+		}
+		return err
+	}
+	if err := db.Delete(f).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func UpdateFile(id uint, filename string, description string) (*model.File, error) {
+	f := &model.File{}
+	if err := db.Where("id = ?", id).First(f).Error; err != nil {
+		return nil, err
+	}
+	if filename != "" {
+		f.Filename = filename
+	}
+	if description != "" {
+		f.Description = description
+	}
+	if err := db.Save(f).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, model.NewNotFoundError("file not found")
+		}
+		return nil, err
+	}
+	return f, nil
+}

server/dao/image.go

@@ -0,0 +1,56 @@
+package dao
+
+import (
+	"errors"
+	"nysoure/server/model"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+func CreateImage(name string, width, height int) (model.Image, error) {
+	// Create a new image in the database
+	i := model.Image{FileName: name, Width: width, Height: height}
+	if err := db.Create(&i).Error; err != nil {
+		return model.Image{}, err
+	}
+	return i, nil
+}
+
+func GetImageByID(id uint) (model.Image, error) {
+	// Retrieve an image by its ID from the database
+	var i model.Image
+	if err := db.First(&i, id).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return model.Image{}, model.NewNotFoundError("Image not found")
+		}
+		return model.Image{}, err
+	}
+	return i, nil
+}
+
+func DeleteImage(id uint) error {
+	// Delete an image from the database
+	i := model.Image{}
+	i.ID = id
+	if err := db.Delete(&i).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetUnusedImages() ([]model.Image, error) {
+	// Retrieve all images that are not used in any post
+	var images []model.Image
+	oneDayAgo := time.Now().Add(-24 * time.Hour)
+	if err := db.
+		Where("NOT EXISTS (SELECT 1 FROM resource_images WHERE image_id = images.id)").
+		Where("created_at < ?", oneDayAgo).
+		Find(&images).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return images, nil
+}

server/dao/resource.go

@@ -0,0 +1,169 @@
+package dao
+
+import (
+	"errors"
+	"nysoure/server/model"
+	"strings"
+
+	"gorm.io/gorm"
+)
+
+func CreateResource(r model.Resource) (model.Resource, error) {
+	// Create a new resource in the database
+	if err := db.Create(&r).Error; err != nil {
+		return model.Resource{}, err
+	}
+	return r, nil
+}
+
+func GetResourceByID(id uint) (model.Resource, error) {
+	// Retrieve a resource by its ID from the database
+	var r model.Resource
+	if err := db.Preload("User").Preload("Images").Preload("Tags").Preload("Files").First(&r, id).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return model.Resource{}, model.NewNotFoundError("Resource not found")
+		}
+		return model.Resource{}, err
+	}
+	return r, nil
+}
+
+func GetResourceList(page, pageSize int) ([]model.Resource, int, error) {
+	// Retrieve a list of resources with pagination
+	var resources []model.Resource
+	var total int64
+
+	if err := db.Model(&model.Resource{}).Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	if err := db.Offset((page - 1) * pageSize).Limit(pageSize).Preload("User").Preload("Images").Preload("Tags").Order("created_at DESC").Find(&resources).Error; err != nil {
+		return nil, 0, err
+	}
+
+	totalPages := int(total) / pageSize
+
+	return resources, int(totalPages), nil
+}
+
+func UpdateResource(r model.Resource) error {
+	// Update a resource in the database
+	if err := db.Save(&r).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func DeleteResource(id uint) error {
+	// Delete a resource from the database
+	r := model.Resource{}
+	r.ID = id
+	if err := db.Delete(&r).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return err
+	}
+	return nil
+}
+
+func Search(query string, page, pageSize int) ([]model.Resource, int, error) {
+	query = strings.TrimSpace(query)
+	keywords := strings.Split(query, " ")
+	resource, err := searchWithKeyword(keywords[0])
+	if err != nil {
+		return nil, 0, err
+	}
+	if len(keywords) > 1 {
+		for _, keyword := range keywords[1:] {
+			r := make([]model.Resource, 0, len(resource))
+			for _, res := range resource {
+				if strings.Contains(res.Title, keyword) {
+					r = append(r, res)
+					continue
+				}
+				ok := false
+				for _, at := range res.AlternativeTitles {
+					if strings.Contains(at, keyword) {
+						r = append(r, res)
+						ok = true
+						break
+					}
+				}
+				if ok {
+					continue
+				}
+				for _, tag := range res.Tags {
+					if tag.Name == keyword {
+						r = append(r, res)
+						ok = true
+						break
+					}
+				}
+			}
+			resource = r
+		}
+	}
+
+	startIndex := (page - 1) * pageSize
+	endIndex := startIndex + pageSize
+	if startIndex > len(resource) {
+		return nil, 0, nil
+	}
+	if endIndex > len(resource) {
+		endIndex = len(resource)
+	}
+	totalPages := len(resource) / pageSize
+
+	result := make([]model.Resource, 0, endIndex-startIndex)
+	for i := startIndex; i < endIndex; i++ {
+		var r model.Resource
+		if err := db.Model(&r).Preload("User").Preload("Images").Preload("Tags").Where("id=?", resource[i].ID).First(&r).Error; err != nil {
+			return nil, 0, err
+		}
+		result = append(result, r)
+	}
+
+	return result, totalPages, nil
+}
+
+func searchWithKeyword(keyword string) ([]model.Resource, error) {
+	if len(keyword) == 0 {
+		return nil, nil
+	}
+	if len([]rune(keyword)) < 20 {
+		var tag model.Tag
+		if err := db.Where("name = ?", keyword).First(&tag).Error; err != nil {
+			if !errors.Is(err, gorm.ErrRecordNotFound) {
+				return nil, err
+			}
+		} else {
+			if err := db.Model(&tag).Preload("Resources").Find(&tag).Error; err != nil {
+				return nil, err
+			}
+			return tag.Resources, nil
+		}
+	}
+	if len([]rune(keyword)) < 80 {
+		var resources []model.Resource
+		if err := db.Where("title LIKE ?", "%"+keyword+"%").Or("alternative_titles LIKE ?", "%"+keyword+"%").Find(&resources).Error; err != nil {
+			return nil, err
+		}
+		return resources, nil
+	}
+	return nil, model.NewRequestError("Keyword too long")
+}
+
+func GetResourceByTag(tagID uint, page int, pageSize int) ([]model.Resource, int, error) {
+	var tag model.Tag
+	var total int64
+
+	total = db.Model(&model.Tag{}).Where("id = ?", tagID).Association("Resources").Count()
+
+	if err := db.Model(&model.Tag{}).Where("id = ?", tagID).Preload("User").Preload("Resources", func(tx *gorm.DB) *gorm.DB {
+		return tx.Offset((page - 1) * pageSize).Limit(pageSize)
+	}).First(&tag).Error; err != nil {
+		return nil, 0, err
+	}
+
+	totalPages := int(total) / pageSize
+
+	return tag.Resources, totalPages, nil
+}

server/dao/statistic.go

@@ -0,0 +1,22 @@
+package dao
+
+import "nysoure/server/model"
+
+func SetStatistic(key string, value int64) error {
+	statistic := &model.Statistic{
+		Key:   key,
+		Value: value,
+	}
+	if err := db.Save(statistic).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetStatistic(key string) int64 {
+	statistic := &model.Statistic{}
+	if err := db.Where("key = ?", key).First(statistic).Error; err != nil {
+		return 0
+	}
+	return statistic.Value
+}

server/dao/storage.go

@@ -0,0 +1,24 @@
+package dao
+
+import "nysoure/server/model"
+
+func CreateStorage(s model.Storage) (model.Storage, error) {
+	err := db.Model(&s).Create(&s).Error
+	return s, err
+}
+
+func DeleteStorage(id uint) error {
+	return db.Model(&model.Storage{}).Where("id = ?", id).Delete(&model.Storage{}).Error
+}
+
+func GetStorages() ([]model.Storage, error) {
+	var storages []model.Storage
+	err := db.Model(&model.Storage{}).Find(&storages).Error
+	return storages, err
+}
+
+func GetStorage(id uint) (model.Storage, error) {
+	var storage model.Storage
+	err := db.Model(&model.Storage{}).Where("id = ?", id).First(&storage).Error
+	return storage, err
+}

server/dao/tag.go

@@ -0,0 +1,60 @@
+package dao
+
+import (
+	"errors"
+	"nysoure/server/model"
+
+	"gorm.io/gorm"
+)
+
+func CreateTag(tag string) (model.Tag, error) {
+	// Create a new tag in the database
+	t := model.Tag{Name: tag}
+	if err := db.Create(&t).Error; err != nil {
+		return model.Tag{}, err
+	}
+	return t, nil
+}
+
+func SearchTag(keyword string) ([]model.Tag, error) {
+	// Search for a tag by its name in the database
+	var t []model.Tag
+	if err := db.Model(&model.Tag{}).Where("name Like ?", "%"+keyword+"%").Limit(10).Find(&t).Error; err != nil {
+		return nil, err
+	}
+	return t, nil
+}
+
+func DeleteTag(id uint) error {
+	// Delete a tag from the database
+	t := model.Tag{}
+	t.ID = id
+	if err := db.Delete(&t).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return err
+	}
+	return nil
+}
+
+func GetTagByID(id uint) (model.Tag, error) {
+	// Retrieve a tag by its ID from the database
+	var t model.Tag
+	if err := db.First(&t, id).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return model.Tag{}, model.NewNotFoundError("Tag not found")
+		}
+		return model.Tag{}, err
+	}
+	return t, nil
+}
+
+func GetTagByName(name string) (model.Tag, error) {
+	// Retrieve a tag by its name from the database
+	var t model.Tag
+	if err := db.Where("name = ?", name).First(&t).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return model.Tag{}, model.NewNotFoundError("Tag not found")
+		}
+		return model.Tag{}, err
+	}
+	return t, nil
+}

server/dao/user.go

@@ -0,0 +1,120 @@
+package dao
+
+import (
+	"errors"
+	"gorm.io/gorm"
+	"nysoure/server/model"
+)
+
+func CreateUser(username string, hashedPassword []byte) (model.User, error) {
+	isEmpty, err := IsUserDataBaseEmpty()
+	if err != nil {
+		return model.User{}, err
+	}
+	user := model.User{
+		Username:     username,
+		PasswordHash: hashedPassword,
+		IsAdmin:      isEmpty,
+	}
+	exists, err := ExistsUser(username)
+	if err != nil {
+		return user, err
+	}
+	if exists {
+		return user, &model.RequestError{
+			Message: "User already exists",
+		}
+	}
+	if err := db.Create(&user).Error; err != nil {
+		return user, err
+	}
+	return user, nil
+}
+
+func ExistsUser(username string) (bool, error) {
+	var count int64
+	if err := db.Model(&model.User{}).Where("username = ?", username).Count(&count).Error; err != nil {
+		return false, err
+	}
+	return count > 0, nil
+}
+
+func GetUserByUsername(username string) (model.User, error) {
+	var user model.User
+	if err := db.Where("username = ?", username).First(&user).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return user, model.NewNotFoundError("User not found")
+		}
+		return user, err
+	}
+	return user, nil
+}
+
+func GetUserByID(id uint) (model.User, error) {
+	var user model.User
+	if err := db.First(&user, id).Error; err != nil {
+		return user, err
+	}
+	return user, nil
+}
+
+func UpdateUser(user model.User) error {
+	if err := db.Save(&user).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func IsUserDataBaseEmpty() (bool, error) {
+	var user model.User
+	if err := db.First(&user).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return true, nil
+		}
+		return false, err
+	}
+	return false, nil
+}
+
+// 获取分页用户列表
+func ListUsers(page, pageSize int) ([]model.User, int64, error) {
+	var users []model.User
+	var total int64
+
+	// 获取总数
+	if err := db.Model(&model.User{}).Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// 分页获取用户
+	offset := (page - 1) * pageSize
+	if err := db.Offset(offset).Limit(pageSize).Order("id desc").Find(&users).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return users, total, nil
+}
+
+// 根据用户名搜索用户
+func SearchUsersByUsername(username string, page, pageSize int) ([]model.User, int64, error) {
+	var users []model.User
+	var total int64
+
+	// 获取符合条件的总数
+	if err := db.Model(&model.User{}).Where("username LIKE ?", "%"+username+"%").Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// 分页获取符合条件的用户
+	offset := (page - 1) * pageSize
+	if err := db.Where("username LIKE ?", "%"+username+"%").Offset(offset).Limit(pageSize).Order("id desc").Find(&users).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return users, total, nil
+}
+
+// 删除用户
+func DeleteUser(id uint) error {
+	return db.Delete(&model.User{}, id).Error
+}