实现音频服务api

db.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"butterfliu/internal/repository"
 	"butterfliu/migrations"
 	"database/sql"
 	"fmt"
@@ -55,10 +56,10 @@ func CloseDB() error {
 	return nil
 }
 
-func AddLibrary(name, path string) (Library, error) {
+func AddLibrary(name, path string) (repository.Library, error) {
 	absPath, err := filepath.Abs(path)
 	if err != nil {
-		return Library{}, err
+		return repository.Library{}, err
 	}
 
 	result, err := DB.Exec(
@@ -66,31 +67,31 @@ func AddLibrary(name, path string) (Library, error) {
 		name, absPath,
 	)
 	if err != nil {
-		return Library{}, err
+		return repository.Library{}, err
 	}
 
 	id, err := result.LastInsertId()
 	if err != nil {
-		return Library{}, err
+		return repository.Library{}, err
 	}
 
-	return Library{
+	return repository.Library{
 		ID:   int(id),
 		Name: name,
 		Path: absPath,
 	}, nil
 }
 
-func GetLibraries() ([]Library, error) {
+func GetLibraries() ([]repository.Library, error) {
 	rows, err := DB.Query("SELECT id, name, path FROM libraries")
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 
-	libraries := []Library{}
+	libraries := []repository.Library{}
 	for rows.Next() {
-		var lib Library
+		var lib repository.Library
 		if err := rows.Scan(&lib.ID, &lib.Name, &lib.Path); err != nil {
 			return nil, err
 		}
@@ -100,11 +101,11 @@ func GetLibraries() ([]Library, error) {
 	return libraries, nil
 }
 
-func GetLibraryByID(id int) (Library, error) {
+func GetLibraryByID(id int) (repository.Library, error) {
 	row := DB.QueryRow("SELECT id, name, path FROM libraries WHERE id = ?", id)
-	var lib Library
+	var lib repository.Library
 	if err := row.Scan(&lib.ID, &lib.Name, &lib.Path); err != nil {
-		return Library{}, err
+		return repository.Library{}, err
 	}
 	return lib, nil
 }
@@ -128,58 +129,58 @@ func DeleteLibrary(id int) error {
 	return err
 }
 
-func AddMediaFile(path string, libraryID int) (MediaFile, error) {
+func AddMediaFile(path string, libraryID int) (repository.MediaFile, error) {
 	result, err := DB.Exec("INSERT INTO media_files (path, library_id) VALUES (?, ?)", path, libraryID)
 	if err != nil {
-		return MediaFile{}, err
+		return repository.MediaFile{}, err
 	}
 
 	id, err := result.LastInsertId()
 	if err != nil {
-		return MediaFile{}, err
+		return repository.MediaFile{}, err
 	}
 
-	return MediaFile{
+	return repository.MediaFile{
 		ID:   int(id),
 		Path: path,
 	}, nil
 }
 
-func GetMediaFileByPath(path string) (MediaFile, error) {
+func GetMediaFileByPath(path string) (repository.MediaFile, error) {
 	row := DB.QueryRow("SELECT id, path FROM media_files WHERE path = ?", path)
-	var mediaFile MediaFile
+	var mediaFile repository.MediaFile
 	if err := row.Scan(&mediaFile.ID, &mediaFile.Path); err != nil {
-		return MediaFile{}, err
+		return repository.MediaFile{}, err
 	}
 	return mediaFile, nil
 }
 
-func AddArtist(name string) (Artist, error) {
+func AddArtist(name string) (repository.Artist, error) {
 	result, err := DB.Exec("INSERT INTO artists (name) VALUES (?)", name)
 	if err != nil {
-		return Artist{}, err
+		return repository.Artist{}, err
 	}
 
 	id, err := result.LastInsertId()
 	if err != nil {
-		return Artist{}, err
+		return repository.Artist{}, err
 	}
 
-	return Artist{
+	return repository.Artist{
 		ID:   int(id),
 		Name: name,
 	}, nil
 }
 
-func GetArtists() ([]Artist, error) {
+func GetArtists() ([]repository.Artist, error) {
 	rows, err := DB.Query("SELECT id, name FROM artists")
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	artists := []Artist{}
+	artists := []repository.Artist{}
 	for rows.Next() {
-		var artist Artist
+		var artist repository.Artist
 		if err := rows.Scan(&artist.ID, &artist.Name); err != nil {
 			return nil, err
 		}
@@ -187,19 +188,19 @@ func GetArtists() ([]Artist, error) {
 	}
 	return artists, nil
 }
-func GetArtistByID(id int) (Artist, error) {
+func GetArtistByID(id int) (repository.Artist, error) {
 	row := DB.QueryRow("SELECT id, name FROM artists WHERE id = ?", id)
-	var artist Artist
+	var artist repository.Artist
 	if err := row.Scan(&artist.ID, &artist.Name); err != nil {
-		return Artist{}, err
+		return repository.Artist{}, err
 	}
 	return artist, nil
 }
-func GetArtistByName(name string) (Artist, error) {
+func GetArtistByName(name string) (repository.Artist, error) {
 	row := DB.QueryRow("SELECT id, name FROM artists WHERE name = ?", name)
-	var artist Artist
+	var artist repository.Artist
 	if err := row.Scan(&artist.ID, &artist.Name); err != nil {
-		return Artist{}, err
+		return repository.Artist{}, err
 	}
 	return artist, nil
 }
@@ -213,32 +214,32 @@ func DeleteArtist(id int) error {
 	return err
 }
 
-func AddAlbum(title string, artistID int) (Album, error) {
+func AddAlbum(title string, artistID int) (repository.Album, error) {
 	result, err := DB.Exec("INSERT INTO albums (title, artist_id) VALUES (?, ?)", title, artistID)
 	if err != nil {
-		return Album{}, err
+		return repository.Album{}, err
 	}
 	id, err := result.LastInsertId()
 	if err != nil {
-		return Album{}, err
+		return repository.Album{}, err
 	}
 
-	return Album{
+	return repository.Album{
 		ID:       int(id),
 		Title:    title,
 		ArtistID: artistID,
 	}, nil
 }
 
-func GetAlbums() ([]Album, error) {
+func GetAlbums() ([]repository.Album, error) {
 	rows, err := DB.Query("SELECT id, title, artist_id FROM albums")
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	albums := []Album{}
+	albums := []repository.Album{}
 	for rows.Next() {
-		var album Album
+		var album repository.Album
 		if err := rows.Scan(&album.ID, &album.Title, &album.ArtistID); err != nil {
 			return nil, err
 		}
@@ -247,42 +248,42 @@ func GetAlbums() ([]Album, error) {
 	return albums, nil
 }
 
-func GetAlbumByID(id int) (Album, error) {
+func GetAlbumByID(id int) (repository.Album, error) {
 	row := DB.QueryRow("SELECT id, title, artist_id FROM albums WHERE id = ?", id)
-	var album Album
+	var album repository.Album
 	if err := row.Scan(&album.ID, &album.Title, &album.ArtistID); err != nil {
-		return Album{}, err
+		return repository.Album{}, err
 	}
 	return album, nil
 }
 
-func GetAlbumByTitle(title string) (Album, error) {
+func GetAlbumByTitle(title string) (repository.Album, error) {
 	row := DB.QueryRow("SELECT id, title, artist_id FROM albums WHERE title = ?", title)
-	var album Album
+	var album repository.Album
 	if err := row.Scan(&album.ID, &album.Title, &album.ArtistID); err != nil {
-		return Album{}, err
+		return repository.Album{}, err
 	}
 	return album, nil
 }
 
-func GetAlbumByTitleAndArtist(title string, artistID int) (Album, error) {
+func GetAlbumByTitleAndArtist(title string, artistID int) (repository.Album, error) {
 	row := DB.QueryRow("SELECT id, title, artist_id FROM albums WHERE title = ? AND artist_id = ?", title, artistID)
-	var album Album
+	var album repository.Album
 	if err := row.Scan(&album.ID, &album.Title, &album.ArtistID); err != nil {
-		return Album{}, err
+		return repository.Album{}, err
 	}
 	return album, nil
 }
 
-func GetAlbumsByArtist(artistID int) ([]Album, error) {
+func GetAlbumsByArtist(artistID int) ([]repository.Album, error) {
 	rows, err := DB.Query("SELECT id, title, artist_id FROM albums WHERE artist_id = ?", artistID)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	albums := []Album{}
+	albums := []repository.Album{}
 	for rows.Next() {
-		var album Album
+		var album repository.Album
 		if err := rows.Scan(&album.ID, &album.Title, &album.ArtistID); err != nil {
 			return nil, err
 		}
@@ -304,18 +305,18 @@ func DeleteAlbum(id int) error {
 	return err
 }
 
-func AddSong(title string, artistID, albumID, duration, mediaFileID int) (Song, error) {
+func AddSong(title string, artistID, albumID, duration, mediaFileID int) (repository.Song, error) {
 	result, err := DB.Exec("INSERT INTO songs (title, artist_id, album_id, duration, media_file_id) VALUES (?, ?, ?, ?, ?)", title, artistID, albumID, duration, mediaFileID)
 	if err != nil {
-		return Song{}, err
+		return repository.Song{}, err
 	}
 
 	id, err := result.LastInsertId()
 	if err != nil {
-		return Song{}, err
+		return repository.Song{}, err
 	}
 
-	return Song{
+	return repository.Song{
 		ID:          int(id),
 		Title:       title,
 		ArtistID:    artistID,
@@ -324,15 +325,15 @@ func AddSong(title string, artistID, albumID, duration, mediaFileID int) (Song,
 		MediaFileID: mediaFileID,
 	}, nil
 }
-func GetSongs() ([]Song, error) {
+func GetSongs() ([]repository.Song, error) {
 	rows, err := DB.Query("SELECT id, artist_id, album_id, duration, media_file_id FROM songs")
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	songs := []Song{}
+	songs := []repository.Song{}
 	for rows.Next() {
-		var song Song
+		var song repository.Song
 		if err := rows.Scan(&song.ID, &song.ArtistID, &song.AlbumID, &song.Duration, &song.MediaFileID); err != nil {
 			return nil, err
 		}
@@ -361,7 +362,7 @@ func DeleteSong(id int) error {
 	return err
 }
 
-func GetSongsByLibrary(libraryID int) ([]Song, error) {
+func GetSongsByLibrary(libraryID int) ([]repository.Song, error) {
 	rows, err := DB.Query(`
 		SELECT s.id, s.title, s.artist_id, s.album_id, s.duration, s.media_file_id
 		FROM songs s
@@ -373,9 +374,9 @@ func GetSongsByLibrary(libraryID int) ([]Song, error) {
 		return nil, err
 	}
 	defer rows.Close()
-	songs := []Song{}
+	songs := []repository.Song{}
 	for rows.Next() {
-		var song Song
+		var song repository.Song
 		if err := rows.Scan(&song.ID, &song.Title, &song.ArtistID, &song.AlbumID, &song.Duration, &song.MediaFileID); err != nil {
 			return nil, err
 		}