Added: Ability to see TMDB and lists going through the Radarr API on the discovery page.

Added: More lists (specifically presets for IMDB Top 250 and IMDB Popular)
Added: Ability to set Radarr API endpoint as list.

src/NzbDrone.Core/NetImport/NetImportBase.cs

@@ -32,23 +32,21 @@ namespace NzbDrone.Core.NetImport
         public Type ConfigContract => typeof(TSettings);
 
         public virtual ProviderMessage Message => null;
-        public virtual IEnumerable<ProviderDefinition> DefaultDefinitions
-        {
-            get
-            {
-                var config = (IProviderConfig)new TSettings();
 
-                yield return new NetImportDefinition
-                {
-                    Name = this.Name,
-                    Enabled = config.Validate().IsValid && Enabled,
-                    EnableAuto = true,
-                    ProfileId = 1,
-		            MinimumAvailability = MovieStatusType.Announced,
-                    Implementation = GetType().Name,
-                    Settings = config
-                };
-            }
+        public virtual IEnumerable<ProviderDefinition> GetDefaultDefinitions()
+        {
+            var config = (IProviderConfig)new TSettings();
+
+            yield return new NetImportDefinition
+            {
+                Name = this.Name,
+                Enabled = config.Validate().IsValid && Enabled,
+                EnableAuto = true,
+                ProfileId = 1,
+                MinimumAvailability = MovieStatusType.Announced,
+                Implementation = GetType().Name,
+                Settings = config
+            };
         }
 
         public virtual ProviderDefinition Definition { get; set; }

src/NzbDrone.Core/NetImport/NetImportFactory.cs

@@ -10,6 +10,8 @@ namespace NzbDrone.Core.NetImport
     public interface INetImportFactory : IProviderFactory<INetImport, NetImportDefinition>
     {
         List<INetImport> Enabled();
+
+        List<INetImport> Discoverable();
     }
 
     public class NetImportFactory : ProviderFactory<INetImport, NetImportDefinition>, INetImportFactory
@@ -46,6 +48,13 @@ namespace NzbDrone.Core.NetImport
             return indexers.ToList();
         }
 
