mirror/Radarr
1
0
Fork 0
mirror of https://github.com/Radarr/Radarr synced 2025-02-24 15:21:28 +00:00
Code Issues Releases Wiki Activity

Rename ImportExclusion to ImportListExclusion

Browse source
This commit is contained in:
Bogdan 2024-08-11 17:12:32 +03:00 committed by Qstick
parent f76c97c3ce
commit b1a7652753
16 changed files with 253 additions and 213 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/NzbDrone.Core.Test/ImportListTests/ImportListSyncServiceFixture.cs
View file

@ -76,9 +76,9 @@ public void Setup()
.Setup(v => v.Enabled(It.IsAny<bool>()))
.Returns(_importLists);
Mocker.GetMock<IImportExclusionsService>()
.Setup(v => v.GetAllExclusions())
.Returns(new List<ImportExclusion>());
Mocker.GetMock<IImportListExclusionService>()
.Setup(v => v.All())
.Returns(new List<ImportListExclusion>());
Mocker.GetMock<IMovieService>()
.Setup(v => v.MovieExists(It.IsAny<Movie>()))
@ -167,8 +167,8 @@ public void should_not_clean_library_or_process_movies_if_no_synced_lists()
Mocker.GetMock<IMovieService>()
.Verify(v => v.UpdateMovie(new List<Movie>(), true), Times.Never());
Mocker.GetMock<IImportExclusionsService>()
.Verify(v => v.GetAllExclusions(), Times.Never);
Mocker.GetMock<IImportListExclusionService>()
.Verify(v => v.All(), Times.Never);
}
[Test]
@ -427,9 +427,9 @@ public void should_not_add_movie_from_on_exclusion_list()
GivenCleanLevel("disabled");
Mocker.GetMock<IImportExclusionsService>()
.Setup(v => v.GetAllExclusions())
.Returns(new List<ImportExclusion> { new ImportExclusion { TmdbId = _existingMovies[0].TmdbId } });
Mocker.GetMock<IImportListExclusionService>()
.Setup(v => v.All())
.Returns(new List<ImportListExclusion> { new ImportListExclusion { TmdbId = _existingMovies[0].TmdbId } });
Subject.Execute(_commandAll);

2
src/NzbDrone.Core/Datastore/TableMapping.cs
View file

@ -134,7 +134,7 @@ public static void Map()
Mapper.Entity<Credit>("Credits").RegisterModel();
Mapper.Entity<ImportExclusion>("ImportExclusions").RegisterModel();
Mapper.Entity<ImportListExclusion>("ImportExclusions").RegisterModel();
Mapper.Entity<QualityDefinition>("QualityDefinitions").RegisterModel()
.Ignore(d => d.GroupName)

95
src/NzbDrone.Core/ImportLists/ImportExclusions/ImportExclusionsService.cs
View file

