Updating/Cleanup importing process

Downloads/VersionSelector.xaml

@@ -11,10 +11,10 @@
             <Separator Margin="0,5,0,0" />
             <ScrollViewer DockPanel.Dock="Top" Width="auto" Height="120" Margin="5,5,5,5" VerticalScrollBarVisibility="Visible" HorizontalScrollBarVisibility="Disabled">
                 <StackPanel x:Name="tStack">
-                    <ItemsControl ItemsSource="{Binding Siblings}">
+                    <ItemsControl ItemsSource="{Binding RomVersions}">
                         <ItemsControl.ItemTemplate>
                             <DataTemplate>
-                                <RadioButton Margin="5,5,5,5" GroupName="Options" IsChecked="{Binding isSelected, Mode=TwoWay}" Content="{Binding FileName, Mode=OneWay}"/>
+                                <RadioButton Margin="5,5,5,5" GroupName="Options" IsChecked="{Binding IsSelected, Mode=TwoWay}" Content="{Binding FileName, Mode=OneWay}"/>
                             </DataTemplate>
                         </ItemsControl.ItemTemplate>
                     </ItemsControl>

Downloads/VersionSelector.xaml.cs

@@ -10,13 +10,13 @@ namespace RomM.VersionSelector
     public partial class RomMVersionSelector : PluginUserControl
     {
 
-        public ObservableCollection<RomMSibling> Siblings { get; set; }
+        public ObservableCollection<RomMRevision> RomVersions { get; set; }
         public bool Cancelled { get; set; } = true;
 
-        public RomMVersionSelector(List<RomMSibling> siblings)
+        public RomMVersionSelector(List<RomMRevision> romVersions)
         {
 
-            Siblings = new ObservableCollection<RomMSibling>(siblings);
+            RomVersions = new ObservableCollection<RomMRevision>(romVersions);
 
             InitializeComponent();  
         }

Games/RomMGameInfo.cs

@@ -7,7 +7,7 @@
 using System.IO;
 using System.Linq;
 using ProtoBuf;
-using Playnite.SDK;
+using RomM.Models.RomM.Rom;
 
 namespace RomM.Games
 {
@@ -68,7 +68,7 @@ private static T FromGameIdString<T>(string gameId) where T : RomMGameInfo
             }
         }
 
-        public InstallController GetInstallController(Game game, RomM romm, bool HasSiblings, int SelectedSibling) => new RomMInstallController(game, romm, HasSiblings, SelectedSibling);
+        public InstallController GetInstallController(Game game, RomM romm, GameInstallInfo GameData) => new RomMInstallController(game, romm, GameData);
 
         public UninstallController GetUninstallController(Game game, RomM romm) => new RomMUninstallController(game, romm);
 

Games/RomMImportController.cs