+        public List<INetImport> Discoverable()
+        {
+            var enabledImporters = GetAvailableProviders().Where(n => (n.GetType() == typeof(Radarr.RadarrProxied) || n.GetType() == typeof(TMDb.TMDbImport)));
+            var indexers = FilterBlockedIndexers(enabledImporters);
+            return indexers.ToList();
+        }
+
         private IEnumerable<INetImport> FilterBlockedIndexers(IEnumerable<INetImport> importers)
         {
             foreach (var importer in importers)

src/NzbDrone.Core/NetImport/RSSImport/RSSImport.cs

@@ -17,33 +17,30 @@ namespace NzbDrone.Core.NetImport.RSSImport
             : base(httpClient, configService, parsingService, logger)
         { }
 
-        public override IEnumerable<ProviderDefinition> DefaultDefinitions
+        public override IEnumerable<ProviderDefinition> GetDefaultDefinitions()
         {
-            get
+            foreach (var def in base.GetDefaultDefinitions())
             {
-                foreach (var def in base.DefaultDefinitions)
-                {
-                    yield return def;
-                }
-                yield return new NetImportDefinition
-                {
-                    Name = "IMDb List",
-                    Enabled = Enabled,
-                    EnableAuto = true,
-                    ProfileId = 1,
-                    Implementation = GetType().Name,
-                    Settings = new RSSImportSettings { Link = "http://rss.imdb.com/list/YOURLISTID" },
-                };
-                yield return new NetImportDefinition
-                {
-                    Name = "IMDb Watchlist",
-                    Enabled = Enabled,
-                    EnableAuto = true,
-                    ProfileId = 1,
-                    Implementation = GetType().Name,
-                    Settings = new RSSImportSettings { Link = "http://rss.imdb.com/user/IMDBUSERID/watchlist" },
-                };
+                yield return def;
             }
+            yield return new NetImportDefinition
+            {
+                Name = "IMDb List",
+                Enabled = Enabled,
+                EnableAuto = true,
+                ProfileId = 1,
+                Implementation = GetType().Name,
+                Settings = new RSSImportSettings { Link = "http://rss.imdb.com/list/YOURLISTID" },
+            };
+            yield return new NetImportDefinition
+            {
+                Name = "IMDb Watchlist",
+                Enabled = Enabled,
+                EnableAuto = true,
+                ProfileId = 1,
+                Implementation = GetType().Name,
+                Settings = new RSSImportSettings { Link = "http://rss.imdb.com/user/IMDBUSERID/watchlist" },
+            };
         }
 
         public override INetImportRequestGenerator GetRequestGenerator()

src/NzbDrone.Core/NetImport/Radarr/RadarrParser.cs

@@ -0,0 +1,78 @@
+using Newtonsoft.Json;
+using NzbDrone.Core.NetImport.Exceptions;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using NLog;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Core.MetadataSource.SkyHook.Resource;
+using NzbDrone.Core.MetadataSource;
+using NzbDrone.Core.MetadataSource.RadarrAPI;
+using NzbDrone.Common.Http;
+
+namespace NzbDrone.Core.NetImport.Radarr
+{
+    public class RadarrParser : IParseNetImportResponse
+    {
+        private readonly RadarrSettings _settings;
+        private NetImportResponse _importResponse;
+        private readonly ISearchForNewMovie _skyhookProxy;
+        private readonly Logger _logger;
+
+        public RadarrParser(RadarrSettings settings, ISearchForNewMovie skyhookProxy)
+        {
+            _skyhookProxy = skyhookProxy;//TinyIoC.TinyIoCContainer.Current.Resolve<ISearchForNewMovie>();
+            _settings = settings;
+        }
+
+        public IList<Tv.Movie> ParseResponse(NetImportResponse importResponse)
+        {
+            _importResponse = importResponse;
+
+            var movies = new List<Tv.Movie>();
+
+            if (!PreProcess(_importResponse))
+            {
+                return movies;
+            }
+
+            var jsonResponse = JsonConvert.DeserializeObject<List<MovieResult>>(_importResponse.Content);
+
+            // no movies were return
+            if (jsonResponse == null)
+            {
+                return movies;
+            }
+
+            return jsonResponse.SelectList(_skyhookProxy.MapMovie);
+
+            
+        }
+
+        protected virtual bool PreProcess(NetImportResponse indexerResponse)
+        {
+            try
+            {
+                var error = JsonConvert.DeserializeObject<RadarrError>(indexerResponse.HttpResponse.Content);
+
+                if (error != null && error.Errors != null && error.Errors.Count != 0)
+                {
+                    throw new RadarrAPIException(error);
+                }
+            }
+            catch (JsonSerializationException)
+            {
+                //No error!
+            }
+
+
+            if (indexerResponse.HttpResponse.StatusCode != System.Net.HttpStatusCode.OK)
+            {
+                throw new HttpException(indexerResponse.HttpRequest, indexerResponse.HttpResponse);
+            }
+
+            return true;
+        }
+
+    }
+}

src/NzbDrone.Core/NetImport/Radarr/RadarrProxied.cs

@@ -0,0 +1,84 @@
+using System.Collections.Generic;
+using NLog;
+using NzbDrone.Common.Http;
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.Parser;
+using NzbDrone.Core.ThingiProvider;
+using NzbDrone.Core.MetadataSource;
+
+
+namespace NzbDrone.Core.NetImport.Radarr
+{
+    public class RadarrProxied : HttpNetImportBase<RadarrSettings>
+    {
+        public override string Name => "Radarr Proxied Lists";
+        public override bool Enabled => true;
+        public override bool EnableAuto => false;
+
+        private readonly IHttpClient _httpClient;
+        private readonly Logger _logger;
+        private readonly ISearchForNewMovie _skyhookProxy;
+
+        public RadarrProxied(IHttpClient httpClient, IConfigService configService, IParsingService parsingService, ISearchForNewMovie skyhookProxy,
+            Logger logger)
+            : base(httpClient, configService, parsingService, logger)
+        {
+            _skyhookProxy = skyhookProxy;
+            _logger = logger;
+            _httpClient = httpClient;
+        }
+
+        public override IEnumerable<ProviderDefinition> GetDefaultDefinitions()
+        {
+                foreach (var def in base.GetDefaultDefinitions())
+                {
+                    yield return def;
+                }
+
+                yield return new NetImportDefinition
+                {
+                    Name = "IMDb Top 250",
+                    Enabled = Enabled,
+                    EnableAuto = true,
+                    ProfileId = 1,
+                    Implementation = GetType().Name,
+                    Settings = new RadarrSettings { Path = "/imdb/top250" },
+                };
+                yield return new NetImportDefinition
+                {
+                    Name = "IMDb Popular Movies",
+                    Enabled = Enabled,
+                    EnableAuto = true,
+                    ProfileId = 1,
+                    Implementation = GetType().Name,
+                    Settings = new RadarrSettings { Path = "/imdb/popular" },
+                };
+                yield return new NetImportDefinition
+                {
+                    Name = "IMDb List",
+                    Enabled = Enabled,
+                    EnableAuto = true,
+                    ProfileId = 1,
+                    Implementation = GetType().Name,
+                    Settings = new RadarrSettings { Path = "/imdb/list?listId=LISTID" },
+                };
+
+
+        }
+
+        public override INetImportRequestGenerator GetRequestGenerator()
+        {
+            return new RadarrRequestGenerator()
+            {
+                Settings = Settings,
+                Logger = _logger,
+                HttpClient = _httpClient
+            };
+        }
+
+        public override IParseNetImportResponse GetParser()
+        {
+            return new RadarrParser(Settings, _skyhookProxy);
+        }
+    }
+}

src/NzbDrone.Core/NetImport/Radarr/RadarrRequestGenerator.cs

@@ -0,0 +1,38 @@
+using System;
+using NzbDrone.Common.Http;
+using System.Collections.Generic;
+using NLog;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Common.Serializer;
+using NzbDrone.Core.MetadataSource.SkyHook.Resource;
+
+namespace NzbDrone.Core.NetImport.Radarr
+{
+    public class RadarrRequestGenerator : INetImportRequestGenerator
+    {
+        public RadarrSettings Settings { get; set; }
+        public IHttpClient HttpClient { get; set; }
+        public Logger Logger { get; set; }
+
+        public int MaxPages { get; set; }
+
+        public RadarrRequestGenerator()
+        {
+            MaxPages = 3;
+        }
+
+        public virtual NetImportPageableRequestChain GetMovies()
+        {
+            var pageableRequests = new NetImportPageableRequestChain();
+
+            var baseUrl = $"{Settings.APIURL.TrimEnd("/")}";
+
+            var request = new NetImportRequest($"{baseUrl}{Settings.Path}", HttpAccept.Json);
+
+            request.HttpRequest.SuppressHttpError = true;
+
+            pageableRequests.Add(new List<NetImportRequest> { request });
+            return pageableRequests;
+        }
+    }
+}

src/NzbDrone.Core/NetImport/Radarr/RadarrSettings.cs

@@ -0,0 +1,42 @@
+using FluentValidation;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Core.Annotations;
+using NzbDrone.Core.ThingiProvider;
+using NzbDrone.Core.Validation;
+using System.Text.RegularExpressions;
+using NzbDrone.Core.MetadataSource.RadarrAPI;
+
+namespace NzbDrone.Core.NetImport.Radarr
+{
+
+    public class RadarrSettingsValidator : AbstractValidator<RadarrSettings>
+    {
+        public RadarrSettingsValidator()
+        {
+            RuleFor(c => c.APIURL).ValidRootUrl();
+        }
+    }
+
+    public class RadarrSettings : IProviderConfig
+    {
+        private static readonly RadarrSettingsValidator Validator = new RadarrSettingsValidator();
+
+        public RadarrSettings()
+        {
+            APIURL = "https://api.radarr.video";
+            Path = "";
+        }
+
+        [FieldDefinition(0, Label = "Radarr API URL", HelpText = "Link to to Radarr API URL.Use https://staging.api.radarr.video if you are on nightly.")]
+        public string APIURL { get; set; }
+
+        [FieldDefinition(1, Label = "Path to list", HelpText = "Path to the list proxied by the Radarr API. Check the wiki for available lists.")]
+        public string Path { get; set; }
+
+        public NzbDroneValidationResult Validate()
+        {
+            return new NzbDroneValidationResult(Validator.Validate(this));
+        }
+    }
+
+}

src/NzbDrone.Core/NetImport/TMDb/TMDbImport.cs

@@ -1,6 +1,7 @@
 using NLog;
 using NzbDrone.Common.Http;
 using NzbDrone.Core.Configuration;
+using NzbDrone.Core.MetadataSource;
 using NzbDrone.Core.Parser;
 
 
@@ -14,13 +15,15 @@ namespace NzbDrone.Core.NetImport.TMDb
 
         private readonly IHttpClient _httpClient;
         private readonly Logger _logger;
+        private readonly ISearchForNewMovie _skyhookProxy;
 
-        public TMDbImport(IHttpClient httpClient, IConfigService configService, IParsingService parsingService,
+        public TMDbImport(IHttpClient httpClient, IConfigService configService, IParsingService parsingService, ISearchForNewMovie skyhookProxy,
             Logger logger)
             : base(httpClient, configService, parsingService, logger)
         {
             _logger = logger;
             _httpClient = httpClient;
+            _skyhookProxy = skyhookProxy;
         }
 
         public override INetImportRequestGenerator GetRequestGenerator()
@@ -35,7 +38,7 @@ namespace NzbDrone.Core.NetImport.TMDb
 
         public override IParseNetImportResponse GetParser()
         {
-            return new TMDbParser(Settings);
+            return new TMDbParser(Settings, _skyhookProxy);
         }
     }
 }

