protected TExtraFile ImportFile(Movie movie, MovieFile movieFile, string path, bool readOnly, string extension, string fileNameSuffix = null)
{
var newFolder = Path.GetDirectoryName(Path.Combine(movie.Path, movieFile.RelativePath));
var filenameBuilder = new StringBuilder(Path.GetFileNameWithoutExtension(movieFile.RelativePath));
if (fileNameSuffix.IsNotNullOrWhiteSpace())
{
filenameBuilder.Append(fileNameSuffix);
}
filenameBuilder.Append(extension);
var newFileName = Path.Combine(newFolder, filenameBuilder.ToString());
var transferMode = TransferMode.Move;
if (readOnly)
{
transferMode = _configService.CopyUsingHardlinks ? TransferMode.HardLinkOrCopy : TransferMode.Copy;
}
_diskTransferService.TransferFile(path, newFileName, transferMode, true, false);
return(new TExtraFile
{
MovieId = movie.Id,
MovieFileId = movieFile.Id,
RelativePath = movie.Path.GetRelativePath(newFileName),
Extension = extension
});
}
public void AddMovieToCollection(TraktSettings settings, Movie movie, MovieFile movieFile)
{
var payload = new TraktCollectMoviesResource
{
Movies = new List <TraktCollectMovie>()
};
var traktResolution = MapResolution(movieFile.Quality.Quality.Resolution, movieFile.MediaInfo?.ScanType);
var mediaType = MapMediaType(movieFile.Quality.Quality.Source);
var audio = MapAudio(movieFile);
var audioChannels = MapAudioChannels(movieFile, audio);
payload.Movies.Add(new TraktCollectMovie
{
Title = movie.Title,
Year = movie.Year,
CollectedAt = DateTime.Now,
Resolution = traktResolution,
MediaType = mediaType,
AudioChannels = audioChannels,
Audio = audio,
Ids = new TraktMovieIdsResource
{
Tmdb = movie.TmdbId,
Imdb = movie.ImdbId ?? "",
}
});
_proxy.AddToCollection(payload, settings.AccessToken);
}
private static MovieFileResource ToResource(this MovieFile model)
{
if (model == null)
{
return(null);
}
return(new MovieFileResource
{
Id = model.Id,
MovieId = model.MovieId,
RelativePath = model.RelativePath,
//Path
Size = model.Size,
DateAdded = model.DateAdded,
SceneName = model.SceneName,
IndexerFlags = (int)model.IndexerFlags,
Quality = model.Quality,
Languages = model.Languages,
ReleaseGroup = model.ReleaseGroup,
Edition = model.Edition,
MediaInfo = model.MediaInfo.ToResource(model.SceneName),
OriginalFilePath = model.OriginalFilePath
});
}
public static MovieFileResource ToResource(this MovieFile model, NzbDrone.Core.Movies.Movie movie, IUpgradableSpecification upgradableSpecification)
{
if (model == null)
{
return(null);
}
return(new MovieFileResource
{
Id = model.Id,
MovieId = model.MovieId,
RelativePath = model.RelativePath,
Path = Path.Combine(movie.Path, model.RelativePath),
Size = model.Size,
DateAdded = model.DateAdded,
SceneName = model.SceneName,
IndexerFlags = (int)model.IndexerFlags,
Quality = model.Quality,
Languages = model.Languages,
Edition = model.Edition,
ReleaseGroup = model.ReleaseGroup,
MediaInfo = model.MediaInfo.ToResource(model.SceneName),
QualityCutoffNotMet = upgradableSpecification?.QualityCutoffNotMet(movie.Profile, model.Quality) ?? false,
OriginalFilePath = model.OriginalFilePath
});
}
public static void askUserForMovie(string userInput)
{
string movieFilePath = "movies.csv";
MovieFile movieFile = new MovieFile(movieFilePath);
// Add movie
Movie movie = new Movie();
string tempInput = "";
// ask user to input movie title
System.Console.WriteLine("What is the movie titled");
movie.movieTitle = System.Console.ReadLine();
// check if the title matches another title
if (!movieFile.hasSameTitle(movie.movieTitle))
{
do
{
// ask user to enter genre
System.Console.WriteLine("Enter a genre. ('.' to stop) ");
tempInput = System.Console.ReadLine();
//adds to genrelist
movie.movieGenres.Add(tempInput);
}while (tempInput != ".");
//movie never gets created if the title matches another
movieFile.AddMovie(movie);
}
}
public void Setup()
{
Mocker.Resolve <QualityUpgradableSpecification>();
_upgradeDisk = Mocker.Resolve <UpgradeDiskSpecification>();
_firstFile = new MovieFile {
Quality = new QualityModel(Quality.Bluray1080p, new Revision(version: 2)), DateAdded = DateTime.Now
};
var fakeSeries = Builder <Movie> .CreateNew()
.With(c => c.Profile = new Profile {
Cutoff = Quality.Bluray1080p, Items = Qualities.QualityFixture.GetDefaultQualities()
})
.With(e => e.MovieFile = _firstFile)
.Build();
_parseResultSingle = new RemoteMovie
{
Movie = fakeSeries,
ParsedMovieInfo = new ParsedMovieInfo()
{
Quality = new QualityModel(Quality.DVD, new Revision(version: 2))
},
};
}
protected TExtraFile MoveFile(Movie movie, MovieFile movieFile, TExtraFile extraFile, string fileNameSuffix = null)
{
var newFolder = Path.GetDirectoryName(Path.Combine(movie.Path, movieFile.RelativePath));
var filenameBuilder = new StringBuilder(Path.GetFileNameWithoutExtension(movieFile.RelativePath));
if (fileNameSuffix.IsNotNullOrWhiteSpace())
{
filenameBuilder.Append(fileNameSuffix);
}
filenameBuilder.Append(extraFile.Extension);
var existingFileName = Path.Combine(movie.Path, extraFile.RelativePath);
var newFileName = Path.Combine(newFolder, filenameBuilder.ToString());
if (newFileName.PathNotEquals(existingFileName))
{
try
{
_diskProvider.MoveFile(existingFileName, newFileName);
extraFile.RelativePath = movie.Path.GetRelativePath(newFileName);
return(extraFile);
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to move file after rename: {0}", existingFileName);
}
}
return(null);
}
private void CreateAfterImport(Movie movie, MovieFile movieFile)
{
foreach (var extraFileManager in _extraFileManagers)
{
extraFileManager.CreateAfterMovieImport(movie, movieFile);
}
}
public string BuildFileName(Movie movie, MovieFile movieFile, NamingConfig namingConfig = null)
{
if (namingConfig == null)
{
namingConfig = _namingConfigService.GetConfig();
}
if (!namingConfig.RenameEpisodes)
{
return(GetOriginalTitle(movieFile));
}
var pattern = namingConfig.StandardMovieFormat;
var tokenHandlers = new Dictionary <string, Func <TokenMatch, string> >(FileNameBuilderTokenEqualityComparer.Instance);
AddMovieTokens(tokenHandlers, movie);
AddReleaseDateTokens(tokenHandlers, movie.Year);
AddImdbIdTokens(tokenHandlers, movie.ImdbId);
AddQualityTokens(tokenHandlers, movie, movieFile);
AddMediaInfoTokens(tokenHandlers, movieFile);
AddMovieFileTokens(tokenHandlers, movieFile);
AddTagsTokens(tokenHandlers, movieFile);
var fileName = ReplaceTokens(pattern, tokenHandlers, namingConfig).Trim();
fileName = FileNameCleanupRegex.Replace(fileName, match => match.Captures[0].Value[0].ToString());
fileName = TrimSeparatorsRegex.Replace(fileName, string.Empty);
return(fileName);
}
public override string GetFilenameAfterMove(Movie movie, MovieFile movieFile, MetadataFile metadataFile)
{
_logger.Debug("Getting Movie Filename after move for: {0}", Path.Combine(movie.Path, movieFile.RelativePath));
var movieFilePath = Path.Combine(movie.Path, movieFile.RelativePath);
if (metadataFile.Type == MetadataType.MovieMetadata)
{
return(GetMovieMetadataFilename(movieFilePath));
}
if (metadataFile.Type == MetadataType.MovieImage)
{
foreach (CoverType coverType in Enum.GetValues(typeof(CoverType)))
{
if (metadataFile.RelativePath.Contains($"{coverType}.jpg"))
{
return(Path.Combine(movie.Path, GetMovieCoverType(movieFilePath, coverType, isTransparent: false)));
}
if (metadataFile.RelativePath.Contains($"{coverType}.png"))
{
return(Path.Combine(movie.Path, GetMovieCoverType(movieFilePath, coverType, isTransparent: true)));
}
}
}
_logger.Debug("Unknown movie file metadata: {0}", metadataFile.RelativePath);
return(Path.Combine(movie.Path, metadataFile.RelativePath));
}
public void Setup()
{
Mocker.Resolve <QualityUpgradableSpecification>();
_firstFile = new MovieFile {
Quality = new QualityModel(Quality.Bluray1080p, new Revision(version: 1)), DateAdded = DateTime.Now
};
_secondFile = new MovieFile {
Quality = new QualityModel(Quality.Bluray1080p, new Revision(version: 1)), DateAdded = DateTime.Now
};
var fakeSeries = Builder <Movie> .CreateNew()
.With(c => c.Profile = new Profile {
Cutoff = Quality.Bluray1080p
})
.With(c => c.MovieFile = _firstFile)
.Build();
_parseResultSingle = new RemoteMovie
{
Movie = fakeSeries,
ParsedMovieInfo = new ParsedMovieInfo {
Quality = new QualityModel(Quality.DVD, new Revision(version: 2))
},
};
}
public void Setup()
{
_movieFile = Builder <MovieFile> .CreateNew().With(m => m.MovieId = 0).Build();
_oldQuality = new QualityModel(Quality.Bluray720p);
_movieFile.Quality = _oldQuality;
_newQuality = _oldQuality.JsonClone();
var format = new CustomFormats.CustomFormat("Awesome Format");
format.Id = 1;
_newQuality.CustomFormats = new List <CustomFormats.CustomFormat> {
format
};
_newInfo = new ParsedMovieInfo
{
Quality = _newQuality
};
Mocker.GetMock <IMediaFileService>().Setup(s => s.GetMovies(It.IsAny <IEnumerable <int> >()))
.Returns(new List <MovieFile> {
_movieFile
});
Mocker.GetMock <IHistoryService>().Setup(s => s.FindByMovieId(It.IsAny <int>()))
.Returns(new List <History.History>());
}
public void Setup()
{
Mocker.Resolve <UpgradableSpecification>();
_upgradeDisk = Mocker.Resolve <UpgradeDiskSpecification>();
CustomFormatsFixture.GivenCustomFormats();
_firstFile = new MovieFile {
Quality = new QualityModel(Quality.Bluray1080p, new Revision(version: 2)), DateAdded = DateTime.Now
};
var fakeSeries = Builder <Movie> .CreateNew()
.With(c => c.Profile = new Profile
{
Cutoff = Quality.Bluray1080p.Id, Items = Qualities.QualityFixture.GetDefaultQualities(),
FormatItems = CustomFormatsFixture.GetSampleFormatItems(),
MinFormatScore = 0
})
.With(e => e.MovieFile = _firstFile)
.Build();
_parseResultSingle = new RemoteMovie
{
Movie = fakeSeries,
ParsedMovieInfo = new ParsedMovieInfo()
{
Quality = new QualityModel(Quality.DVD, new Revision(version: 2))
},
CustomFormats = new List <CustomFormat>()
};
Mocker.GetMock <ICustomFormatCalculationService>()
.Setup(x => x.ParseCustomFormat(It.IsAny <MovieFile>()))
.Returns(new List <CustomFormat>());
}
public void Setup()
{
_series = Builder <Movie> .CreateNew()
.With(s => s.Path = @"C:\Test\TV\Series".AsOsAgnostic())
.Build();
_episodeFile = Builder <MovieFile> .CreateNew()
.With(f => f.Path = null)
.With(f => f.RelativePath = @"Season 1\File.avi")
.Build();
_localEpisode = Builder <LocalMovie> .CreateNew()
.With(l => l.Movie = _series)
.Build();
Mocker.GetMock <IBuildFileNames>()
.Setup(s => s.BuildFileName(It.IsAny <Movie>(), It.IsAny <MovieFile>(), null))
.Returns("File Name");
Mocker.GetMock <IBuildFileNames>()
.Setup(s => s.BuildFilePath(It.IsAny <Movie>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(@"C:\Test\TV\Series\File Name.avi".AsOsAgnostic());
var rootFolder = @"C:\Test\TV\".AsOsAgnostic();
Mocker.GetMock <IDiskProvider>()
.Setup(s => s.FolderExists(rootFolder))
.Returns(true);
Mocker.GetMock <IDiskProvider>()
.Setup(s => s.FileExists(It.IsAny <string>()))
.Returns(true);
}
public static MovieFileResource ToResource(this MovieFile model)
{
if (model == null)
{
return(null);
}
MovieResource movie = null;
/*if (model.Movie != null)
* {
* //model.Movie.LazyLoad();
* if (model.Movie.Value != null)
* {
* //movie = model.Movie.Value.ToResource();
* }
* }*/
return(new MovieFileResource
{
Id = model.Id,
RelativePath = model.RelativePath,
Path = model.Path,
Size = model.Size,
DateAdded = model.DateAdded,
SceneName = model.SceneName,
ReleaseGroup = model.ReleaseGroup,
Quality = model.Quality,
Movie = movie,
MediaInfo = model.MediaInfo,
Edition = model.Edition
});
}
public void Setup()
{
_movie = Builder <Movie>
.CreateNew()
.With(e => e.Title = "Batman")
.Build();
_movieFile = new MovieFile {
Quality = new QualityModel(Quality.HDTV720p), ReleaseGroup = "RadarrTest"
};
_namingConfig = NamingConfig.Default;
_namingConfig.RenameMovies = true;
Mocker.GetMock <INamingConfigService>()
.Setup(c => c.GetConfig()).Returns(_namingConfig);
Mocker.GetMock <IQualityDefinitionService>()
.Setup(v => v.Get(Moq.It.IsAny <Quality>()))
.Returns <Quality>(v => Quality.DefaultQualityDefinitions.First(c => c.Quality == v));
Mocker.GetMock <ICustomFormatService>()
.Setup(v => v.All())
.Returns(new List <CustomFormat>());
}
public MovieImportedEvent(LocalMovie movieInfo, MovieFile importedMovie, bool newDownload, DownloadClientItem downloadClientItem, string downloadId)
{
MovieInfo = movieInfo;
ImportedMovie = importedMovie;
NewDownload = newDownload;
DownloadClientInfo = downloadClientItem.DownloadClientInfo;
DownloadId = downloadId;
}
public virtual string GetFilenameAfterMove(Movie movie, MovieFile movieFile, MetadataFile metadataFile)
{
var existingFilename = Path.Combine(movie.Path, metadataFile.RelativePath);
var extension = Path.GetExtension(existingFilename).TrimStart('.');
var newFileName = Path.ChangeExtension(Path.Combine(movie.Path, movieFile.RelativePath), extension);
return(newFileName);
}
public override ExtraFile Import(Movie movie, MovieFile movieFile, string path, string extension, bool readOnly)
{
var extraFile = ImportFile(movie, movieFile, path, readOnly, extension, null);
_otherExtraFileService.Upsert(extraFile);
return(extraFile);
}
public FileNameSampleService(IBuildFileNames buildFileNames)
{
_buildFileNames = buildFileNames;
var mediaInfo = new MediaInfoModel()
{
VideoFormat = "AVC",
VideoBitDepth = 10,
VideoMultiViewCount = 2,
VideoColourPrimaries = "BT.2020",
VideoTransferCharacteristics = "HLG",
AudioFormat = "DTS",
AudioChannelsContainer = 6,
AudioChannelPositions = "3/2/0.1",
AudioLanguages = "German",
Subtitles = "English/German"
};
_movieFile = new MovieFile
{
Quality = new QualityModel(Quality.Bluray1080p, new Revision(2)),
RelativePath = "The.Movie.Title.2010.1080p.BluRay.DTS.x264-EVOLVE.mkv",
SceneName = "The.Movie.Title.2010.1080p.BluRay.DTS.x264-EVOLVE",
ReleaseGroup = "EVOLVE",
MediaInfo = mediaInfo,
Edition = "Ultimate extended edition",
};
_movie = new Movie
{
Title = "The Movie: Title",
OriginalTitle = "The Original Movie Title",
Collection = new MovieCollection {
Name = "The Movie Collection", TmdbId = 123654
},
Certification = "R",
Year = 2010,
ImdbId = "tt0066921",
TmdbId = 345691,
MovieFile = _movieFile,
MovieFileId = 1,
};
_customFormats = new List <CustomFormat>
{
new CustomFormat
{
Name = "Surround Sound",
IncludeCustomFormatWhenRenaming = true
},
new CustomFormat
{
Name = "x264",
IncludeCustomFormatWhenRenaming = true
}
};
}
private string GetOriginalFileName(MovieFile movieFile)
{
if (movieFile.RelativePath.IsNullOrWhiteSpace())
{
return(Path.GetFileNameWithoutExtension(movieFile.Path));
}
return(Path.GetFileNameWithoutExtension(movieFile.RelativePath));
}
public MovieImportedEvent(LocalMovie episodeInfo, MovieFile importedMovie, bool newDownload, string downloadClient, string downloadId, bool isReadOnly)
{
MovieInfo = episodeInfo;
ImportedMovie = importedMovie;
NewDownload = newDownload;
DownloadClient = downloadClient;
DownloadId = downloadId;
IsReadOnly = isReadOnly;
}
private string GetOriginalTitle(MovieFile movieFile)
{
if (movieFile.SceneName.IsNullOrWhiteSpace())
{
return(GetOriginalFileName(movieFile));
}
return(movieFile.SceneName);
}
public override List <ImageFileResult> MovieImages(Movie movie, MovieFile movieFile)
{
if (!Settings.MovieImages)
{
return(new List <ImageFileResult>());
}
return(ProcessMovieImages(movie, movieFile).ToList());
}
public MovieDownloadedEvent(LocalMovie movie, MovieFile movieFile, List <MovieFile> oldFiles, DownloadClientItem downloadClientItem)
{
Movie = movie;
MovieFile = movieFile;
OldFiles = oldFiles;
if (downloadClientItem != null)
{
DownloadId = downloadClientItem.DownloadId;
}
}
public WebhookMovieFile(MovieFile movieFile)
{
Id = movieFile.Id;
RelativePath = movieFile.RelativePath;
Path = movieFile.Path;
Quality = movieFile.Quality.Quality.Name;
QualityVersion = movieFile.Quality.Revision.Version;
ReleaseGroup = movieFile.ReleaseGroup;
SceneName = movieFile.SceneName;
}
public bool Update(MovieFile movieFile, Movie movie)
{
if (!_configService.EnableMediaInfo)
{
_logger.Debug("MediaInfo is disabled");
return(false);
}
return(UpdateMediaInfo(movieFile, movie));
}
public void null_string_as_arg_should_not_fail()
{
var epFile = new MovieFile();
_logger.Debug("File {0} no longer exists on disk. removing from database.", epFile.RelativePath);
Thread.Sleep(1000);
epFile.RelativePath.Should().BeNull();
}
public void Update(MovieFile movieFile, Movie movie)
{
if (!_configService.EnableMediaInfo)
{
_logger.Debug("MediaInfo is disabled");
return;
}
UpdateMediaInfo(movieFile, movie);
}
private string MapAudioChannels(MovieFile movieFile, string audioFormat)
{
var audioChannels = movieFile.MediaInfo != null?MediaInfoFormatter.FormatAudioChannels(movieFile.MediaInfo).ToString("0.0") : string.Empty;
if (audioChannels == "0.0")
{
audioChannels = string.Empty;
}
return(audioChannels);
}