@@ -0,0 +1,231 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Playnite.SDK;
+using Playnite.SDK.Models;
+using Playnite.SDK.Plugins;
+using RomM.Models.RomM.Collection;
+using RomM.Models.RomM.Platform;
+using RomM.Models.RomM.Rom;
+using RomM.Settings;
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace RomM.Games
+{
+    class RomMImportController
+    {
+        private readonly RomM _plugin;
+        public ILogger Logger => LogManager.GetLogger();
+
+        public RomMImportController(RomM plugin)
+        {
+            _plugin = plugin;
+        }
+
+        public List<Game> Import(LibraryImportGamesArgs args)
+        {
+            IList<RomMPlatform> apiPlatforms = FetchPlatforms();
+            List<Task<List<Game>>> tasks = new List<Task<List<Game>>>();
+            List<Game> games = new List<Game>();
+            IEnumerable<EmulatorMapping> enabledMappings = SettingsViewModel.Instance.Mappings?.Where(m => m.Enabled);
+            string url = BuildROMUrl();
+
+            if (enabledMappings == null || !enabledMappings.Any())
+            {
+                _plugin.Playnite.Notifications.Add(_plugin.Id.ToString(), "No emulators are configured or enabled in RomM settings. No games will be fetched.", NotificationType.Error);
+                return games;
+            }
+
+            IList<RomMCollection> favoritCollections = _plugin.FetchFavorites();
+            var favorites = favoritCollections.FirstOrDefault(c => c.IsFavorite)?.RomIds ?? new List<int>();
+
+            // Pull ROM data for each enabled mapping and add the games to playnite
+            foreach (var mapping in enabledMappings)
+            {
+                if (args.CancelToken.IsCancellationRequested)
+                    break;
+
+                // Check mapping has an Emulator, Profile & Platform assigned to it
+                if (mapping.Emulator == null || mapping.EmulatorProfile == null || mapping.RomMPlatform == null || mapping.RomMPlatform.Id == -1)
+                {
+                    Logger.Warn($"[Import Controller] Emulator {mapping.MappingId} is misconfigured, skipping.");
+                    continue;
+                }
+
+                RomMPlatform apiPlatform = apiPlatforms.FirstOrDefault(p => p.Id == mapping.RomMPlatformId);
+                if (apiPlatform == null)
+                {
+                    _plugin.Playnite.Notifications.Add(_plugin.Id.ToString(), $"Platform {mapping.RomMPlatform.Name} with ID {mapping.RomMPlatformId} not found in RomM, skipping.", NotificationType.Error);
+                    continue;
+                }
+
+                // Pull data from server
+                // Could be made async, but when testing (4.7.0) found a performance degradation
+                var romMROMs = DownloadROMData(args, url, apiPlatform);
+                if(romMROMs == null)
+                {
+                    Logger.Warn($"[Import Controller] Failed to get ROMs for {apiPlatform.Name}.");
+                    continue;
+                }
+                Logger.Info($"[Import Controller] Finished parsing response for {apiPlatform.Name}.");
+
+                // Import games for current mapping 
+                tasks.Add(Task<List<Game>>.Factory.StartNew(() =>
+                {
+                    RomMImport newImport = new RomMImport(_plugin, args, mapping, romMROMs, favorites);
+                    return newImport.ProcessData();
+                }));
+
+            }
+
+            Task.WhenAll(tasks).Wait();
+
+            foreach (var task in tasks)
+            {
+                games.AddRange(task.Result);
+            }
+
+            return games;
+        }
+
+        private static async Task<HttpResponseMessage> GetAsyncWithParams(string baseUrl, NameValueCollection queryParams)
+        {
+            var uriBuilder = new UriBuilder(baseUrl);
+            var query = HttpUtility.ParseQueryString(uriBuilder.Query);
+
+            foreach (string key in queryParams)
+            {
+                query[key] = queryParams[key];
+            }
+
+            uriBuilder.Query = query.ToString();
+
+            return await HttpClientSingleton.Instance.GetAsync(uriBuilder.Uri);
+        }
+
+        private string BuildROMUrl()
+        {
+            string url = _plugin.CombineUrl(_plugin.Settings.RomMHost, "api/roms");
+
+            if (_plugin.Settings.SkipMissingFiles)
+            {
+                url += "?missing=false&";
+            }
+
+            // Exclude genres from import
+            string excludeGenresString = _plugin.Settings.ExcludeGenres.Trim(' ');
+            excludeGenresString = excludeGenresString.Trim(';');
+            List<string> excludeGenres = excludeGenresString.Split(';').ToList();
+            if (!string.IsNullOrEmpty(excludeGenresString))
+            {
+                // Add ? if it hasn't been added already
+                if (!_plugin.Settings.SkipMissingFiles)
+                {
+                    url += "?";
+                }
+
+                if (excludeGenres.Count > 1)
+                {
+                    foreach (var genre in excludeGenres)
+                    {
+                        url += $"genres={HttpUtility.UrlEncode(genre)}&";
+                    }
+                }
+                else
+                {
+                    url += $"genres={HttpUtility.UrlEncode(excludeGenresString)}";
+                }
+            }
+            url.Trim('&');
+
+            return url;
+        }
+        private IList<RomMPlatform> FetchPlatforms()
+        {
+            string apiPlatformsUrl = _plugin.CombineUrl(_plugin.Settings.RomMHost, "api/platforms");
+            try
+            {
+                HttpResponseMessage response = HttpClientSingleton.Instance.GetAsync(apiPlatformsUrl).GetAwaiter().GetResult();
+                response.EnsureSuccessStatusCode();
+
+                string body = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+                return JsonConvert.DeserializeObject<List<RomMPlatform>>(body);
+            }
+            catch (HttpRequestException e)
+            {
+                Logger.Error($"[Import Controller] Request exception: {e.Message}");
+                return new List<RomMPlatform>();
+            }
+        }
+
+        private List<RomMRom> DownloadROMData(LibraryImportGamesArgs args, string url, RomMPlatform platform)
+        {
+            Logger.Info($"[Import Controller] Starting to fetch games for {platform.Name}.");
+
+            const int pageSize = 50;
+            int offset = 0;
+            bool hasMoreData = true;
+            var romData = new List<RomMRom>();
+
+            // Download data from RomM server
+            while (hasMoreData)
+            {
+                if (args.CancelToken.IsCancellationRequested)
+                    break;
+
+                NameValueCollection queryParams = new NameValueCollection
+                    {
+                        { "platform_ids", platform.Id.ToString() },
+                        { "genres_logic", "none" },
+                        { "order_by", "name" },
+                        { "order_dir", "asc" },
+                        { "limit", pageSize.ToString() },
+                        { "offset", offset.ToString() },
+                    };
+
+                try
+                {
+                    HttpResponseMessage response = GetAsyncWithParams(url, queryParams).GetAwaiter().GetResult();
+                    response.EnsureSuccessStatusCode();
+
+                    Logger.Info($"[Import Controller] Parsing response for {platform.Name} batch {offset / pageSize + 1}.");
+
+                    Stream body = response.Content.ReadAsStreamAsync().GetAwaiter().GetResult();
+                    List<RomMRom> roms;
+                    using (StreamReader reader = new StreamReader(body))
+                    {
+                        var jsonResponse = JObject.Parse(reader.ReadToEnd());
+                        roms = jsonResponse["items"].ToObject<List<RomMRom>>();
+                    }
+
+                    Logger.Info($"[Import Controller] Parsed {roms.Count} roms for batch {offset / pageSize + 1}.");
+                    romData.AddRange(roms);
+
+                    if (roms.Count < pageSize)
+                    {
+                        Logger.Info($"[Import Controller] Received less than {pageSize} roms for {platform.Name}, assuming no more games.");
+                        hasMoreData = false;
+                        break;
+                    }
+
+                    offset += pageSize;
+                }
+                catch (HttpRequestException e)
+                {
+                    Logger.Error($"[Import Controller] Request exception: {e.Message}");
+                    hasMoreData = false;
+                }
+            }
+
+            return romData;
+        }
+    }
+
+}