jellyfin-smart-playlist/Jellyfin.Plugin.SmartPlaylist/Store.cs

using YamlDotNet.Serialization;

namespace Jellyfin.Plugin.SmartPlaylist {
    public interface IStore {
        Task<SmartPlaylistDto> GetSmartPlaylistAsync(SmartPlaylistId smartPlaylistId);
        Task<SmartPlaylistDto[]> GetAllSmartPlaylistsAsync();
        Task SaveSmartPlaylistAsync(SmartPlaylistDto smartPlaylist);
        void DeleteSmartPlaylistById(SmartPlaylistId smartPlaylistId);
        void DeleteSmartPlaylist(SmartPlaylistDto smartPlaylist);

        Task<SmartCollectionDto> GetSmartCollectionAsync(SmartCollectionId smartCollectionId);
        Task<SmartCollectionDto[]> GetAllSmartCollectionsAsync();
        Task SaveSmartCollectionAsync(SmartCollectionDto smartCollection);
        void DeleteSmartCollectionById(SmartCollectionId smartCollectionId);
        void DeleteSmartCollection(SmartCollectionDto smartCollection);
    }

    public class Store : IStore {
        private readonly ISmartPlaylistFileSystem _fileSystem;
        public Store(ISmartPlaylistFileSystem fileSystem) {
            _fileSystem = fileSystem;
        }
        private async Task<SmartPlaylistDto> LoadPlaylistAsync(string filename) {
            var r = await File.ReadAllTextAsync(filename);
            if (r.Equals("")) {
                r = "{}";
            }
            var dto = new DeserializerBuilder().Build().Deserialize<SmartPlaylistDto>(r);
            if (dto == null)
            {
                throw new ApplicationException("");
            }
            if (dto.Id != Path.GetFileNameWithoutExtension(filename)) {
                dto.Id = Path.GetFileNameWithoutExtension(filename);
            }
            if (dto.Name != Path.GetFileNameWithoutExtension(filename)) {
                dto.Name = Path.GetFileNameWithoutExtension(filename);
            }
            if (dto.Filename != filename) {
                dto.Filename = filename;
            }
            return dto;
        }
        public async Task<SmartPlaylistDto> GetSmartPlaylistAsync(SmartPlaylistId smartPlaylistId) {
            string filename = _fileSystem.FindSmartPlaylistFilePath(smartPlaylistId);
            return await LoadPlaylistAsync(filename).ConfigureAwait(false);
        }
        public async Task<SmartPlaylistDto[]> GetAllSmartPlaylistsAsync() {
            var t = _fileSystem.FindAllSmartPlaylistFilePaths().Select(LoadPlaylistAsync).ToArray();
            await Task.WhenAll(t).ConfigureAwait(false);
            return t.Where(x => x != null).Select(x => x.Result).ToArray();
        }
        public async Task SaveSmartPlaylistAsync(SmartPlaylistDto smartPlaylist) {
            string filename = _fileSystem.GetSmartPlaylistFilePath(smartPlaylist.Id);
            var text = new SerializerBuilder().Build().Serialize(smartPlaylist);
            await File.WriteAllTextAsync(filename, text);
        }
        public void DeleteSmartPlaylistById(SmartPlaylistId smartPlaylistId) {
            try {
                string filename = _fileSystem.FindSmartPlaylistFilePath(smartPlaylistId);
                if (File.Exists(filename)) { File.Delete(filename); }
            } catch (System.InvalidOperationException) {}
        }
        public void DeleteSmartPlaylist(SmartPlaylistDto smartPlaylist) {
            if (File.Exists(smartPlaylist.Filename)) { File.Delete(smartPlaylist.Filename); }
            DeleteSmartPlaylistById(smartPlaylist.Id);
        }

        private async Task<SmartCollectionDto> LoadCollectionAsync(string filename) {
            var r = await File.ReadAllTextAsync(filename);
            if (r.Equals("")) {
                r = "{}";
            }
            var dto = new DeserializerBuilder().Build().Deserialize<SmartCollectionDto>(r);
            if (dto == null)
            {
                throw new ApplicationException("");
            }
            if (dto.Id != Path.GetFileNameWithoutExtension(filename)) {
                dto.Id = Path.GetFileNameWithoutExtension(filename);
            }
            if (dto.Name != Path.GetFileNameWithoutExtension(filename)) {
                dto.Name = Path.GetFileNameWithoutExtension(filename);
            }
            if (dto.Filename != filename) {
                dto.Filename = filename;
            }
            return dto;
        }
        public async Task<SmartCollectionDto> GetSmartCollectionAsync(SmartCollectionId smartCollectionId) {
            string filename = _fileSystem.FindSmartCollectionFilePath(smartCollectionId);
            return await LoadCollectionAsync(filename).ConfigureAwait(false);
        }
        public async Task<SmartCollectionDto[]> GetAllSmartCollectionsAsync() {
            var t = _fileSystem.FindAllSmartCollectionFilePaths().Select(LoadCollectionAsync).ToArray();
            await Task.WhenAll(t).ConfigureAwait(false);
            return t.Where(x => x != null).Select(x => x.Result).ToArray();
        }
        public async Task SaveSmartCollectionAsync(SmartCollectionDto smartCollection) {
            string filename = _fileSystem.GetSmartCollectionFilePath(smartCollection.Id);
            var text = new SerializerBuilder().Build().Serialize(smartCollection);
            await File.WriteAllTextAsync(filename, text);
        }
        public void DeleteSmartCollectionById(SmartCollectionId smartCollectionId) {
            try {
                string filename = _fileSystem.FindSmartCollectionFilePath(smartCollectionId);
                if (File.Exists(filename)) { File.Delete(filename); }
            } catch (System.InvalidOperationException) {}
        }
        public void DeleteSmartCollection(SmartCollectionDto smartCollection) {
            if (File.Exists(smartCollection.Filename)) { File.Delete(smartCollection.Filename); }
            DeleteSmartCollectionById(smartCollection.Id);
        }
    }
}