public List <CustomFormat> ParseCustomFormat(Blocklist blocklist) { var movie = _movieService.GetMovie(blocklist.MovieId); var parsed = _parsingService.ParseMovieInfo(blocklist.SourceTitle, null); var info = new ParsedMovieInfo { MovieTitles = new List <string>() { movie.Title }, SimpleReleaseTitle = parsed?.SimpleReleaseTitle ?? blocklist.SourceTitle.SimplifyReleaseTitle(), Quality = blocklist.Quality, Languages = blocklist.Languages, ReleaseGroup = parsed?.ReleaseGroup, Edition = parsed?.Edition, Year = movie.Year, ImdbId = movie.ImdbId, ExtraInfo = new Dictionary <string, object> { { "IndexerFlags", blocklist.IndexerFlags }, { "Size", blocklist.Size } } }; return(ParseCustomFormat(info)); }
//TODO add some good tests for this! public void Execute(UpdateMovieFileQualityCommand command) { var movieFiles = _mediaFileService.GetMovies(command.MovieFileIds); var count = 1; foreach (var movieFile in movieFiles) { _logger.ProgressInfo("Updating quality for {0}/{1} files.", count, movieFiles.Count); var history = _historyService.FindByMovieId(movieFile.MovieId).OrderByDescending(h => h.Date); var latestImported = history.FirstOrDefault(h => h.EventType == HistoryEventType.DownloadFolderImported); var latestImportedName = latestImported?.SourceTitle; var latestGrabbed = history.FirstOrDefault(h => h.EventType == HistoryEventType.Grabbed); var sizeMovie = new LocalMovie(); sizeMovie.Size = movieFile.Size; var helpers = new List <object> { sizeMovie }; if (movieFile.MediaInfo != null) { helpers.Add(movieFile.MediaInfo); } if (latestGrabbed != null) { helpers.Add(latestGrabbed); } ParsedMovieInfo parsedMovieInfo = null; if (latestImportedName?.IsNotNullOrWhiteSpace() == true) { parsedMovieInfo = _parsingService.ParseMovieInfo(latestImportedName, helpers); } if (parsedMovieInfo == null) { _logger.Debug("Could not parse movie info from history source title, using current path instead: {0}.", movieFile.RelativePath); parsedMovieInfo = _parsingService.ParseMovieInfo(movieFile.RelativePath, helpers); } //Only update Custom formats for now. if (parsedMovieInfo != null) { movieFile.Quality.CustomFormats = parsedMovieInfo.Quality.CustomFormats; _mediaFileService.Update(movieFile); _eventAggregator.PublishEvent(new MovieFileUpdatedEvent(movieFile)); } else { _logger.Warn("Could not update custom formats for {0}, since it's title could not be parsed!", movieFile); } count++; } }
private CustomFormatTestResource Test() { var parsed = _parsingService.ParseMovieInfo((string)Request.Query.title, new List <object>()); if (parsed == null) { return(null); } return(new CustomFormatTestResource { Matches = _parsingService.MatchFormatTags(parsed).ToResource(), MatchedFormats = parsed.Quality.CustomFormats.ToResource() }); }
private ParseResource Parse() { var title = Request.Query.Title.Value as string; var parsedMovieInfo = _parsingService.ParseMovieInfo(title, new List <object>()); if (parsedMovieInfo == null) { return(null); } var remoteMovie = _parsingService.Map(parsedMovieInfo, ""); if (remoteMovie != null) { return(new ParseResource { Title = title, ParsedMovieInfo = remoteMovie.RemoteMovie.ParsedMovieInfo, Movie = remoteMovie.Movie.ToResource() }); } else { return(new ParseResource { Title = title, ParsedMovieInfo = parsedMovieInfo }); } }
private List <ManualImportItem> ProcessFolder(string folder, string downloadId) { DownloadClientItem downloadClientItem = null; var directoryInfo = new DirectoryInfo(folder); var movie = _parsingService.GetMovie(directoryInfo.Name); if (downloadId.IsNotNullOrWhiteSpace()) { var trackedDownload = _trackedDownloadService.Find(downloadId); downloadClientItem = trackedDownload.DownloadItem; if (movie == null) { movie = trackedDownload.RemoteMovie.Movie; } } if (movie == null) { var files = _diskScanService.GetVideoFiles(folder); return(files.Select(file => ProcessFile(file, downloadId, folder)).Where(i => i != null).ToList()); } var historyItems = _historyService.FindByDownloadId(downloadId); var firstHistoryItem = historyItems.OrderByDescending(h => h.Date).FirstOrDefault(); var folderInfo = _parsingService.ParseMovieInfo(directoryInfo.Name, new List <object> { firstHistoryItem }); var movieFiles = _diskScanService.GetVideoFiles(folder).ToList(); var decisions = _importDecisionMaker.GetImportDecisions(movieFiles, movie, downloadClientItem, folderInfo, SceneSource(movie, folder), false); return(decisions.Select(decision => MapItem(decision, folder, downloadId)).ToList()); }
private List <ImportResult> ProcessFolder(DirectoryInfo directoryInfo, ImportMode importMode, Movie movie, DownloadClientItem downloadClientItem) { if (_movieService.MoviePathExists(directoryInfo.FullName)) { _logger.Warn("Unable to process folder that is mapped to an existing show"); return(new List <ImportResult>()); } var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name); var historyItems = _historyService.FindByDownloadId(downloadClientItem?.DownloadId ?? ""); var firstHistoryItem = historyItems?.OrderByDescending(h => h.Date).FirstOrDefault(); var folderInfo = _parsingService.ParseMovieInfo(cleanedUpName, new List <object> { firstHistoryItem }); if (folderInfo != null) { _logger.Debug("{0} folder quality: {1}", cleanedUpName, folderInfo.Quality); } var videoFiles = _diskScanService.FilterPaths(directoryInfo.FullName, _diskScanService.GetVideoFiles(directoryInfo.FullName)); if (downloadClientItem == null) { foreach (var videoFile in videoFiles) { if (_diskProvider.IsFileLocked(videoFile)) { return(new List <ImportResult> { FileIsLockedResult(videoFile) }); } } } var decisions = _importDecisionMaker.GetImportDecisions(videoFiles.ToList(), movie, downloadClientItem, folderInfo, true); var importResults = _importApprovedMovie.Import(decisions, true, downloadClientItem, importMode); if (importMode == ImportMode.Auto) { importMode = (downloadClientItem == null || downloadClientItem.CanMoveFiles) ? ImportMode.Move : ImportMode.Copy; } if (importMode == ImportMode.Move && importResults.Any(i => i.Result == ImportResultType.Imported) && ShouldDeleteFolder(directoryInfo, movie)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(directoryInfo.FullName, true); } return(importResults); }
public ParseResource Parse(string title) { if (title.IsNullOrWhiteSpace()) { return(null); } var parsedMovieInfo = _parsingService.ParseMovieInfo(title, new List <object>()); if (parsedMovieInfo == null) { return(new ParseResource { Title = title }); } var remoteMovie = _parsingService.Map(parsedMovieInfo, ""); if (remoteMovie != null) { return(new ParseResource { Title = title, ParsedMovieInfo = remoteMovie.RemoteMovie.ParsedMovieInfo, Movie = remoteMovie.Movie.ToResource(_configService.AvailabilityDelay) }); } else { return(new ParseResource { Title = title, ParsedMovieInfo = parsedMovieInfo }); } }
public TrackedDownload TrackDownload(DownloadClientDefinition downloadClient, DownloadClientItem downloadItem) { var existingItem = Find(downloadItem.DownloadId); if (existingItem != null && existingItem.State != TrackedDownloadState.Downloading) { LogItemChange(existingItem, existingItem.DownloadItem, downloadItem); existingItem.DownloadItem = downloadItem; existingItem.IsTrackable = true; return(existingItem); } var trackedDownload = new TrackedDownload { DownloadClient = downloadClient.Id, DownloadItem = downloadItem, Protocol = downloadClient.Protocol, IsTrackable = true }; try { var historyItems = _historyService.FindByDownloadId(downloadItem.DownloadId) .OrderByDescending(h => h.Date) .ToList(); var grabbedHistoryItem = historyItems.FirstOrDefault(h => h.EventType == MovieHistoryEventType.Grabbed); //TODO: Create release info from history and use that here, so we don't loose indexer flags! var parsedMovieInfo = _parsingService.ParseMovieInfo(trackedDownload.DownloadItem.Title, new List <object> { grabbedHistoryItem }); if (parsedMovieInfo != null) { trackedDownload.RemoteMovie = _parsingService.Map(parsedMovieInfo, "", null).RemoteMovie; } var downloadHistory = _downloadHistoryService.GetLatestDownloadHistoryItem(downloadItem.DownloadId); if (downloadHistory != null) { var state = GetStateFromHistory(downloadHistory.EventType); trackedDownload.State = state; } if (historyItems.Any()) { var firstHistoryItem = historyItems.FirstOrDefault(); var grabbedEvent = historyItems.FirstOrDefault(v => v.EventType == MovieHistoryEventType.Grabbed); trackedDownload.Indexer = grabbedEvent?.Data["indexer"]; if (parsedMovieInfo == null || trackedDownload.RemoteMovie == null || trackedDownload.RemoteMovie.Movie == null) { parsedMovieInfo = _parsingService.ParseMovieInfo(firstHistoryItem.SourceTitle, new List <object> { grabbedHistoryItem }); if (parsedMovieInfo != null) { trackedDownload.RemoteMovie = _parsingService.Map(parsedMovieInfo, "", null).RemoteMovie; } } } // Calculate custom formats if (trackedDownload.RemoteMovie != null) { trackedDownload.RemoteMovie.CustomFormats = _formatCalculator.ParseCustomFormat(parsedMovieInfo); } // Track it so it can be displayed in the queue even though we can't determine which movie it is for if (trackedDownload.RemoteMovie == null) { _logger.Trace("No Movie found for download '{0}'", trackedDownload.DownloadItem.Title); } } catch (Exception e) { _logger.Debug(e, "Failed to find movie for " + downloadItem.Title); return(null); } LogItemChange(trackedDownload, existingItem?.DownloadItem, trackedDownload.DownloadItem); _cache.Set(trackedDownload.DownloadItem.DownloadId, trackedDownload); return(trackedDownload); }
private IEnumerable <DownloadDecision> GetMovieDecisions(List <ReleaseInfo> reports, SearchCriteriaBase searchCriteria = null) { if (reports.Any()) { _logger.ProgressInfo("Processing {0} releases", reports.Count); } else { _logger.ProgressInfo("No results found"); } var reportNumber = 1; foreach (var report in reports) { DownloadDecision decision = null; _logger.ProgressTrace("Processing release {0}/{1}", reportNumber, reports.Count); try { var parsedMovieInfo = _parsingService.ParseMovieInfo(report.Title, new List <object> { report }); MappingResult result = null; if (parsedMovieInfo == null || parsedMovieInfo.MovieTitle.IsNullOrWhiteSpace()) { _logger.Debug("{0} could not be parsed :(.", report.Title); parsedMovieInfo = new ParsedMovieInfo { MovieTitle = report.Title, Year = 1290, Languages = new List <Language> { Language.Unknown }, Quality = new QualityModel(), }; if (_configService.ParsingLeniency == ParsingLeniencyType.MappingLenient) { result = _parsingService.Map(parsedMovieInfo, report.ImdbId.ToString(), searchCriteria); } if (result == null || result.MappingResultType != MappingResultType.SuccessLenientMapping) { result = new MappingResult { MappingResultType = MappingResultType.NotParsable }; result.Movie = null; //To ensure we have a remote movie, else null exception on next line! result.RemoteMovie.ParsedMovieInfo = parsedMovieInfo; } else { //Enhance Parsed Movie Info! result.RemoteMovie.ParsedMovieInfo = Parser.Parser.ParseMinimalMovieTitle(parsedMovieInfo.MovieTitle, result.RemoteMovie.Movie.Title, parsedMovieInfo.Year); } } else { result = _parsingService.Map(parsedMovieInfo, report.ImdbId.ToString(), searchCriteria); } result.ReleaseName = report.Title; var remoteMovie = result.RemoteMovie; remoteMovie.Release = report; remoteMovie.MappingResult = result.MappingResultType; if (result.MappingResultType != MappingResultType.Success && result.MappingResultType != MappingResultType.SuccessLenientMapping) { var rejection = result.ToRejection(); decision = new DownloadDecision(remoteMovie, rejection); } else { if (parsedMovieInfo.Quality.HardcodedSubs.IsNotNullOrWhiteSpace()) { //remoteMovie.DownloadAllowed = true; if (_configService.AllowHardcodedSubs) { decision = GetDecisionForReport(remoteMovie, searchCriteria); } else { var whitelisted = _configService.WhitelistedHardcodedSubs.Split(','); _logger.Debug("Testing: {0}", whitelisted); if (whitelisted != null && whitelisted.Any(t => (parsedMovieInfo.Quality.HardcodedSubs.ToLower().Contains(t.ToLower()) && t.IsNotNullOrWhiteSpace()))) { decision = GetDecisionForReport(remoteMovie, searchCriteria); } else { decision = new DownloadDecision(remoteMovie, new Rejection("Hardcoded subs found: " + parsedMovieInfo.Quality.HardcodedSubs)); } } } else { //remoteMovie.DownloadAllowed = true; decision = GetDecisionForReport(remoteMovie, searchCriteria); } } } catch (Exception e) { _logger.Error(e, "Couldn't process release."); var remoteMovie = new RemoteMovie { Release = report }; decision = new DownloadDecision(remoteMovie, new Rejection("Unexpected error processing release")); } reportNumber++; if (decision != null) { if (decision.Rejections.Any()) { _logger.Debug("Release rejected for the following reasons: {0}", string.Join(", ", decision.Rejections)); } else { _logger.Debug("Release accepted"); } yield return(decision); } } }
public TrackedDownload TrackDownload(DownloadClientDefinition downloadClient, DownloadClientItem downloadItem) { if (downloadItem.DownloadId.IsNullOrWhiteSpace()) { _logger.Warn("The following download client item ({0}) has no download hash (id), so it cannot be tracked: {1}", downloadClient.Name, downloadItem.Title); return(null); } if (downloadItem.Title.IsNullOrWhiteSpace()) { _logger.Warn("The following download client item ({0}) has no title so it cannot be tracked: {1}", downloadClient.Name, downloadItem.Title); return(null); } var existingItem = Find(downloadItem.DownloadId); if (existingItem != null && existingItem.State != TrackedDownloadStage.Downloading) { existingItem.DownloadItem = downloadItem; return(existingItem); } var trackedDownload = new TrackedDownload { DownloadClient = downloadClient.Id, DownloadItem = downloadItem, Protocol = downloadClient.Protocol }; try { var historyItems = _historyService.FindByDownloadId(downloadItem.DownloadId); var grabbedHistoryItem = historyItems.OrderByDescending(h => h.Date).FirstOrDefault(h => h.EventType == HistoryEventType.Grabbed); var firstHistoryItem = historyItems.OrderByDescending(h => h.Date).FirstOrDefault(); //TODO: Create release info from history and use that here, so we don't loose indexer flags! var parsedMovieInfo = _parsingService.ParseMovieInfo(trackedDownload.DownloadItem.Title, new List <object> { grabbedHistoryItem }); if (parsedMovieInfo != null) { trackedDownload.RemoteMovie = _parsingService.Map(parsedMovieInfo, "", null).RemoteMovie; } if (firstHistoryItem != null) { trackedDownload.State = GetStateFromHistory(firstHistoryItem.EventType); if (parsedMovieInfo == null || trackedDownload.RemoteMovie == null || trackedDownload.RemoteMovie.Movie == null) { parsedMovieInfo = _parsingService.ParseMovieInfo(firstHistoryItem.SourceTitle, new List <object> { grabbedHistoryItem }); if (parsedMovieInfo != null) { trackedDownload.RemoteMovie = _parsingService.Map(parsedMovieInfo, "", null).RemoteMovie; } } } if (trackedDownload.RemoteMovie == null) { return(null); } } catch (Exception e) { _logger.Debug(e, "Failed to find movie for " + downloadItem.Title); return(null); } _cache.Set(trackedDownload.DownloadItem.DownloadId, trackedDownload); return(trackedDownload); }