refactor: backend

store/resource.go

@@ -1,63 +1,155 @@
 package store
 
-import "memos/utils"
+import (
+	"fmt"
+	"memos/api"
+	"memos/common"
+	"strings"
+)
 
-type Resource struct {
-	Id        string `json:"id"`
-	UserId    string `json:"userId"`
-	Filename  string `json:"filename"`
-	Blob      []byte `json:"blob"`
-	Type      string `json:"type"`
-	Size      int64  `json:"size"`
-	CreatedAt string `json:"createdAt"`
+type ResourceService struct {
+	db *DB
 }
 
-func CreateResource(userId string, filename string, blob []byte, filetype string, size int64) (Resource, error) {
-	newResource := Resource{
-		Id:        utils.GenUUID(),
-		UserId:    userId,
-		Filename:  filename,
-		Blob:      blob,
-		Type:      filetype,
-		Size:      size,
-		CreatedAt: utils.GetNowDateTimeStr(),
+func NewResourceService(db *DB) *ResourceService {
+	return &ResourceService{db: db}
+}
+
+func (s *ResourceService) CreateResource(create *api.ResourceCreate) (*api.Resource, error) {
+	resource, err := createResource(s.db, create)
+	if err != nil {
+		return nil, err
 	}
 
-	query := `INSERT INTO resources (id, user_id, filename, blob, type, size, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)`
-	_, err := DB.Exec(query, newResource.Id, newResource.UserId, newResource.Filename, newResource.Blob, newResource.Type, newResource.Size, newResource.CreatedAt)
-
-	return newResource, FormatDBError(err)
+	return resource, nil
 }
 
-func GetResourcesByUserId(userId string) ([]Resource, error) {
-	query := `SELECT id, filename, type, size, created_at FROM resources WHERE user_id=?`
-	rows, _ := DB.Query(query, userId)
+func (s *ResourceService) FindResouceList(find *api.ResourceFind) ([]*api.Resource, error) {
+	list, err := findResourceList(s.db, find)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}
+
+func (s *ResourceService) DeleteResource(delete *api.ResourceDelete) error {
+	err := deleteResource(s.db, delete)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func createResource(db *DB, create *api.ResourceCreate) (*api.Resource, error) {
+	row, err := db.Db.Query(`
+		INSERT INTO resource (
+			filename,
+			blob,
+			type,
+			size,
+			creator_id
+		)
+		VALUES (?, ?, ?, ?, ?)
+		RETURNING id, filename, blob, type, size, created_ts, updated_ts
+	`,
+		create.Filename,
+		create.Blob,
+		create.Type,
+		create.Size,
+		create.CreatorId,
+	)
+	if err != nil {
+		return nil, FormatError(err)
+	}
+	defer row.Close()
+
+	if !row.Next() {
+		return nil, &common.Error{Code: common.NotFound, Err: fmt.Errorf("not found")}
+	}
+
+	var resource api.Resource
+	if err := row.Scan(
+		&resource.Id,
+		&resource.Filename,
+		&resource.Blob,
+		&resource.Type,
+		&resource.Size,
+		&resource.CreatedTs,
+		&resource.UpdatedTs,
+	); err != nil {
+		return nil, FormatError(err)
+	}
+
+	return &resource, nil
+}
+
+func findResourceList(db *DB, find *api.ResourceFind) ([]*api.Resource, error) {
+	where, args := []string{"1 = 1"}, []interface{}{}
+	if v := find.Id; v != nil {
+		where, args = append(where, "id = ?"), append(args, *v)
+	}
+	if v := find.CreatorId; v != nil {
+		where, args = append(where, "creator_id = ?"), append(args, *v)
+	}
+	if v := find.Filename; v != nil {
+		where, args = append(where, "filename = ?"), append(args, *v)
+	}
+
+	rows, err := db.Db.Query(`
+		SELECT
+			id,
+			filename,
+			blob,
+			type,
+			size,
+			created_ts,
+			updated_ts
+		FROM resource
+		WHERE `+strings.Join(where, " AND "),
+		args...,
+	)
+	if err != nil {
+		return nil, FormatError(err)
+	}
 	defer rows.Close()
 
-	resources := []Resource{}
-
+	list := make([]*api.Resource, 0)
 	for rows.Next() {
-		resource := Resource{}
-		rows.Scan(&resource.Id, &resource.Filename, &resource.Type, &resource.Size, &resource.CreatedAt)
-		resources = append(resources, resource)
+		var resource api.Resource
+		if err := rows.Scan(
+			&resource.Id,
+			&resource.Filename,
+			&resource.Blob,
+			&resource.Type,
+			&resource.Size,
+			&resource.CreatedTs,
+			&resource.UpdatedTs,
+		); err != nil {
+			return nil, FormatError(err)
+		}
+
+		list = append(list, &resource)
 	}
 
 	if err := rows.Err(); err != nil {
-		return nil, FormatDBError(err)
+		return nil, FormatError(err)
 	}
 
-	return resources, nil
+	return list, nil
 }
 
-func GetResourceByIdAndFilename(id string, filename string) (Resource, error) {
-	query := `SELECT id, filename, blob, type, size FROM resources WHERE id=? AND filename=?`
-	resource := Resource{}
-	err := DB.QueryRow(query, id, filename).Scan(&resource.Id, &resource.Filename, &resource.Blob, &resource.Type, &resource.Size)
-	return resource, FormatDBError(err)
-}
+func deleteResource(db *DB, delete *api.ResourceDelete) error {
+	result, err := db.Db.Exec(`DELETE FROM resource WHERE id = ?`, delete.Id)
+	if err != nil {
+		return FormatError(err)
+	}
 
-func DeleteResourceById(id string) error {
-	query := `DELETE FROM resources WHERE id=?`
-	_, err := DB.Exec(query, id)
-	return FormatDBError(err)
+	rows, _ := result.RowsAffected()
+	if rows == 0 {
+		return &common.Error{Code: common.NotFound, Err: fmt.Errorf("resource ID not found: %d", delete.Id)}
+	}
+
+	return nil
 }