src/NzbDrone.Core/NetImport/TMDb/TMDbParser.cs

@@ -6,6 +6,8 @@ using System.Net;
 using NLog;
 using NzbDrone.Common.Extensions;
 using NzbDrone.Core.MetadataSource.SkyHook.Resource;
+using NzbDrone.Core.MetadataSource;
+using TinyIoC;
 
 namespace NzbDrone.Core.NetImport.TMDb
 {
@@ -13,10 +15,12 @@ namespace NzbDrone.Core.NetImport.TMDb
     {
         private readonly TMDbSettings _settings;
         private NetImportResponse _importResponse;
+        private readonly ISearchForNewMovie _skyhookProxy;
         private readonly Logger _logger;
 
-        public TMDbParser(TMDbSettings settings)
+        public TMDbParser(TMDbSettings settings, ISearchForNewMovie skyhookProxy)
         {
+            _skyhookProxy = skyhookProxy;
             _settings = settings;
         }
 
@@ -41,22 +45,7 @@ namespace NzbDrone.Core.NetImport.TMDb
                     return movies;
                 }
 
-                foreach (var movie in jsonResponse.results)
-                {
-                    // Movies with no Year Fix
-                    if (string.IsNullOrWhiteSpace(movie.release_date))
-                    {
-                        continue;
-                    }
-
-                    movies.AddIfNotNull(new Tv.Movie()
-                    {
-                        Title = movie.title,
-                        TmdbId = movie.id,
-                        ImdbId = null,
-                        Year = DateTime.Parse(movie.release_date).Year
-                    });
-                }
+                return jsonResponse.results.SelectList(_skyhookProxy.MapMovie);
             }
             else
             {
@@ -82,13 +71,7 @@ namespace NzbDrone.Core.NetImport.TMDb
                         continue;
                     }
 
-                    movies.AddIfNotNull(new Tv.Movie()
-                    {
-                        Title = movie.title,
-                        TmdbId = movie.id,
-                        ImdbId = null,
-                        Year = DateTime.Parse(movie.release_date).Year
-                    });
+                    movies.AddIfNotNull(_skyhookProxy.MapMovie(movie));
                 }
             }