New: Bump Version to V3 to please the masses

src/Radarr.Api.V3/NetImport/ImportExclusionsModule.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using FluentValidation;
+using NzbDrone.Core.NetImport;
+using NzbDrone.Core.NetImport.ImportExclusions;
+using Radarr.Http;
+
+namespace Radarr.Api.V3.NetImport
+{
+    public class ImportExclusionsModule : RadarrRestModule<ImportExclusionsResource>
+    {
+        private readonly IImportExclusionsService _exclusionService;
+
+        public ImportExclusionsModule(NetImportFactory netImportFactory, IImportExclusionsService exclusionService) : base("exclusions")
+        {
+            _exclusionService = exclusionService;
+            GetResourceAll = GetAll;
+            CreateResource = AddExclusion;
+            DeleteResource = RemoveExclusion;
+            GetResourceById = GetById;
+
+            SharedValidator.RuleFor(c => c.TmdbId).GreaterThan(0);
+            SharedValidator.RuleFor(c => c.MovieTitle).NotEmpty();
+            SharedValidator.RuleFor(c => c.MovieYear).GreaterThan(0);
+        }
+
+        public List<ImportExclusionsResource> GetAll()
+        {
+            return _exclusionService.GetAllExclusions().ToResource();
+        }
+
+        public ImportExclusionsResource GetById(int id)
+        {
+            return _exclusionService.GetById(id).ToResource();
+        }
+       
+        public int AddExclusion(ImportExclusionsResource exclusionResource)
+        {
+            var model = exclusionResource.ToModel();
+
+            // TODO: Add some more validation here and auto pull the title if not provided
+
+            return _exclusionService.AddExclusion(model).Id;
+        }
+
+        public void RemoveExclusion (int id)
+        {
+            _exclusionService.RemoveExclusion(new ImportExclusion { Id = id });
+        }
+    }
+}

src/Radarr.Api.V3/NetImport/ImportExclusionsResource.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using NzbDrone.Core.NetImport;
+using NzbDrone.Core.Movies;
+
+namespace Radarr.Api.V3.NetImport
+{
+    public class ImportExclusionsResource : ProviderResource
+    {
+        //public int Id { get; set; }
+        public int TmdbId { get; set; }
+        public string MovieTitle { get; set; }
+        public int MovieYear { get; set; }
+    }
+
+    public static class ImportExclusionsResourceMapper
+    {
+        public static ImportExclusionsResource ToResource(this NzbDrone.Core.NetImport.ImportExclusions.ImportExclusion model)
+        {
+            if (model == null) return null;
+
+            return new ImportExclusionsResource
+            {
+                Id = model.Id,
+                TmdbId = model.TmdbId,
+                MovieTitle = model.MovieTitle,
+                MovieYear = model.MovieYear
+            };
+        }
+
+        public static List<ImportExclusionsResource> ToResource(this IEnumerable<NzbDrone.Core.NetImport.ImportExclusions.ImportExclusion> exclusions)
+        {
+            return exclusions.Select(ToResource).ToList();
+        }
+
+        public static NzbDrone.Core.NetImport.ImportExclusions.ImportExclusion ToModel(this ImportExclusionsResource resource)
+        {
+            return new NzbDrone.Core.NetImport.ImportExclusions.ImportExclusion
+            {
+                TmdbId = resource.TmdbId,
+                MovieTitle = resource.MovieTitle,
+                MovieYear = resource.MovieYear
+            };
+        }
+    }
+}

