Playlist downloading

BeatSyncLib/Configs/BeatSyncConfig.cs

@@ -223,6 +223,27 @@ public ScoreSaberConfig ScoreSaber
                 SetConfigChanged();
             }
         }
+        private PlaylistFeeds _playlistFeed;
+        [JsonProperty(Order = -30)]
+        public PlaylistFeeds PlaylistsFeed
+        {
+            get
+            {
+                if (_playlistFeed == null)
+                {
+                    _playlistFeed = new PlaylistFeeds();
+                    SetConfigChanged();
+                }
+                return _playlistFeed;
+            }
+            set
+            {
+                if (_playlistFeed == value)
+                    return;
+                _playlistFeed = value;
+                SetConfigChanged();
+            }
+        }
         [JsonProperty(Order = 100)]
         public DateTime LastRun
         {
@@ -256,7 +277,8 @@ public override bool ConfigChanged
                 return (base.ConfigChanged 
                     || BeatSaver.ConfigChanged 
                     || BeastSaber.ConfigChanged 
-                    || ScoreSaber.ConfigChanged);
+                    || ScoreSaber.ConfigChanged
+                    || PlaylistsFeed.ConfigChanged);
             }
             protected set => base.ConfigChanged = value;
         }
@@ -266,6 +288,7 @@ public override void ResetConfigChanged()
             BeastSaber.ResetConfigChanged();
             BeatSaver.ResetConfigChanged();
             ScoreSaber.ResetConfigChanged();
+            PlaylistsFeed.ResetConfigChanged();
             base.ResetConfigChanged();
         }
 
@@ -274,6 +297,7 @@ public override void ResetFlags()
             BeastSaber.ResetFlags();
             BeatSaver.ResetFlags();
             ScoreSaber.ResetFlags();
+            PlaylistsFeed.ResetFlags();
             base.ResetFlags();
         }
 
@@ -288,6 +312,7 @@ public override void FillDefaults()
             BeatSaver.FillDefaults();
             BeastSaber.FillDefaults();
             ScoreSaber.FillDefaults();
+            PlaylistsFeed.FillDefaults();
         }
 
         public BeatSyncConfig Clone()

BeatSyncLib/Configs/PlaylistsFeedConfigs.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BeatSaberPlaylistsLib;
+using SongFeedReaders.Readers;
+using SongFeedReaders.Readers.BeastSaber;
+using BeatSyncLib.Playlists;
+
+namespace BeatSyncLib.Configs
+{
+    public class PlaylistFeeds : FeedConfigBase
+    {
+        #region Defaults
+        protected override bool DefaultEnabled => false;
+
+        protected override int DefaultMaxSongs => 0;
+
+        protected override bool DefaultCreatePlaylist => false;
+
+        protected override PlaylistStyle DefaultPlaylistStyle => PlaylistStyle.Append;
+
+        protected override BuiltInPlaylist DefaultFeedPlaylist => BuiltInPlaylist.BeastSaberFollows;
+        #endregion
+
+        public override IFeedSettings ToFeedSettings()
+        {
+            return new BeastSaberFeedSettings((int)BeastSaberFeedName.Following)
+            {
+                MaxSongs = this.MaxSongs
+            };
+        }
+    }
+}

BeatSyncLib/Downloader/SongDownloader.cs

@@ -29,11 +29,19 @@ public async Task<JobStats[]> RunAsync(BeatSyncConfig config, IJobBuilder jobBui
                     {
                         GetBeatSaverAsync(config, jobBuilder, manager, cancellationToken),
                         GetBeastSaberAsync(config, jobBuilder, manager, cancellationToken),
-                        GetScoreSaberAsync(config, jobBuilder, manager, cancellationToken)
+                        GetScoreSaberAsync(config, jobBuilder, manager, cancellationToken),
+                        GetPlaylistsAsync(config, jobBuilder, manager, cancellationToken)
                     };
-            return await Task.WhenAll(downloadTasks).ConfigureAwait(false);
+            var mainStats = await Task.WhenAll(downloadTasks).ConfigureAwait(false);
+            var playlistStats = await GetPlaylistsAsync(config, jobBuilder, manager, cancellationToken);
+            var stats = new JobStats[mainStats.Length + 1];
+            for (int i = 0; i < mainStats.Length; i++)
+                stats[i] = mainStats[i];
+            stats[3] = playlistStats;
+            return stats;
         }
 
+
         public static IEnumerable<IJob>? CreateJobs(FeedResult feedResult, IJobBuilder jobBuilder, JobManager jobManager, CancellationToken cancellationToken)
         {
             if (!feedResult.Successful)
@@ -285,7 +293,55 @@ protected async Task<JobStats> GetBeatSaverAsync(BeatSyncConfig config, IJobBuil
             return sourceStats;
         }
 
+        protected async Task<JobStats> GetPlaylistsAsync(BeatSyncConfig config, IJobBuilder jobBuilder, JobManager jobManager, CancellationToken cancellationToken)
+        {
+            PlaylistFeeds feedConfig = config.PlaylistsFeed;
+            JobStats sourceStats = new JobStats();
+
+            if (!feedConfig.Enabled)
+                return sourceStats;
+            foreach (var target in jobBuilder.SongTargets)
+            {
+                if(target is ITargetWithPlaylists playlistTarget)
+                {
+                    var playlists = playlistTarget.PlaylistManager?.GetAllPlaylists() ?? Array.Empty<IPlaylist>();
+                    List<SongFeedReaders.Data.ISong> songList = new List<SongFeedReaders.Data.ISong>();
+                    foreach (var playlist in playlists)
+                    {
+                        Logger.log?.Info($"Checking playlist {playlist.Title} for missing songs...");
+                        foreach (var song in playlist)
+                        {
+                            string? hash = song.Hash;
+                            if (hash == null)
+                                break;
+                            SongState songState = await target.CheckSongExistsAsync(hash);
+                            if(songState == SongState.Wanted)
+                            {
+                                string? logText = song.Name;
+                                if(!string.IsNullOrEmpty(logText))
+                                {
+                                    if (!string.IsNullOrEmpty(song.LevelAuthorName))
+                                        logText = $"{logText} by {song.LevelAuthorName}";
+                                    else
+                                        logText = hash;
+                                }
+                                Logger.log?.Debug($"Missing song '{logText}'");
+                                songList.Add(new ScrapedSong(hash, song.Name, song.LevelAuthorName));
+                            }
+                        }
+
+                        IEnumerable<IJob>? jobs = CreateJobs(songList, jobBuilder, jobManager, cancellationToken) ?? Array.Empty<IJob>();
+                        JobResult[] jobResults = await Task.WhenAll(jobs.Select(j => j.JobTask).ToArray());
+                        JobStats feedStats = new JobStats(jobResults);
+                        ProcessFinishedJobs(jobs, jobBuilder.SongTargets, config, feedConfig);
+                        Logger.log?.Info($"  Finished downloading songs for playlist {playlist.Title}: ({feedStats}).");
+                        sourceStats += feedStats;
+                    }
 
+                }
+            }
+            return sourceStats;
+        }
 
 
         public static void ProcessFinishedJobs(IEnumerable<IJob> jobs, IEnumerable<SongTarget> songTargets, BeatSyncConfig beatSyncConfig, FeedConfigBase feedConfig)