update api

providers/local/local.go

@@ -1,135 +1,103 @@
 package local
 
 import (
-	"miaosic"
+	"github.com/AynaLivePlayer/miaosic"
 	"os"
 	"path"
+	"strings"
 )
 
+type localPlaylist struct {
+	name   string
+	medias []localMedia
+}
+
+type localMedia struct {
+	info    miaosic.MediaInfo
+	quality miaosic.Quality
+	lyrics  []miaosic.Lyrics
+}
+
+func (l *localPlaylist) GetMediaInfo(meta miaosic.MediaMeta) (miaosic.MediaInfo, error) {
+	for _, m := range l.medias {
+		if m.info.Meta.Identifier == meta.Identifier {
+			return m.info, nil
+		}
+	}
+	return miaosic.MediaInfo{}, miaosic.ErrorInvalidMediaMeta
+}
+
 type Local struct {
 	localDir  string
-	playlists map[string]*miaosic.Playlist
+	playlists map[string]*localPlaylist
 }
 
 func NewLocal(localdir string) *Local {
-	l := &Local{localDir: localdir, playlists: make(map[string]*miaosic.Playlist, 0)}
+	l := &Local{localDir: localdir, playlists: make(map[string]*localPlaylist, 0)}
 	if err := os.MkdirAll(localdir, 0755); err != nil {
 		return l
 	}
 	for _, n := range getPlaylistNames(localdir) {
-		playlist := &miaosic.Playlist{Meta: miaosic.MediaMeta{Provider: n}}
+		playlist := &localPlaylist{name: n, medias: make([]localMedia, 0)}
 		if readLocalPlaylist(localdir, playlist) != nil {
-			l.playlists[playlist.Title] = playlist
+			l.playlists[playlist.name] = playlist
 		}
 	}
 	return l
 }
 
+func (l *Local) metaToId(meta miaosic.MediaMeta) (playlist string) {
+	return strings.Split(meta.Identifier, "/")[0]
+}
+
 func (l *Local) GetName() string {
 	return "local"
 }
 
-func (l *Local) MatchMedia(uri string) *miaosic.Media {
-	return nil
+func (l *Local) MatchMedia(uri string) (miaosic.MediaMeta, bool) {
+	return miaosic.MediaMeta{}, false
 }
 
-func (l *Local) MatchPlaylist(uri string) *miaosic.Playlist {
-	return nil
+func (l *Local) GetMediaInfo(meta miaosic.MediaMeta) (miaosic.MediaInfo, error) {
+	if meta.Provider != l.GetName() {
+		return miaosic.MediaInfo{}, miaosic.ErrorDifferentProvider
+	}
+	playlist, ok := l.playlists[l.metaToId(meta)]
+	if !ok {
+		return miaosic.MediaInfo{}, miaosic.ErrorInvalidMediaMeta
+	}
+	return playlist.GetMediaInfo(meta)
 }
 
-func (l *Local) Search(keyword string) ([]*miaosic.Media, error) {
-	allMedias := make([]*miaosic.Media, 0)
+func (l *Local) GetMediaUrl(meta miaosic.MediaMeta, quality miaosic.Quality) ([]miaosic.MediaUrl, error) {
+	info, err := l.GetMediaInfo(meta)
+	if err != nil {
+		return []miaosic.MediaUrl{}, err
+	}
+	return []miaosic.MediaUrl{{
+		Url:     path.Join(l.localDir, info.Meta.Identifier),
+		Quality: miaosic.QualityUnk,
+	}}, nil
+}
+
+func (l *Local) GetMediaLyric(meta miaosic.MediaMeta) ([]miaosic.Lyrics, error) {
+	return []miaosic.Lyrics{}, miaosic.ErrNotImplemented
+}
+
+func (l *Local) Search(keyword string, page, size int) ([]miaosic.MediaInfo, error) {
+	allMedias := make([]miaosic.MediaInfo, 0)
 	for _, p := range l.playlists {
-		for _, m := range p.Medias {
-			allMedias = append(allMedias, m)
+		for _, m := range p.medias {
+			allMedias = append(allMedias, m.info)
 		}
 	}
-	return RankMedia(keyword, allMedias), nil
-}
-
-func (l *Local) UpdatePlaylist(playlist *miaosic.Playlist) error {
-	err := readLocalPlaylist(l.localDir, playlist)
-	if err != nil {
-		return err
+	rankedMedias := rankMedia(keyword, &allMedias)
+	total := len(rankedMedias)
+	if total < page*size {
+		return []miaosic.MediaInfo{}, nil
 	}
-	l.playlists[playlist.Meta.Identifier] = playlist
-	return nil
-}
-
-func (l *Local) UpdateMedia(media *miaosic.Media) error {
-	mediaPath := path.Join(l.localDir, media.Meta.Identifier)
-	_, err := os.Stat(mediaPath)
-	if err != nil {
-		return err
+	if total >= page*size {
+		total = page * size
 	}
-	return readMediaFile(l.localDir, media)
+	return rankedMedias[(page-1)*size : total], nil
 }
-
-func (l *Local) UpdateMediaUrl(media *miaosic.Media) error {
-	mediaPath := path.Join(l.localDir, media.Meta.Identifier)
-	_, err := os.Stat(mediaPath)
-	if err != nil {
-		return err
-	}
-	media.Url = mediaPath
-	return nil
-}
-
-func (l *Local) UpdateMediaLyric(media *miaosic.Media) error {
-	return nil
-}
-
-//
-//func (l *Local) Search(keyword string) ([]*model.Media, error) {
-//	allMedias := make([]*model.Media, 0)
-//	for _, p := range l.Playlists {
-//		for _, m := range p.Medias {
-//			allMedias = append(allMedias, m)
-//		}
-//	}
-//	MediaSort(keyword, allMedias)
-//	c := util.Min(len(allMedias), 32)
-//	medias := make([]*model.Media, c)
-//	for i := 0; i < c; i++ {
-//		medias[i] = allMedias[i].Copy()
-//	}
-//	return medias, nil
-//}
-//
-//func (l *Local) SearchV1(keyword string) ([]*model.Media, error) {
-//	result := make([]struct {
-//		M *model.Media
-//		N int
-//	}, 0)
-//	keywords := strings.Split(keyword, " ")
-//	for _, p := range l.Playlists {
-//		for _, m := range p.Medias {
-//			title := strings.ToLower(m.Title)
-//			artist := strings.ToLower(m.Artist)
-//			n := 0
-//			for _, k := range keywords {
-//				kw := strings.ToLower(k)
-//				if strings.Contains(title, kw) || strings.Contains(artist, kw) {
-//					n++
-//				}
-//				if kw == title {
-//					n += 3
-//				}
-//			}
-//			if n > 0 {
-//				result = append(result, struct {
-//					M *model.Media
-//					N int
-//				}{M: m, N: n})
-//			}
-//		}
-//	}
-//	sort.Slice(result, func(i, j int) bool {
-//		return result[i].N > result[j].N
-//	})
-//	medias := make([]*model.Media, len(result))
-//	for i, r := range result {
-//		medias[i] = r.M.Copy()
-//	}
-//	return medias, nil
-//}