src/Radarr.Api.V3/NetImport/ListImportModule.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using Nancy;
+using Nancy.Extensions;
+using Radarr.Http.Extensions;
+using Radarr.Api.V3.Movies;
+using NzbDrone.Core.MetadataSource;
+using NzbDrone.Core.Movies;
+
+namespace Radarr.Api.V3.NetImport
+{
+    public class ListImportModule : RadarrV3Module
+    {
+        private readonly IMovieService _movieService;
+        private readonly ISearchForNewMovie _movieSearch;
+
+        public ListImportModule(IMovieService movieService, ISearchForNewMovie movieSearch)
+            : base("/movie/import")
+        {
+            _movieService = movieService;
+            _movieSearch = movieSearch;
+            Put("/",  Movie => SaveAll());
+        }
+
+        private object SaveAll()
+        {
+            var resources = Request.Body.FromJson<List<MovieResource>>();
+
+            var Movies = resources.Select(MovieResource => _movieSearch.MapMovieToTmdbMovie(MovieResource.ToModel())).Where(m => m != null).DistinctBy(m => m.TmdbId).ToList();
+
+            return ResponseWithCode(_movieService.AddMovies(Movies).ToResource(), HttpStatusCode.Accepted);
+        }
+    }
+}

src/Radarr.Api.V3/NetImport/NetImportModule.cs

@@ -0,0 +1,26 @@
+using FluentValidation;
+using Radarr.Http.ClientSchema;
+using NzbDrone.Core.NetImport;
+using NzbDrone.Core.Validation.Paths;
+
+namespace Radarr.Api.V3.NetImport
+{
+    public class NetImportModule : ProviderModuleBase<NetImportResource, INetImport, NetImportDefinition>
+    {
+        public static readonly NetImportResourceMapper ResourceMapper = new NetImportResourceMapper();
+
+        public NetImportModule(NetImportFactory netImportFactory)
+            : base(netImportFactory, "netimport", ResourceMapper)
+        {
+            SharedValidator.RuleFor(c => c.RootFolderPath).IsValidPath();
+            SharedValidator.RuleFor(c => c.MinimumAvailability).NotNull();
+            SharedValidator.RuleFor(c => c.QualityProfileId).NotNull();
+        }
+
+        protected override void Validate(NetImportDefinition definition, bool includeWarnings)
+        {
+            if (!definition.Enable) return;
+            base.Validate(definition, includeWarnings);
+        }
+    }
+}

src/Radarr.Api.V3/NetImport/NetImportResource.cs

@@ -0,0 +1,56 @@
+using NzbDrone.Core.Movies;
+using NzbDrone.Core.NetImport;
+
+namespace Radarr.Api.V3.NetImport
+{
+    public class NetImportResource : ProviderResource
+    {
+        public bool Enabled { get; set; }
+        public bool EnableAuto { get; set; }
+        public bool ShouldMonitor { get; set; }
+        public string RootFolderPath { get; set; }
+        public int QualityProfileId { get; set; }
+        public MovieStatusType MinimumAvailability { get; set; }
+    }
+
+    public class NetImportResourceMapper : ProviderResourceMapper<NetImportResource, NetImportDefinition>
+    {
+        public override NetImportResource ToResource(NetImportDefinition definition)
+        {
+            if (definition == null)
+            {
+                return null;
+            }
+
+            var resource = base.ToResource(definition);
+
+            resource.Enabled = definition.Enabled;
+            resource.EnableAuto = definition.EnableAuto;
+            resource.ShouldMonitor = definition.ShouldMonitor;
+            resource.RootFolderPath = definition.RootFolderPath;
+            resource.QualityProfileId = definition.ProfileId;
+            resource.MinimumAvailability = definition.MinimumAvailability;
+
+            return resource;
+        }
+
+        public override NetImportDefinition ToModel(NetImportResource resource)
+        {
+            if (resource == null)
+            {
+                return null;
+            }
+
+            var definition = base.ToModel(resource);
+
+            definition.Enabled = resource.Enabled;
+            definition.EnableAuto = resource.EnableAuto;
+            definition.ShouldMonitor = resource.ShouldMonitor;
+            definition.RootFolderPath = resource.RootFolderPath;
+            definition.ProfileId = resource.QualityProfileId;
+            definition.MinimumAvailability = resource.MinimumAvailability;
+
+            return definition;
+        }
+    }
+}