@ -1,95 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using NLog;
using NzbDrone.Core.Messaging.Events;
using NzbDrone.Core.Movies.Events;
namespace NzbDrone.Core.ImportLists.ImportExclusions
{
public interface IImportExclusionsService
{
List<ImportExclusion> GetAllExclusions();
bool IsMovieExcluded(int tmdbId);
ImportExclusion AddExclusion(ImportExclusion exclusion);
List<ImportExclusion> AddExclusions(List<ImportExclusion> exclusions);
void RemoveExclusion(ImportExclusion exclusion);
ImportExclusion GetById(int id);
ImportExclusion Update(ImportExclusion exclusion);
}
public class ImportExclusionsService : IImportExclusionsService, IHandleAsync<MoviesDeletedEvent>
{
private readonly IImportExclusionsRepository _exclusionRepository;
private readonly Logger _logger;
public ImportExclusionsService(IImportExclusionsRepository exclusionRepository,
Logger logger)
{
_exclusionRepository = exclusionRepository;
_logger = logger;
}
public ImportExclusion AddExclusion(ImportExclusion exclusion)
{
if (_exclusionRepository.IsMovieExcluded(exclusion.TmdbId))
{
return _exclusionRepository.GetByTmdbid(exclusion.TmdbId);
}
return _exclusionRepository.Insert(exclusion);
}
public List<ImportExclusion> AddExclusions(List<ImportExclusion> exclusions)
{
_exclusionRepository.InsertMany(DeDupeExclusions(exclusions));
return exclusions;
}
public List<ImportExclusion> GetAllExclusions()
{
return _exclusionRepository.All().ToList();
}
public bool IsMovieExcluded(int tmdbId)
{
return _exclusionRepository.IsMovieExcluded(tmdbId);
}
public void RemoveExclusion(ImportExclusion exclusion)
{
_exclusionRepository.Delete(exclusion);
}
public ImportExclusion GetById(int id)
{
return _exclusionRepository.Get(id);
}
public ImportExclusion Update(ImportExclusion exclusion)
{
return _exclusionRepository.Update(exclusion);
}
public void HandleAsync(MoviesDeletedEvent message)
{
if (message.AddExclusion)
{
_logger.Debug("Adding {0} Deleted Movies to Import Exclusions", message.Movies.Count);
var exclusions = message.Movies.Select(m => new ImportExclusion { TmdbId = m.TmdbId, MovieTitle = m.Title, MovieYear = m.Year }).ToList();
_exclusionRepository.InsertMany(DeDupeExclusions(exclusions));
}
}
private List<ImportExclusion> DeDupeExclusions(List<ImportExclusion> exclusions)
{
var existingExclusions = _exclusionRepository.AllExcludedTmdbIds();
return exclusions
.DistinctBy(x => x.TmdbId)
.Where(x => !existingExclusions.Contains(x.TmdbId))
.ToList();
}
}
}

2
src/NzbDrone.Core/ImportLists/ImportExclusions/ImportExclusion.cs → src/NzbDrone.Core/ImportLists/ImportExclusions/ImportListExclusion.cs
View file

