2018-03-14 20:41:36 +00:00
|
|
|
using System;
|
2016-12-29 15:04:01 +00:00
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Linq;
|
|
|
|
using NLog;
|
|
|
|
using NzbDrone.Common.EnsureThat;
|
|
|
|
using NzbDrone.Common.Extensions;
|
2019-12-22 22:08:53 +00:00
|
|
|
using NzbDrone.Core.Configuration;
|
|
|
|
using NzbDrone.Core.Datastore;
|
2017-01-03 19:24:55 +00:00
|
|
|
using NzbDrone.Core.MediaFiles;
|
|
|
|
using NzbDrone.Core.MediaFiles.Events;
|
2019-12-22 22:08:53 +00:00
|
|
|
using NzbDrone.Core.Messaging.Events;
|
2018-03-14 20:41:36 +00:00
|
|
|
using NzbDrone.Core.Movies.Events;
|
2019-12-22 22:08:53 +00:00
|
|
|
using NzbDrone.Core.Parser;
|
2019-12-18 21:56:41 +00:00
|
|
|
using NzbDrone.Core.Parser.RomanNumerals;
|
2016-12-29 15:04:01 +00:00
|
|
|
|
2018-03-14 20:41:36 +00:00
|
|
|
namespace NzbDrone.Core.Movies
|
2016-12-29 15:04:01 +00:00
|
|
|
{
|
|
|
|
public interface IMovieService
|
|
|
|
{
|
|
|
|
Movie GetMovie(int movieId);
|
|
|
|
List<Movie> GetMovies(IEnumerable<int> movieIds);
|
2019-12-22 21:24:10 +00:00
|
|
|
PagingSpec<Movie> Paged(PagingSpec<Movie> pagingSpec);
|
2016-12-29 15:04:01 +00:00
|
|
|
Movie AddMovie(Movie newMovie);
|
2017-01-27 18:36:25 +00:00
|
|
|
List<Movie> AddMovies(List<Movie> newMovies);
|
2016-12-29 15:04:01 +00:00
|
|
|
Movie FindByImdbId(string imdbid);
|
2019-11-27 14:19:35 +00:00
|
|
|
Movie FindByTmdbId(int tmdbid);
|
2019-12-18 21:56:41 +00:00
|
|
|
List<Movie> FindByTmdbId(List<int> tmdbids);
|
2016-12-29 15:04:01 +00:00
|
|
|
Movie FindByTitle(string title);
|
|
|
|
Movie FindByTitle(string title, int year);
|
2020-10-07 20:45:04 +00:00
|
|
|
Movie FindByTitle(string title, int? year, string arabicTitle, string romanTitle, List<Movie> candidates);
|
|
|
|
List<Movie> FindByTitleCandidates(string title, out string roman, out string arabic);
|
2017-01-09 22:16:54 +00:00
|
|
|
Movie FindByTitleSlug(string slug);
|
2019-07-16 02:27:35 +00:00
|
|
|
Movie FindByPath(string path);
|
2019-12-18 21:56:41 +00:00
|
|
|
List<string> AllMoviePaths();
|
2020-09-04 02:50:56 +00:00
|
|
|
List<int> AllMovieTmdbIds();
|
2017-01-23 13:04:01 +00:00
|
|
|
bool MovieExists(Movie movie);
|
2020-01-09 03:08:26 +00:00
|
|
|
List<Movie> GetMoviesByFileId(int fileId);
|
2017-01-16 21:40:59 +00:00
|
|
|
List<Movie> GetMoviesBetweenDates(DateTime start, DateTime end, bool includeUnmonitored);
|
2017-01-18 18:53:17 +00:00
|
|
|
PagingSpec<Movie> MoviesWithoutFiles(PagingSpec<Movie> pagingSpec);
|
2019-12-22 21:24:10 +00:00
|
|
|
void SetFileId(Movie movie, MovieFile movieFile);
|
2017-02-25 21:38:52 +00:00
|
|
|
void DeleteMovie(int movieId, bool deleteFiles, bool addExclusion = false);
|
2020-06-05 03:35:02 +00:00
|
|
|
void DeleteMovies(List<int> movieIds, bool deleteFiles, bool addExclusion = false);
|
2016-12-29 15:04:01 +00:00
|
|
|
List<Movie> GetAllMovies();
|
2018-11-23 07:03:32 +00:00
|
|
|
List<Movie> AllForTag(int tagId);
|
2016-12-29 15:04:01 +00:00
|
|
|
Movie UpdateMovie(Movie movie);
|
2020-01-12 03:13:28 +00:00
|
|
|
List<Movie> UpdateMovie(List<Movie> movie, bool useExistingRelativeFolder);
|
2017-07-08 14:13:28 +00:00
|
|
|
List<Movie> FilterExistingMovies(List<Movie> movies);
|
2020-09-04 02:50:56 +00:00
|
|
|
List<int> GetRecommendedTmdbIds();
|
2016-12-29 15:04:01 +00:00
|
|
|
bool MoviePathExists(string folder);
|
2017-01-03 12:26:09 +00:00
|
|
|
void RemoveAddOptions(Movie movie);
|
2016-12-29 15:04:01 +00:00
|
|
|
}
|
|
|
|
|
2017-01-03 19:24:55 +00:00
|
|
|
public class MovieService : IMovieService, IHandle<MovieFileAddedEvent>,
|
|
|
|
IHandle<MovieFileDeletedEvent>
|
2016-12-29 15:04:01 +00:00
|
|
|
{
|
|
|
|
private readonly IMovieRepository _movieRepository;
|
2017-02-25 02:30:12 +00:00
|
|
|
private readonly IConfigService _configService;
|
2016-12-29 15:04:01 +00:00
|
|
|
private readonly IEventAggregator _eventAggregator;
|
2020-01-12 03:13:28 +00:00
|
|
|
private readonly IBuildMoviePaths _moviePathBuilder;
|
2016-12-29 15:04:01 +00:00
|
|
|
private readonly Logger _logger;
|
|
|
|
|
|
|
|
public MovieService(IMovieRepository movieRepository,
|
2020-07-22 03:04:20 +00:00
|
|
|
IEventAggregator eventAggregator,
|
|
|
|
IConfigService configService,
|
|
|
|
IBuildMoviePaths moviePathBuilder,
|
|
|
|
Logger logger)
|
2016-12-29 15:04:01 +00:00
|
|
|
{
|
|
|
|
_movieRepository = movieRepository;
|
2017-02-25 21:47:18 +00:00
|
|
|
_eventAggregator = eventAggregator;
|
2017-02-25 02:30:12 +00:00
|
|
|
_configService = configService;
|
2020-01-12 03:13:28 +00:00
|
|
|
_moviePathBuilder = moviePathBuilder;
|
2016-12-29 15:04:01 +00:00
|
|
|
_logger = logger;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Movie GetMovie(int movieId)
|
|
|
|
{
|
|
|
|
return _movieRepository.Get(movieId);
|
|
|
|
}
|
|
|
|
|
|
|
|
public List<Movie> GetMovies(IEnumerable<int> movieIds)
|
|
|
|
{
|
|
|
|
return _movieRepository.Get(movieIds).ToList();
|
|
|
|
}
|
|
|
|
|
2019-12-22 21:24:10 +00:00
|
|
|
public PagingSpec<Movie> Paged(PagingSpec<Movie> pagingSpec)
|
|
|
|
{
|
|
|
|
return _movieRepository.GetPaged(pagingSpec);
|
|
|
|
}
|
2017-02-24 18:52:40 +00:00
|
|
|
|
2016-12-29 15:04:01 +00:00
|
|
|
public Movie AddMovie(Movie newMovie)
|
|
|
|
{
|
|
|
|
_movieRepository.Insert(newMovie);
|
|
|
|
_eventAggregator.PublishEvent(new MovieAddedEvent(GetMovie(newMovie.Id)));
|
|
|
|
|
|
|
|
return newMovie;
|
|
|
|
}
|
|
|
|
|
2017-01-27 18:36:25 +00:00
|
|
|
public List<Movie> AddMovies(List<Movie> newMovies)
|
|
|
|
{
|
|
|
|
_movieRepository.InsertMany(newMovies);
|
2018-11-23 07:03:32 +00:00
|
|
|
_eventAggregator.PublishEvent(new MoviesImportedEvent(newMovies.Select(s => s.Id).ToList()));
|
2017-01-27 18:36:25 +00:00
|
|
|
|
|
|
|
return newMovies;
|
|
|
|
}
|
|
|
|
|
2016-12-29 15:04:01 +00:00
|
|
|
public Movie FindByTitle(string title)
|
|
|
|
{
|
2020-10-07 20:45:04 +00:00
|
|
|
var candidates = FindByTitleCandidates(title, out var arabicTitle, out var romanTitle);
|
|
|
|
|
|
|
|
return FindByTitle(title, null, arabicTitle, romanTitle, candidates);
|
2019-12-18 21:56:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public Movie FindByTitle(string title, int year)
|
|
|
|
{
|
2020-10-07 20:45:04 +00:00
|
|
|
var candidates = FindByTitleCandidates(title, out var arabicTitle, out var romanTitle);
|
|
|
|
|
|
|
|
return FindByTitle(title, year, arabicTitle, romanTitle, candidates);
|
2019-12-18 21:56:41 +00:00
|
|
|
}
|
|
|
|
|
2020-10-07 20:45:04 +00:00
|
|
|
public Movie FindByTitle(string cleanTitle, int? year, string arabicTitle, string romanTitle, List<Movie> candidates)
|
2019-12-18 21:56:41 +00:00
|
|
|
{
|
|
|
|
var result = candidates.Where(x => x.CleanTitle == cleanTitle).FirstWithYear(year);
|
|
|
|
|
|
|
|
if (result == null)
|
|
|
|
{
|
|
|
|
result =
|
2020-10-07 20:45:04 +00:00
|
|
|
candidates.Where(movie => movie.CleanTitle == arabicTitle).FirstWithYear(year) ??
|
|
|
|
candidates.Where(movie => movie.CleanTitle == romanTitle).FirstWithYear(year);
|
2020-07-22 03:04:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (result == null)
|
|
|
|
{
|
|
|
|
result = candidates
|
|
|
|
.Where(m => m.AlternativeTitles.Any(t => t.CleanTitle == cleanTitle ||
|
2020-10-07 20:45:04 +00:00
|
|
|
t.CleanTitle == arabicTitle ||
|
|
|
|
t.CleanTitle == romanTitle))
|
2020-07-22 03:04:20 +00:00
|
|
|
.FirstWithYear(year);
|
|
|
|
}
|
2019-12-18 21:56:41 +00:00
|
|
|
|
2020-07-22 03:04:20 +00:00
|
|
|
if (result == null)
|
|
|
|
{
|
|
|
|
result = candidates
|
|
|
|
.Where(m => m.Translations.Any(t => t.CleanTitle == cleanTitle ||
|
2020-10-07 20:45:04 +00:00
|
|
|
t.CleanTitle == arabicTitle ||
|
|
|
|
t.CleanTitle == romanTitle))
|
2020-07-22 03:04:20 +00:00
|
|
|
.FirstWithYear(year);
|
2019-12-18 21:56:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
2016-12-29 15:04:01 +00:00
|
|
|
}
|
|
|
|
|
2020-10-07 20:45:04 +00:00
|
|
|
public List<Movie> FindByTitleCandidates(string title, out string arabicTitle, out string romanTitle)
|
|
|
|
{
|
|
|
|
var cleanTitle = title.CleanMovieTitle().ToLowerInvariant();
|
|
|
|
romanTitle = cleanTitle;
|
|
|
|
arabicTitle = cleanTitle;
|
|
|
|
|
|
|
|
foreach (var arabicRomanNumeral in RomanNumeralParser.GetArabicRomanNumeralsMapping())
|
|
|
|
{
|
|
|
|
var arabicNumber = arabicRomanNumeral.ArabicNumeralAsString;
|
|
|
|
var romanNumber = arabicRomanNumeral.RomanNumeral;
|
|
|
|
|
|
|
|
romanTitle = romanTitle.Replace(arabicNumber, romanNumber);
|
|
|
|
arabicTitle = arabicTitle.Replace(romanNumber, arabicNumber);
|
|
|
|
}
|
|
|
|
|
|
|
|
romanTitle = romanTitle.ToLowerInvariant();
|
|
|
|
|
|
|
|
return _movieRepository.FindByTitles(new List<string> { cleanTitle, arabicTitle, romanTitle });
|
|
|
|
}
|
|
|
|
|
2016-12-29 15:04:01 +00:00
|
|
|
public Movie FindByImdbId(string imdbid)
|
|
|
|
{
|
|
|
|
return _movieRepository.FindByImdbId(imdbid);
|
|
|
|
}
|
|
|
|
|
2019-11-27 14:19:35 +00:00
|
|
|
public Movie FindByTmdbId(int tmdbid)
|
|
|
|
{
|
|
|
|
return _movieRepository.FindByTmdbId(tmdbid);
|
|
|
|
}
|
|
|
|
|
2019-12-18 21:56:41 +00:00
|
|
|
public List<Movie> FindByTmdbId(List<int> tmdbids)
|
|
|
|
{
|
|
|
|
return _movieRepository.FindByTmdbId(tmdbids);
|
|
|
|
}
|
|
|
|
|
|
|
|
public Movie FindByPath(string path)
|
2016-12-29 15:04:01 +00:00
|
|
|
{
|
2019-12-18 21:56:41 +00:00
|
|
|
return _movieRepository.FindByPath(path);
|
2016-12-29 15:04:01 +00:00
|
|
|
}
|
|
|
|
|
2019-12-18 21:56:41 +00:00
|
|
|
public List<string> AllMoviePaths()
|
2019-07-16 02:27:35 +00:00
|
|
|
{
|
2019-12-18 21:56:41 +00:00
|
|
|
return _movieRepository.AllMoviePaths();
|
2019-07-16 02:27:35 +00:00
|
|
|
}
|
|
|
|
|
2020-09-04 02:50:56 +00:00
|
|
|
public List<int> AllMovieTmdbIds()
|
|
|
|
{
|
|
|
|
return _movieRepository.AllMovieTmdbIds();
|
|
|
|
}
|
|
|
|
|
2017-02-25 21:38:52 +00:00
|
|
|
public void DeleteMovie(int movieId, bool deleteFiles, bool addExclusion = false)
|
2016-12-29 15:04:01 +00:00
|
|
|
{
|
|
|
|
var movie = _movieRepository.Get(movieId);
|
2019-12-22 22:08:53 +00:00
|
|
|
|
2016-12-29 15:04:01 +00:00
|
|
|
_movieRepository.Delete(movieId);
|
2020-06-05 03:35:02 +00:00
|
|
|
_eventAggregator.PublishEvent(new MoviesDeletedEvent(new List<Movie> { movie }, deleteFiles, addExclusion));
|
|
|
|
_logger.Info("Deleted movie {0}", movie);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void DeleteMovies(List<int> movieIds, bool deleteFiles, bool addExclusion = false)
|
|
|
|
{
|
|
|
|
var moviesToDelete = _movieRepository.Get(movieIds).ToList();
|
|
|
|
|
|
|
|
_movieRepository.DeleteMany(movieIds);
|
|
|
|
|
|
|
|
_eventAggregator.PublishEvent(new MoviesDeletedEvent(moviesToDelete, deleteFiles, addExclusion));
|
|
|
|
|
|
|
|
foreach (var movie in moviesToDelete)
|
|
|
|
{
|
|
|
|
_logger.Info("Deleted movie {0}", movie);
|
|
|
|
}
|
2016-12-29 15:04:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public List<Movie> GetAllMovies()
|
|
|
|
{
|
|
|
|
return _movieRepository.All().ToList();
|
|
|
|
}
|
|
|
|
|
2018-11-23 07:03:32 +00:00
|
|
|
public List<Movie> AllForTag(int tagId)
|
|
|
|
{
|
|
|
|
return GetAllMovies().Where(s => s.Tags.Contains(tagId))
|
|
|
|
.ToList();
|
|
|
|
}
|
|
|
|
|
2016-12-29 15:04:01 +00:00
|
|
|
public Movie UpdateMovie(Movie movie)
|
|
|
|
{
|
|
|
|
var storedMovie = GetMovie(movie.Id);
|
|
|
|
|
|
|
|
var updatedMovie = _movieRepository.Update(movie);
|
|
|
|
_eventAggregator.PublishEvent(new MovieEditedEvent(updatedMovie, storedMovie));
|
|
|
|
|
|
|
|
return updatedMovie;
|
|
|
|
}
|
|
|
|
|
2020-01-12 03:13:28 +00:00
|
|
|
public List<Movie> UpdateMovie(List<Movie> movie, bool useExistingRelativeFolder)
|
2016-12-29 15:04:01 +00:00
|
|
|
{
|
|
|
|
_logger.Debug("Updating {0} movie", movie.Count);
|
2020-01-12 03:13:28 +00:00
|
|
|
foreach (var m in movie)
|
2016-12-29 15:04:01 +00:00
|
|
|
{
|
2020-01-12 03:13:28 +00:00
|
|
|
_logger.Trace("Updating: {0}", m.Title);
|
|
|
|
|
|
|
|
if (!m.RootFolderPath.IsNullOrWhiteSpace())
|
2016-12-29 15:04:01 +00:00
|
|
|
{
|
2020-01-12 03:13:28 +00:00
|
|
|
m.Path = _moviePathBuilder.BuildPath(m, useExistingRelativeFolder);
|
|
|
|
|
|
|
|
_logger.Trace("Changing path for {0} to {1}", m.Title, m.Path);
|
2016-12-29 15:04:01 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-01-12 03:13:28 +00:00
|
|
|
_logger.Trace("Not changing path for: {0}", m.Title);
|
2016-12-29 15:04:01 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-05 14:28:05 +00:00
|
|
|
|
2016-12-29 15:04:01 +00:00
|
|
|
_movieRepository.UpdateMany(movie);
|
|
|
|
_logger.Debug("{0} movie updated", movie.Count);
|
|
|
|
|
|
|
|
return movie;
|
|
|
|
}
|
|
|
|
|
|
|
|
public bool MoviePathExists(string folder)
|
|
|
|
{
|
|
|
|
return _movieRepository.MoviePathExists(folder);
|
|
|
|
}
|
|
|
|
|
2017-01-03 12:26:09 +00:00
|
|
|
public void RemoveAddOptions(Movie movie)
|
|
|
|
{
|
|
|
|
_movieRepository.SetFields(movie, s => s.AddOptions);
|
|
|
|
}
|
2017-01-03 19:24:55 +00:00
|
|
|
|
2019-12-22 21:24:10 +00:00
|
|
|
public void SetFileId(Movie movie, MovieFile movieFile)
|
|
|
|
{
|
|
|
|
_movieRepository.SetFileId(movieFile.Id, movie.Id);
|
|
|
|
_logger.Info("Linking [{0}] > [{1}]", movieFile.RelativePath, movie);
|
|
|
|
}
|
2017-02-25 12:50:12 +00:00
|
|
|
|
2020-01-09 03:08:26 +00:00
|
|
|
public List<Movie> GetMoviesByFileId(int fileId)
|
2017-01-03 19:24:55 +00:00
|
|
|
{
|
2020-01-09 03:08:26 +00:00
|
|
|
return _movieRepository.GetMoviesByFileId(fileId);
|
2017-01-03 19:24:55 +00:00
|
|
|
}
|
2017-01-09 22:16:54 +00:00
|
|
|
|
|
|
|
public Movie FindByTitleSlug(string slug)
|
|
|
|
{
|
|
|
|
return _movieRepository.FindByTitleSlug(slug);
|
|
|
|
}
|
2017-01-16 21:40:59 +00:00
|
|
|
|
|
|
|
public List<Movie> GetMoviesBetweenDates(DateTime start, DateTime end, bool includeUnmonitored)
|
|
|
|
{
|
2018-03-14 20:41:36 +00:00
|
|
|
var movies = _movieRepository.MoviesBetweenDates(start.ToUniversalTime(), end.ToUniversalTime(), includeUnmonitored);
|
2017-01-16 21:40:59 +00:00
|
|
|
|
2018-03-14 20:41:36 +00:00
|
|
|
return movies;
|
2017-01-16 21:40:59 +00:00
|
|
|
}
|
2017-01-18 18:53:17 +00:00
|
|
|
|
|
|
|
public PagingSpec<Movie> MoviesWithoutFiles(PagingSpec<Movie> pagingSpec)
|
|
|
|
{
|
|
|
|
var movieResult = _movieRepository.MoviesWithoutFiles(pagingSpec);
|
|
|
|
|
|
|
|
return movieResult;
|
|
|
|
}
|
2017-01-23 13:04:01 +00:00
|
|
|
|
|
|
|
public bool MovieExists(Movie movie)
|
|
|
|
{
|
|
|
|
Movie result = null;
|
|
|
|
|
|
|
|
if (movie.TmdbId != 0)
|
|
|
|
{
|
|
|
|
result = _movieRepository.FindByTmdbId(movie.TmdbId);
|
|
|
|
if (result != null)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (movie.ImdbId.IsNotNullOrWhiteSpace())
|
|
|
|
{
|
|
|
|
result = _movieRepository.FindByImdbId(movie.ImdbId);
|
|
|
|
if (result != null)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-17 13:19:41 +00:00
|
|
|
if (movie.Title.IsNotNullOrWhiteSpace())
|
2017-01-23 13:04:01 +00:00
|
|
|
{
|
2020-05-17 13:19:41 +00:00
|
|
|
if (movie.Year > 1850)
|
2017-01-23 13:04:01 +00:00
|
|
|
{
|
2020-07-22 02:08:59 +00:00
|
|
|
result = FindByTitle(movie.Title.CleanMovieTitle(), movie.Year);
|
2020-05-17 13:19:41 +00:00
|
|
|
if (result != null)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2017-01-23 13:04:01 +00:00
|
|
|
}
|
2020-05-17 13:19:41 +00:00
|
|
|
else
|
2017-12-12 22:26:16 +00:00
|
|
|
{
|
2020-07-22 02:08:59 +00:00
|
|
|
result = FindByTitle(movie.Title.CleanMovieTitle());
|
2020-05-17 13:19:41 +00:00
|
|
|
if (result != null)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2017-12-12 22:26:16 +00:00
|
|
|
}
|
|
|
|
}
|
2017-01-23 13:04:01 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2017-07-08 14:13:28 +00:00
|
|
|
|
|
|
|
public List<Movie> FilterExistingMovies(List<Movie> movies)
|
|
|
|
{
|
|
|
|
var allMovies = GetAllMovies();
|
|
|
|
|
|
|
|
var withTmdbid = movies.Where(m => m.TmdbId != 0).ToList();
|
|
|
|
var withoutTmdbid = movies.Where(m => m.TmdbId == 0).ToList();
|
|
|
|
var withImdbid = withoutTmdbid.Where(m => m.ImdbId.IsNotNullOrWhiteSpace());
|
|
|
|
var rest = withoutTmdbid.Where(m => m.ImdbId.IsNullOrWhiteSpace());
|
|
|
|
|
|
|
|
var ret = withTmdbid.ExceptBy(m => m.TmdbId, allMovies, m => m.TmdbId, EqualityComparer<int>.Default)
|
|
|
|
.Union(withImdbid.ExceptBy(m => m.ImdbId, allMovies, m => m.ImdbId, EqualityComparer<string>.Default))
|
2020-07-22 02:08:59 +00:00
|
|
|
.Union(rest.ExceptBy(m => m.Title.CleanMovieTitle(), allMovies, m => m.CleanTitle, EqualityComparer<string>.Default)).ToList();
|
2017-07-08 14:13:28 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2020-01-09 03:08:26 +00:00
|
|
|
|
2020-09-04 02:50:56 +00:00
|
|
|
public List<int> GetRecommendedTmdbIds()
|
2020-06-09 05:49:44 +00:00
|
|
|
{
|
2020-09-04 02:50:56 +00:00
|
|
|
return _movieRepository.GetRecommendations();
|
2020-06-09 05:49:44 +00:00
|
|
|
}
|
|
|
|
|
2020-01-09 03:08:26 +00:00
|
|
|
public void Handle(MovieFileAddedEvent message)
|
|
|
|
{
|
|
|
|
var movie = message.MovieFile.Movie;
|
|
|
|
movie.MovieFileId = message.MovieFile.Id;
|
|
|
|
_movieRepository.Update(movie);
|
|
|
|
|
|
|
|
//_movieRepository.SetFileId(message.MovieFile.Id, message.MovieFile.Movie.Value.Id);
|
|
|
|
_logger.Info("Linking [{0}] > [{1}]", message.MovieFile.RelativePath, message.MovieFile.Movie);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void Handle(MovieFileDeletedEvent message)
|
|
|
|
{
|
|
|
|
foreach (var movie in GetMoviesByFileId(message.MovieFile.Id))
|
|
|
|
{
|
|
|
|
_logger.Debug("Detaching movie {0} from file.", movie.Id);
|
|
|
|
movie.MovieFileId = 0;
|
|
|
|
|
|
|
|
if (message.Reason != DeleteMediaFileReason.Upgrade && _configService.AutoUnmonitorPreviouslyDownloadedMovies)
|
|
|
|
{
|
|
|
|
movie.Monitored = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
UpdateMovie(movie);
|
|
|
|
}
|
|
|
|
}
|
2016-12-29 15:04:01 +00:00
|
|
|
}
|
|
|
|
}
|