@ -2,7 +2,7 @@
namespace NzbDrone.Core.ImportLists.ImportExclusions
{
public class ImportExclusion : ModelBase
public class ImportListExclusion : ModelBase
{
public int TmdbId { get; set; }
public string MovieTitle { get; set; }

12
src/NzbDrone.Core/ImportLists/ImportExclusions/ImportExclusionsRepository.cs → src/NzbDrone.Core/ImportLists/ImportExclusions/ImportListExclusionRepository.cs
View file

@ -6,16 +6,16 @@
namespace NzbDrone.Core.ImportLists.ImportExclusions
{
public interface IImportExclusionsRepository : IBasicRepository<ImportExclusion>
public interface IImportListExclusionRepository : IBasicRepository<ImportListExclusion>
{
bool IsMovieExcluded(int tmdbid);
ImportExclusion GetByTmdbid(int tmdbid);
ImportListExclusion FindByTmdbid(int tmdbid);
List<int> AllExcludedTmdbIds();
}
public class ImportExclusionsRepository : BasicRepository<ImportExclusion>, IImportExclusionsRepository
public class ImportListListExclusionRepository : BasicRepository<ImportListExclusion>, IImportListExclusionRepository
{
public ImportExclusionsRepository(IMainDatabase database, IEventAggregator eventAggregator)
public ImportListListExclusionRepository(IMainDatabase database, IEventAggregator eventAggregator)
: base(database, eventAggregator)
{
}
@ -25,9 +25,9 @@ public bool IsMovieExcluded(int tmdbid)
return Query(x => x.TmdbId == tmdbid).Any();
}
public ImportExclusion GetByTmdbid(int tmdbid)
public ImportListExclusion FindByTmdbid(int tmdbid)
{
return Query(x => x.TmdbId == tmdbid).First();
return Query(x => x.TmdbId == tmdbid).SingleOrDefault();
}
public List<int> AllExcludedTmdbIds()

115
src/NzbDrone.Core/ImportLists/ImportExclusions/ImportListExclusionService.cs Normal file
View file

@ -0,0 +1,115 @@
using System.Collections.Generic;
using System.Linq;
using NLog;
using NzbDrone.Core.Messaging.Events;
using NzbDrone.Core.Movies.Events;
namespace NzbDrone.Core.ImportLists.ImportExclusions
{
public interface IImportListExclusionService
{
ImportListExclusion Add(ImportListExclusion importListExclusion);
List<ImportListExclusion> Add(List<ImportListExclusion> importListExclusions);
List<ImportListExclusion> All();
bool IsMovieExcluded(int tmdbId);
void Delete(int id);
void Delete(List<int> ids);
ImportListExclusion Get(int id);
ImportListExclusion Update(ImportListExclusion importListExclusion);
List<int> AllExcludedTmdbIds();
}
public class ImportListExclusionService : IImportListExclusionService, IHandleAsync<MoviesDeletedEvent>
{
private readonly IImportListExclusionRepository _repo;
private readonly Logger _logger;
public ImportListExclusionService(IImportListExclusionRepository repo,
Logger logger)
{
_repo = repo;
_logger = logger;
}
public ImportListExclusion Add(ImportListExclusion importListExclusion)
{
if (_repo.IsMovieExcluded(importListExclusion.TmdbId))
{
return _repo.FindByTmdbid(importListExclusion.TmdbId);
}
return _repo.Insert(importListExclusion);
}
public List<ImportListExclusion> Add(List<ImportListExclusion> importListExclusions)
{
_repo.InsertMany(DeDupeExclusions(importListExclusions));
return importListExclusions;
}
public bool IsMovieExcluded(int tmdbId)
{
return _repo.IsMovieExcluded(tmdbId);
}
public void Delete(int id)
{
_repo.Delete(id);
}
public void Delete(List<int> ids)
{
_repo.DeleteMany(ids);
}
public ImportListExclusion Get(int id)
{
return _repo.Get(id);
}
public ImportListExclusion Update(ImportListExclusion importListExclusion)
{
return _repo.Update(importListExclusion);
}
public List<ImportListExclusion> All()
{
return _repo.All().ToList();
}
public List<int> AllExcludedTmdbIds()
{
return _repo.AllExcludedTmdbIds();
}
public void HandleAsync(MoviesDeletedEvent message)
{
if (!message.AddImportListExclusion)
{
return;
}
_logger.Debug("Adding {0} deleted movies to import list exclusions.", message.Movies.Count);
var exclusionsToAdd = DeDupeExclusions(message.Movies.Select(m => new ImportListExclusion
{
TmdbId = m.TmdbId,
MovieTitle = m.Title,
MovieYear = m.Year
}).ToList());
_repo.InsertMany(exclusionsToAdd);
}
private List<ImportListExclusion> DeDupeExclusions(List<ImportListExclusion> exclusions)
{
var existingExclusions = _repo.AllExcludedTmdbIds();
return exclusions
.DistinctBy(x => x.TmdbId)
.Where(x => !existingExclusions.Contains(x.TmdbId))
.ToList();
}
}
}

10
src/NzbDrone.Core/ImportLists/ImportListSyncService.cs
View file

@ -19,7 +19,7 @@ public class ImportListSyncService : IExecute<ImportListSyncCommand>
private readonly IMovieService _movieService;
private readonly IAddMovieService _addMovieService;
private readonly IConfigService _configService;
private readonly IImportExclusionsService _exclusionService;
private readonly IImportListExclusionService _listExclusionService;
private readonly IImportListMovieService _listMovieService;
public ImportListSyncService(IImportListFactory importListFactory,
@ -27,7 +27,7 @@ public ImportListSyncService(IImportListFactory importListFactory,
IMovieService movieService,
IAddMovieService addMovieService,
IConfigService configService,
IImportExclusionsService exclusionService,
IImportListExclusionService listExclusionService,
IImportListMovieService listMovieService,
Logger logger)
{
@ -35,7 +35,7 @@ public ImportListSyncService(IImportListFactory importListFactory,
_listFetcherAndParser = listFetcherAndParser;
_movieService = movieService;
_addMovieService = addMovieService;
_exclusionService = exclusionService;
_listExclusionService = listExclusionService;
_listMovieService = listMovieService;
_logger = logger;
_configService = configService;
@ -74,7 +74,7 @@ private void SyncList(ImportListDefinition definition)
ProcessListItems(listItemsResult);
}
private void ProcessMovieReport(ImportListDefinition importList, ImportListMovie report, List<ImportExclusion> listExclusions, List<int> dbMovies, List<Movie> moviesToAdd)
private void ProcessMovieReport(ImportListDefinition importList, ImportListMovie report, List<ImportListExclusion> listExclusions, List<int> dbMovies, List<Movie> moviesToAdd)
{
if (report.TmdbId == 0 || !importList.EnableAuto)
{
@ -142,7 +142,7 @@ private void ProcessListItems(ImportListFetchResult listFetchResult)
var listedMovies = listFetchResult.Movies.ToList();
var importExclusions = _exclusionService.GetAllExclusions();
var importExclusions = _listExclusionService.All();
var dbMovies = _movieService.AllMovieTmdbIds();
var moviesToAdd = new List<Movie>();

6
src/NzbDrone.Core/Movies/Events/MoviesDeletedEvent.cs
View file

@ -7,13 +7,13 @@ public class MoviesDeletedEvent : IEvent
{
public List<Movie> Movies { get; private set; }
public bool DeleteFiles { get; private set; }
public bool AddExclusion { get; private set; }
public bool AddImportListExclusion { get; private set; }
public MoviesDeletedEvent(List<Movie> movies, bool deleteFiles, bool addExclusion)
public MoviesDeletedEvent(List<Movie> movies, bool deleteFiles, bool addImportListExclusion)
{
Movies = movies;
DeleteFiles = deleteFiles;
AddExclusion = addExclusion;
AddImportListExclusion = addImportListExclusion;
}
}
}

12
src/NzbDrone.Core/Movies/MovieService.cs
View file

@ -36,8 +36,8 @@ public interface IMovieService
List<Movie> GetMoviesByCollectionTmdbId(int collectionId);
List<Movie> GetMoviesBetweenDates(DateTime start, DateTime end, bool includeUnmonitored);
PagingSpec<Movie> MoviesWithoutFiles(PagingSpec<Movie> pagingSpec);
void DeleteMovie(int movieId, bool deleteFiles, bool addExclusion = false);
void DeleteMovies(List<int> movieIds, bool deleteFiles, bool addExclusion = false);
void DeleteMovie(int movieId, bool deleteFiles, bool addImportListExclusion = false);
void DeleteMovies(List<int> movieIds, bool deleteFiles, bool addImportListExclusion = false);
List<Movie> GetAllMovies();
Dictionary<int, List<int>> AllMovieTags();
Movie UpdateMovie(Movie movie);
@ -210,22 +210,22 @@ public List<int> AllMovieTmdbIds()
return _movieRepository.AllMovieTmdbIds();
}
public void DeleteMovie(int movieId, bool deleteFiles, bool addExclusion = false)
public void DeleteMovie(int movieId, bool deleteFiles, bool addImportListExclusion = false)
{
var movie = _movieRepository.Get(movieId);
_movieRepository.Delete(movieId);
_eventAggregator.PublishEvent(new MoviesDeletedEvent(new List<Movie> { movie }, deleteFiles, addExclusion));
_eventAggregator.PublishEvent(new MoviesDeletedEvent(new List<Movie> { movie }, deleteFiles, addImportListExclusion));
_logger.Info("Deleted movie {0}", movie);
}
public void DeleteMovies(List<int> movieIds, bool deleteFiles, bool addExclusion = false)
public void DeleteMovies(List<int> movieIds, bool deleteFiles, bool addImportListExclusion = false)
{
var moviesToDelete = _movieRepository.Get(movieIds).ToList();
_movieRepository.DeleteMany(movieIds);
_eventAggregator.PublishEvent(new MoviesDeletedEvent(moviesToDelete, deleteFiles, addExclusion));
_eventAggregator.PublishEvent(new MoviesDeletedEvent(moviesToDelete, deleteFiles, addImportListExclusion));
foreach (var movie in moviesToDelete)
{

8
src/NzbDrone.Core/Movies/RefreshCollectionService.cs
View file

@ -21,7 +21,7 @@ public class RefreshCollectionService : IExecute<RefreshCollectionsCommand>
private readonly IMovieService _movieService;
private readonly IMovieMetadataService _movieMetadataService;
private readonly IAddMovieService _addMovieService;
private readonly IImportExclusionsService _importExclusionService;
private readonly IImportListExclusionService _importListExclusionService;
private readonly IEventAggregator _eventAggregator;
private readonly Logger _logger;
@ -31,7 +31,7 @@ public RefreshCollectionService(IProvideMovieInfo movieInfo,
IMovieService movieService,
IMovieMetadataService movieMetadataService,
IAddMovieService addMovieService,
IImportExclusionsService importExclusionsService,
IImportListExclusionService importListExclusionService,
IEventAggregator eventAggregator,
Logger logger)
{
@ -40,7 +40,7 @@ public RefreshCollectionService(IProvideMovieInfo movieInfo,
_movieService = movieService;
_movieMetadataService = movieMetadataService;
_addMovieService = addMovieService;
_importExclusionService = importExclusionsService;
_importListExclusionService = importListExclusionService;
_eventAggregator = eventAggregator;
_logger = logger;
}
@ -127,7 +127,7 @@ private void SyncCollectionMovies(MovieCollection collection)
{
var existingMovies = _movieService.AllMovieTmdbIds();
var collectionMovies = _movieMetadataService.GetMoviesByCollectionTmdbId(collection.TmdbId);
var excludedMovies = _importExclusionService.GetAllExclusions().Select(e => e.TmdbId);
var excludedMovies = _importListExclusionService.All().Select(e => e.TmdbId);
var moviesToAdd = collectionMovies.Where(m => !existingMovies.Contains(m.TmdbId)).Where(m => !excludedMovies.Contains(m.TmdbId));
if (moviesToAdd.Any())

10
src/Radarr.Api.V3/Collections/CollectionController.cs
View file

@ -31,7 +31,7 @@ public class CollectionController : RestControllerWithSignalR<CollectionResource
private readonly IMovieService _movieService;
private readonly IMovieMetadataService _movieMetadataService;
private readonly IMovieTranslationService _movieTranslationService;
private readonly IImportExclusionsService _importExclusionService;
private readonly IImportListExclusionService _importListExclusionService;
private readonly IConfigService _configService;
private readonly IBuildFileNames _fileNameBuilder;
private readonly INamingConfigService _namingService;
@ -42,7 +42,7 @@ public CollectionController(IBroadcastSignalRMessage signalRBroadcaster,
IMovieService movieService,
IMovieMetadataService movieMetadataService,
IMovieTranslationService movieTranslationService,
IImportExclusionsService importExclusionsService,
IImportListExclusionService importListExclusionService,
IConfigService configService,
IBuildFileNames fileNameBuilder,
INamingConfigService namingService,
@ -53,7 +53,7 @@ public CollectionController(IBroadcastSignalRMessage signalRBroadcaster,
_movieService = movieService;
_movieMetadataService = movieMetadataService;
_movieTranslationService = movieTranslationService;
_importExclusionService = importExclusionsService;
_importListExclusionService = importListExclusionService;
_configService = configService;
_fileNameBuilder = fileNameBuilder;
_namingService = namingService;
@ -158,7 +158,7 @@ private IEnumerable<CollectionResource> MapToResource(List<MovieCollection> coll
var configLanguage = (Language)_configService.MovieInfoLanguage;
var existingMoviesTmdbIds = _movieService.AllMovieWithCollectionsTmdbIds();
var listExclusions = _importExclusionService.GetAllExclusions();
var listExclusions = _importListExclusionService.All();
var allCollectionMovies = _movieMetadataService.GetMoviesWithCollections()
.GroupBy(x => x.CollectionTmdbId)
@ -209,7 +209,7 @@ private CollectionResource MapToResource(MovieCollection collection)
var configLanguage = (Language)_configService.MovieInfoLanguage;
var existingMoviesTmdbIds = _movieService.AllMovieWithCollectionsTmdbIds();
var listExclusions = _importExclusionService.GetAllExclusions();
var listExclusions = _importListExclusionService.All();
foreach (var movie in _movieMetadataService.GetMoviesByCollectionTmdbId(collection.TmdbId))
{

67
src/Radarr.Api.V3/ImportLists/ImportExclusionsController.cs
View file

@ -1,67 +0,0 @@
using System.Collections.Generic;
using FluentValidation;
using Microsoft.AspNetCore.Mvc;
using NzbDrone.Core.ImportLists.ImportExclusions;
using Radarr.Http;
using Radarr.Http.REST;
using Radarr.Http.REST.Attributes;
namespace Radarr.Api.V3.ImportLists
{
[V3ApiController("exclusions")]
public class ImportExclusionsController : RestController<ImportExclusionsResource>
{
private readonly IImportExclusionsService _exclusionService;
public ImportExclusionsController(IImportExclusionsService exclusionService)
{
_exclusionService = exclusionService;
SharedValidator.RuleFor(c => c.TmdbId).GreaterThan(0);
SharedValidator.RuleFor(c => c.MovieTitle).NotEmpty();
SharedValidator.RuleFor(c => c.MovieYear).GreaterThan(0);
}
[HttpGet]
public List<ImportExclusionsResource> GetAll()
{
return _exclusionService.GetAllExclusions().ToResource();
}
protected override ImportExclusionsResource GetResourceById(int id)
{
return _exclusionService.GetById(id).ToResource();
}
[RestPutById]
[Consumes("application/json")]
public ActionResult<ImportExclusionsResource> UpdateExclusion([FromBody] ImportExclusionsResource exclusionResource)
{
var model = exclusionResource.ToModel();
return Accepted(_exclusionService.Update(model));
}
[RestPostById]
[Consumes("application/json")]
public ActionResult<ImportExclusionsResource> AddExclusion([FromBody] ImportExclusionsResource exclusionResource)
{
var model = exclusionResource.ToModel();
return Created(_exclusionService.AddExclusion(model).Id);
}
[HttpPost("bulk")]
public object AddExclusions([FromBody] List<ImportExclusionsResource> resource)
{
var newMovies = resource.ToModel();
return _exclusionService.AddExclusions(newMovies).ToResource();
}
[RestDeleteById]
public void RemoveExclusion(int id)
{
_exclusionService.RemoveExclusion(new ImportExclusion { Id = id });
}
}
}

9
src/Radarr.Api.V3/ImportLists/ImportListExclusionBulkResource.cs Normal file
View file

@ -0,0 +1,9 @@
using System.Collections.Generic;
namespace Radarr.Api.V3.ImportLists
{
public class ImportListExclusionBulkResource
{
public HashSet<int> Ids { get; set; }
}
}

78
src/Radarr.Api.V3/ImportLists/ImportListExclusionController.cs Normal file
View file

@ -0,0 +1,78 @@
using System.Collections.Generic;
using System.Linq;
using FluentValidation;
using Microsoft.AspNetCore.Mvc;
using NzbDrone.Core.ImportLists.ImportExclusions;
using Radarr.Http;
using Radarr.Http.REST;
using Radarr.Http.REST.Attributes;
namespace Radarr.Api.V3.ImportLists
{
[V3ApiController("exclusions")]
public class ImportListExclusionController : RestController<ImportListExclusionResource>
{
private readonly IImportListExclusionService _importListExclusionService;
public ImportListExclusionController(IImportListExclusionService importListExclusionService)
{
_importListExclusionService = importListExclusionService;
SharedValidator.RuleFor(c => c.TmdbId).GreaterThan(0);
SharedValidator.RuleFor(c => c.MovieTitle).NotEmpty();
SharedValidator.RuleFor(c => c.MovieYear).GreaterThan(0);
}
[HttpGet]
[Produces("application/json")]
public List<ImportListExclusionResource> GetImportListExclusions()
{
return _importListExclusionService.All().ToResource();
}
protected override ImportListExclusionResource GetResourceById(int id)
{
return _importListExclusionService.Get(id).ToResource();
}
[RestPostById]
[Consumes("application/json")]
public ActionResult<ImportListExclusionResource> AddImportListExclusion([FromBody] ImportListExclusionResource resource)
{
var importListExclusion = _importListExclusionService.Add(resource.ToModel());
return Created(importListExclusion.Id);
}
[RestPutById]
[Consumes("application/json")]
public ActionResult<ImportListExclusionResource> UpdateImportListExclusion([FromBody] ImportListExclusionResource resource)
{
_importListExclusionService.Update(resource.ToModel());
return Accepted(resource.Id);
}
[HttpPost("bulk")]
public object AddImportListExclusions([FromBody] List<ImportListExclusionResource> resources)
{
var importListExclusions = _importListExclusionService.Add(resources.ToModel());
return importListExclusions.ToResource();
}
[RestDeleteById]
public void DeleteImportListExclusion(int id)
{
_importListExclusionService.Delete(id);
}
[HttpDelete("bulk")]
[Produces("application/json")]
public object DeleteImportListExclusions([FromBody] ImportListExclusionBulkResource resource)
{
_importListExclusionService.Delete(resource.Ids.ToList());
return new { };
}
}
}

16
src/Radarr.Api.V3/ImportLists/ImportExclusionsResource.cs → src/Radarr.Api.V3/ImportLists/ImportListExclusionResource.cs
View file

@ -4,7 +4,7 @@
namespace Radarr.Api.V3.ImportLists
{
public class ImportExclusionsResource : ProviderResource<ImportExclusionsResource>
public class ImportListExclusionResource : ProviderResource<ImportListExclusionResource>
{
// public int Id { get; set; }
public int TmdbId { get; set; }
@ -12,16 +12,16 @@ public class ImportExclusionsResource : ProviderResource<ImportExclusionsResourc
public int MovieYear { get; set; }
}
public static class ImportExclusionsResourceMapper
public static class ImportListExclusionResourceMapper
{
public static ImportExclusionsResource ToResource(this ImportExclusion model)
public static ImportListExclusionResource ToResource(this ImportListExclusion model)
{
if (model == null)
{
return null;
}
return new ImportExclusionsResource
return new ImportListExclusionResource
{
Id = model.Id,
TmdbId = model.TmdbId,
@ -30,14 +30,14 @@ public static ImportExclusionsResource ToResource(this ImportExclusion model)
};
}
public static List<ImportExclusionsResource> ToResource(this IEnumerable<ImportExclusion> exclusions)
public static List<ImportListExclusionResource> ToResource(this IEnumerable<ImportListExclusion> exclusions)
{
return exclusions.Select(ToResource).ToList();
}
public static ImportExclusion ToModel(this ImportExclusionsResource resource)
public static ImportListExclusion ToModel(this ImportListExclusionResource resource)
{
return new ImportExclusion
return new ImportListExclusion
{
Id = resource.Id,
TmdbId = resource.TmdbId,
@ -46,7 +46,7 @@ public static ImportExclusion ToModel(this ImportExclusionsResource resource)
};
}
public static List<ImportExclusion> ToModel(this IEnumerable<ImportExclusionsResource> resources)
public static List<ImportListExclusion> ToModel(this IEnumerable<ImportListExclusionResource> resources)
{
return resources.Select(ToModel).ToList();
}

8
src/Radarr.Api.V3/ImportLists/ImportListMoviesController.cs
View file

@ -25,7 +25,7 @@ public class ImportListMoviesController : Controller
private readonly IBuildFileNames _fileNameBuilder;
private readonly IImportListMovieService _listMovieService;
private readonly IImportListFactory _importListFactory;
private readonly IImportExclusionsService _importExclusionService;
private readonly IImportListExclusionService _importListExclusionService;
private readonly INamingConfigService _namingService;
private readonly IMovieTranslationService _movieTranslationService;
private readonly IConfigService _configService;
@ -36,7 +36,7 @@ public ImportListMoviesController(IMovieService movieService,
IBuildFileNames fileNameBuilder,
IImportListMovieService listMovieService,
IImportListFactory importListFactory,
IImportExclusionsService importExclusionsService,
IImportListExclusionService importListExclusionService,
INamingConfigService namingService,
IMovieTranslationService movieTranslationService,
IConfigService configService)
@ -47,7 +47,7 @@ public ImportListMoviesController(IMovieService movieService,
_fileNameBuilder = fileNameBuilder;
_listMovieService = listMovieService;
_importListFactory = importListFactory;
_importExclusionService = importExclusionsService;
_importListExclusionService = importListExclusionService;
_namingService = namingService;
_movieTranslationService = movieTranslationService;
_configService = configService;
@ -59,7 +59,7 @@ public object GetDiscoverMovies(bool includeRecommendations = false, bool includ
var movieLanguage = (Language)_configService.MovieInfoLanguage;
var realResults = new List<ImportListMoviesResource>();
var listExclusions = _importExclusionService.GetAllExclusions();
var listExclusions = _importListExclusionService.All();
var existingTmdbIds = _movieService.AllMovieTmdbIds();
if (includeRecommendations)