public void UpdateLibrary(Series series, PlexServerSettings settings) { try { _logger.Debug("Sending Update Request to Plex Server"); var sections = GetSections(settings); var partialUpdates = _partialUpdateCache.Get(settings.Host, () => PartialUpdatesAllowed(settings), TimeSpan.FromHours(2)); if (partialUpdates) { UpdatePartialSection(series, sections, settings); } else { sections.ForEach(s => UpdateSection(s.Id, settings)); } } catch(Exception ex) { _logger.WarnException("Failed to Update Plex host: " + settings.Host, ex); throw; } }
internal string GetSeriesPath(XbmcSettings settings, Series series) { var query = string.Format( "select path.strPath from path, tvshow, tvshowlinkpath where tvshow.c12 = {0} and tvshowlinkpath.idShow = tvshow.idShow and tvshowlinkpath.idPath = path.idPath", series.TvdbId); var command = string.Format("QueryVideoDatabase({0})", query); const string setResponseCommand = "SetResponseFormat(webheader;false;webfooter;false;header;<xml>;footer;</xml>;opentag;<tag>;closetag;</tag>;closefinaltag;false)"; const string resetResponseCommand = "SetResponseFormat()"; SendCommand(settings, setResponseCommand); var response = SendCommand(settings, command); SendCommand(settings, resetResponseCommand); if (string.IsNullOrEmpty(response)) return string.Empty; var xDoc = XDocument.Load(new StringReader(response.Replace("&", "&"))); var xml = xDoc.Descendants("xml").Select(x => x).FirstOrDefault(); if (xml == null) return null; var field = xml.Descendants("field").FirstOrDefault(); if (field == null) return null; return field.Value; }
public List<Episode> GetEpisodes(ParsedEpisodeInfo parsedEpisodeInfo, Series series, bool sceneSource, SearchCriteriaBase searchCriteria = null) { if (parsedEpisodeInfo.FullSeason) { return _episodeService.GetEpisodesBySeason(series.Id, parsedEpisodeInfo.SeasonNumber); } if (parsedEpisodeInfo.IsDaily) { if (series.SeriesType == SeriesTypes.Standard) { _logger.Warn("Found daily-style episode for non-daily series: {0}.", series); return new List<Episode>(); } var episodeInfo = GetDailyEpisode(series, parsedEpisodeInfo.AirDate, searchCriteria); if (episodeInfo != null) { return new List<Episode> { episodeInfo }; } return new List<Episode>(); } if (parsedEpisodeInfo.IsAbsoluteNumbering) { return GetAnimeEpisodes(series, parsedEpisodeInfo, sceneSource); } return GetStandardEpisodes(series, parsedEpisodeInfo, sceneSource, searchCriteria); }
public static SeriesResource ToResource(this NzbDrone.Core.Tv.Series model, bool includeSeasonImages = false) { if (model == null) { return(null); } return(new SeriesResource { Id = model.Id, Title = model.Title, //AlternateTitles SortTitle = model.SortTitle, //TotalEpisodeCount //EpisodeCount //EpisodeFileCount //SizeOnDisk Status = model.Status, Overview = model.Overview, //NextAiring //PreviousAiring Network = model.Network, AirTime = model.AirTime, Images = model.Images, Seasons = model.Seasons.ToResource(includeSeasonImages), Year = model.Year, Path = model.Path, QualityProfileId = model.QualityProfileId, LanguageProfileId = model.LanguageProfileId, SeasonFolder = model.SeasonFolder, Monitored = model.Monitored, UseSceneNumbering = model.UseSceneNumbering, Runtime = model.Runtime, TvdbId = model.TvdbId, TvRageId = model.TvRageId, TvMazeId = model.TvMazeId, FirstAired = model.FirstAired, LastInfoSync = model.LastInfoSync, SeriesType = model.SeriesType, CleanTitle = model.CleanTitle, ImdbId = model.ImdbId, TitleSlug = model.TitleSlug, // Root folder path needs to be calculated from the series path // RootFolderPath = model.RootFolderPath, Certification = model.Certification, Genres = model.Genres, Tags = model.Tags, Added = model.Added, AddOptions = model.AddOptions, Ratings = model.Ratings }); }
public bool ShouldRefresh(Series series) { if (series.Status == SeriesStatusType.Continuing) { _logger.Trace("Series {0} is continuing, should refresh.", series.Title); return true; } if (series.LastInfoSync < DateTime.UtcNow.AddDays(-30)) { _logger.Trace("Series {0} last updated more than 30 days ago, should refresh.", series.Title); return true; } var lastEpisode = _episodeService.GetEpisodeBySeries(series.Id).OrderByDescending(e => e.AirDateUtc).FirstOrDefault(); if (lastEpisode != null && lastEpisode.AirDateUtc > DateTime.UtcNow.AddDays(-30)) { _logger.Trace("Last episode in {0} aired less than 30 days ago, should refresh.", series.Title); return true; } _logger.Trace("Series {0} should not be refreshed.", series.Title); return false; }
private IEnumerable<ImportDecision> GetDecisions(IEnumerable<String> videoFiles, Series series, bool sceneSource) { foreach (var file in videoFiles) { ImportDecision decision = null; try { var parsedEpisode = _parsingService.GetEpisodes(file, series, sceneSource); if (parsedEpisode != null) { parsedEpisode.Size = _diskProvider.GetFileSize(file); decision = GetDecision(parsedEpisode); } else { parsedEpisode = new LocalEpisode(); parsedEpisode.Path = file; decision = new ImportDecision(parsedEpisode, "Unable to parse file"); } } catch (Exception e) { _logger.ErrorException("Couldn't import file." + file, e); } if (decision != null) { yield return decision; } } }
private static Series MapSeries(Show show) { var series = new Series(); series.TvdbId = show.tvdb_id; series.TvRageId = show.tvrage_id; series.ImdbId = show.imdb_id; series.Title = show.title; series.CleanTitle = Parser.Parser.CleanSeriesTitle(show.title); series.Year = GetYear(show.year, show.first_aired); series.FirstAired = FromIso(show.first_aired_iso); series.Overview = show.overview; series.Runtime = show.runtime; series.Network = show.network; series.AirTime = show.air_time_utc; series.TitleSlug = show.url.ToLower().Replace("http://trakt.tv/show/", ""); series.Status = GetSeriesStatus(show.status); series.Seasons = show.seasons.Select(s => new Tv.Season { SeasonNumber = s.season }).OrderByDescending(s => s.SeasonNumber).ToList(); series.Images.Add(new MediaCover.MediaCover { CoverType = MediaCoverTypes.Banner, Url = show.images.banner }); series.Images.Add(new MediaCover.MediaCover { CoverType = MediaCoverTypes.Poster, Url = GetPosterThumbnailUrl(show.images.poster) }); series.Images.Add(new MediaCover.MediaCover { CoverType = MediaCoverTypes.Fanart, Url = show.images.fanart }); return series; }
public WebhookSeries(Series series) { Id = series.Id; Title = series.Title; Path = series.Path; TvdbId = series.TvdbId; }
public List<ImportResult> ProcessPath(string path, Series series = null, DownloadClientItem downloadClientItem = null) { if (_diskProvider.FolderExists(path)) { var directoryInfo = new DirectoryInfo(path); if (series == null) { return ProcessFolder(directoryInfo, downloadClientItem); } return ProcessFolder(directoryInfo, series, downloadClientItem); } if (_diskProvider.FileExists(path)) { var fileInfo = new FileInfo(path); if (series == null) { return ProcessFile(fileInfo, downloadClientItem); } return ProcessFile(fileInfo, series, downloadClientItem); } _logger.Error("Import failed, path does not exist or is not accessible by Sonarr: {0}", path); return new List<ImportResult>(); }
private static Series MapSeries(Show show) { var series = new Series(); series.TvdbId = show.tvdb_id; series.TvRageId = show.tvrage_id; series.ImdbId = show.imdb_id; series.Title = show.title; series.CleanTitle = Parser.Parser.CleanSeriesTitle(show.title); series.Year = GetYear(show.year, show.first_aired); series.FirstAired = FromIso(show.first_aired_iso); series.Overview = show.overview; series.Runtime = show.runtime; series.Network = show.network; series.AirTime = show.air_time_utc; series.TitleSlug = show.url.ToLower().Replace("http://trakt.tv/show/", ""); series.Status = GetSeriesStatus(show.status, show.ended); series.Ratings = GetRatings(show.ratings); series.Genres = show.genres; series.Certification = show.certification; series.Actors = GetActors(show.people); series.Seasons = GetSeasons(show); series.Images.Add(new MediaCover.MediaCover { CoverType = MediaCoverTypes.Banner, Url = show.images.banner }); series.Images.Add(new MediaCover.MediaCover { CoverType = MediaCoverTypes.Poster, Url = GetPosterThumbnailUrl(show.images.poster) }); series.Images.Add(new MediaCover.MediaCover { CoverType = MediaCoverTypes.Fanart, Url = show.images.fanart }); return series; }
public void OnDownload(Series series, EpisodeFile episodeFile, string sourcePath, CustomScriptSettings settings) { var environmentVariables = new StringDictionary(); environmentVariables.Add("Sonarr_EventType", "Download"); environmentVariables.Add("Sonarr_Series_Id", series.Id.ToString()); environmentVariables.Add("Sonarr_Series_Title", series.Title); environmentVariables.Add("Sonarr_Series_Path", series.Path); environmentVariables.Add("Sonarr_Series_TvdbId", series.TvdbId.ToString()); environmentVariables.Add("Sonarr_EpisodeFile_Id", episodeFile.Id.ToString()); environmentVariables.Add("Sonarr_EpisodeFile_RelativePath", episodeFile.RelativePath); environmentVariables.Add("Sonarr_EpisodeFile_Path", Path.Combine(series.Path, episodeFile.RelativePath)); environmentVariables.Add("Sonarr_EpisodeFile_SeasonNumber", episodeFile.SeasonNumber.ToString()); environmentVariables.Add("Sonarr_EpisodeFile_EpisodeNumbers", string.Join(",", episodeFile.Episodes.Value.Select(e => e.EpisodeNumber))); environmentVariables.Add("Sonarr_EpisodeFile_EpisodeAirDates", string.Join(",", episodeFile.Episodes.Value.Select(e => e.AirDate))); environmentVariables.Add("Sonarr_EpisodeFile_EpisodeAirDatesUtc", string.Join(",", episodeFile.Episodes.Value.Select(e => e.AirDateUtc))); environmentVariables.Add("Sonarr_EpisodeFile_Quality", episodeFile.Quality.Quality.Name); environmentVariables.Add("Sonarr_EpisodeFile_QualityVersion", episodeFile.Quality.Revision.Version.ToString()); environmentVariables.Add("Sonarr_EpisodeFile_ReleaseGroup", episodeFile.ReleaseGroup ?? string.Empty); environmentVariables.Add("Sonarr_EpisodeFile_SceneName", episodeFile.SceneName ?? string.Empty); environmentVariables.Add("Sonarr_EpisodeFile_SourcePath", sourcePath); environmentVariables.Add("Sonarr_EpisodeFile_SourceFolder", Path.GetDirectoryName(sourcePath)); ExecuteScript(environmentVariables, settings); }
public LocalEpisode GetEpisodes(string filename, Series series, bool sceneSource) { var parsedEpisodeInfo = Parser.ParsePath(filename); if (parsedEpisodeInfo == null) { return null; } var episodes = GetEpisodes(parsedEpisodeInfo, series, sceneSource); if (!episodes.Any()) { return null; } return new LocalEpisode { Series = series, Quality = parsedEpisodeInfo.Quality, Episodes = episodes, Path = filename, ParsedEpisodeInfo = parsedEpisodeInfo, ExistingFile = _diskProvider.IsParent(series.Path, filename) }; }
private void UpdateLibrary(XbmcSettings settings, Series series) { try { var seriesPath = GetSeriesPath(settings, series); if (seriesPath != null) { _logger.Debug("Updating series {0} (Path: {1}) on XBMC host: {2}", series, seriesPath, settings.Address); } else { _logger.Debug("Series {0} doesn't exist on XBMC host: {1}, Updating Entire Library", series, settings.Address); } var response = _proxy.UpdateLibrary(settings, seriesPath); if (!response.Equals("OK", StringComparison.InvariantCultureIgnoreCase)) { _logger.Debug("Failed to update library for: {0}", settings.Address); } } catch (Exception ex) { _logger.DebugException(ex.Message, ex); } }
public List<ImportDecision> GetImportDecisions(IEnumerable<string> videoFiles, Series series, bool sceneSource) { var newFiles = _mediaFileService.FilterExistingFiles(videoFiles.ToList(), series.Id); _logger.Debug("Analysing {0}/{1} files.", newFiles.Count, videoFiles.Count()); return GetDecisions(newFiles, series, sceneSource).ToList(); }
public static NzbDrone.Core.Tv.Series ToModel(this SeriesResource resource, NzbDrone.Core.Tv.Series series) { var updatedSeries = resource.ToModel(); series.ApplyChanges(updatedSeries); return(series); }
public List<ImportDecision> GetImportDecisions(List<string> videoFiles, Series series, bool sceneSource, QualityModel quality = null) { var newFiles = _mediaFileService.FilterExistingFiles(videoFiles.ToList(), series.Id); _logger.Debug("Analyzing {0}/{1} files.", newFiles.Count, videoFiles.Count()); return GetDecisions(newFiles, series, sceneSource, quality).ToList(); }
public string MoveEpisodeFile(EpisodeFile episodeFile, Series series) { var episodes = _episodeService.GetEpisodesByFileId(episodeFile.Id); var newFileName = _buildFileNames.BuildFilename(episodes, series, episodeFile); var filePath = _buildFileNames.BuildFilePath(series, episodes.First().SeasonNumber, newFileName, Path.GetExtension(episodeFile.Path)); MoveFile(episodeFile, series, filePath); return filePath; }
public string BuildFileName(List<Episode> episodes, Series series, EpisodeFile episodeFile, NamingConfig namingConfig = null) { if (namingConfig == null) { namingConfig = _namingConfigService.GetConfig(); } if (!namingConfig.RenameEpisodes) { return GetOriginalTitle(episodeFile); } if (namingConfig.StandardEpisodeFormat.IsNullOrWhiteSpace() && series.SeriesType == SeriesTypes.Standard) { throw new NamingFormatException("Standard episode format cannot be empty"); } if (namingConfig.DailyEpisodeFormat.IsNullOrWhiteSpace() && series.SeriesType == SeriesTypes.Daily) { throw new NamingFormatException("Daily episode format cannot be empty"); } if (namingConfig.AnimeEpisodeFormat.IsNullOrWhiteSpace() && series.SeriesType == SeriesTypes.Anime) { throw new NamingFormatException("Anime episode format cannot be empty"); } var pattern = namingConfig.StandardEpisodeFormat; var tokenHandlers = new Dictionary<string, Func<TokenMatch, string>>(FileNameBuilderTokenEqualityComparer.Instance); episodes = episodes.OrderBy(e => e.SeasonNumber).ThenBy(e => e.EpisodeNumber).ToList(); if (series.SeriesType == SeriesTypes.Daily) { pattern = namingConfig.DailyEpisodeFormat; } if (series.SeriesType == SeriesTypes.Anime && episodes.All(e => e.AbsoluteEpisodeNumber.HasValue)) { pattern = namingConfig.AnimeEpisodeFormat; } pattern = AddSeasonEpisodeNumberingTokens(pattern, tokenHandlers, episodes, namingConfig); pattern = AddAbsoluteNumberingTokens(pattern, tokenHandlers, series, episodes, namingConfig); AddSeriesTokens(tokenHandlers, series); AddEpisodeTokens(tokenHandlers, episodes); AddEpisodeFileTokens(tokenHandlers, episodeFile); AddQualityTokens(tokenHandlers, series, episodeFile); AddMediaInfoTokens(tokenHandlers, episodeFile); 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 void Clean(Series series, List<string> filesOnDisk) { var seriesFiles = _mediaFileService.GetFilesBySeries(series.Id); var episodes = _episodeService.GetEpisodeBySeries(series.Id); var filesOnDiskKeys = new HashSet<string>(filesOnDisk, PathEqualityComparer.Instance); foreach (var seriesFile in seriesFiles) { var episodeFile = seriesFile; var episodeFilePath = Path.Combine(series.Path, episodeFile.RelativePath); try { if (!filesOnDiskKeys.Contains(episodeFilePath)) { _logger.Debug("File [{0}] no longer exists on disk, removing from db", episodeFilePath); _mediaFileService.Delete(seriesFile, DeleteMediaFileReason.MissingFromDisk); continue; } if (episodes.None(e => e.EpisodeFileId == episodeFile.Id)) { _logger.Debug("File [{0}] is not assigned to any episodes, removing from db", episodeFilePath); _mediaFileService.Delete(episodeFile, DeleteMediaFileReason.NoLinkedEpisodes); continue; } // var localEpsiode = _parsingService.GetLocalEpisode(episodeFile.Path, series); // // if (localEpsiode == null || episodes.Count != localEpsiode.Episodes.Count) // { // _logger.Debug("File [{0}] parsed episodes has changed, removing from db", episodeFile.Path); // _mediaFileService.Delete(episodeFile); // continue; // } } catch (Exception ex) { var errorMessage = string.Format("Unable to cleanup EpisodeFile in DB: {0}", episodeFile.Id); _logger.Error(ex, errorMessage); } } foreach (var e in episodes) { var episode = e; if (episode.EpisodeFileId > 0 && seriesFiles.None(f => f.Id == episode.EpisodeFileId)) { episode.EpisodeFileId = 0; _episodeService.UpdateEpisode(episode); } } }
public EpisodeFile MoveEpisodeFile(EpisodeFile episodeFile, Series series) { var episodes = _episodeService.GetEpisodesByFileId(episodeFile.Id); var newFileName = _buildFileNames.BuildFilename(episodes, series, episodeFile); var filePath = _buildFileNames.BuildFilePath(series, episodes.First().SeasonNumber, newFileName, Path.GetExtension(episodeFile.Path)); _logger.Trace("Renaming episode file: {0} to {1}", episodeFile, filePath); return MoveFile(episodeFile, series, filePath); }
public void OnRename(Series series, WebhookSettings settings) { var payload = new WebhookPayload { EventType = "Rename", Series = new WebhookSeries(series) }; NotifyWebhook(payload, settings); }
protected override bool IsValid(PropertyValidatorContext context) { if (context.PropertyValue == null) return true; var series = new Series(); series.InjectFrom(context.ParentContext.InstanceToValidate); if (series.Id == 0) return true; return (!_seriesService.GetAllSeries().Exists(s => s.Path.PathEquals(context.PropertyValue.ToString()) && s.Id != series.Id)); }
private int PrioritizeDownloadProtocol(Series series, DownloadProtocol downloadProtocol) { var delayProfile = _delayProfileService.BestForTags(series.Tags); if (downloadProtocol == delayProfile.PreferredProtocol) { return 0; } return 1; }
public FilenameSampleService(IBuildFileNames buildFileNames) { _buildFileNames = buildFileNames; _standardSeries = new Series { SeriesType = SeriesTypes.Standard, Title = "Series Title" }; _dailySeries = new Series { SeriesType = SeriesTypes.Daily, Title = "Series Title" }; _episode1 = new Episode { SeasonNumber = 1, EpisodeNumber = 1, Title = "Episode Title (1)", AirDate = "2013-10-30" }; _episode2 = new Episode { SeasonNumber = 1, EpisodeNumber = 2, Title = "Episode Title (2)" }; _singleEpisode = new List<Episode> { _episode1 }; _multiEpisodes = new List<Episode> { _episode1, _episode2 }; _singleEpisodeFile = new EpisodeFile { Quality = new QualityModel(Quality.HDTV720p), Path = @"C:\Test\Series.Title.S01E01.720p.HDTV.x264-EVOLVE.mkv", ReleaseGroup = "RlsGrp" }; _multiEpisodeFile = new EpisodeFile { Quality = new QualityModel(Quality.HDTV720p), Path = @"C:\Test\Series.Title.S01E01-E02.720p.HDTV.x264-EVOLVE.mkv", ReleaseGroup = "RlsGrp" }; _dailyEpisodeFile = new EpisodeFile { Quality = new QualityModel(Quality.HDTV720p), Path = @"C:\Test\Series.Title.2013.10.30.HDTV.x264-EVOLVE.mkv", ReleaseGroup = "RlsGrp" }; }
public EpisodeFile MoveEpisodeFile(EpisodeFile episodeFile, Series series) { var episodes = _episodeService.GetEpisodesByFileId(episodeFile.Id); var newFileName = _buildFileNames.BuildFileName(episodes, series, episodeFile); var filePath = _buildFileNames.BuildFilePath(series, episodes.First().SeasonNumber, newFileName, Path.GetExtension(episodeFile.RelativePath)); EnsureEpisodeFolder(episodeFile, series, episodes.Select(v => v.SeasonNumber).First(), filePath); _logger.Debug("Renaming episode file: {0} to {1}", episodeFile, filePath); return TransferFile(episodeFile, series, episodes, filePath, TransferMode.Move); }
public void OnRename(Series series, CustomScriptSettings settings) { var environmentVariables = new StringDictionary(); environmentVariables.Add("Sonarr_EventType", "Rename"); environmentVariables.Add("Sonarr_Series_Id", series.Id.ToString()); environmentVariables.Add("Sonarr_Series_Title", series.Title); environmentVariables.Add("Sonarr_Series_Path", series.Path); environmentVariables.Add("Sonarr_Series_TvdbId", series.TvdbId.ToString()); ExecuteScript(environmentVariables, settings); }
public bool IsSample(Series series, QualityModel quality, string path, long size, int seasonNumber) { if (seasonNumber == 0) { _logger.Debug("Special, skipping sample check"); return false; } var extension = Path.GetExtension(path); if (extension != null && extension.Equals(".flv", StringComparison.InvariantCultureIgnoreCase)) { _logger.Debug("Skipping sample check for .flv file"); return false; } if (extension != null && extension.Equals(".strm", StringComparison.InvariantCultureIgnoreCase)) { _logger.Debug("Skipping sample check for .strm file"); return false; } try { var runTime = _videoFileInfoReader.GetRunTime(path); var minimumRuntime = GetMinimumAllowedRuntime(series); if (runTime.TotalMinutes.Equals(0)) { _logger.Error("[{0}] has a runtime of 0, is it a valid video file?", path); return true; } if (runTime.TotalSeconds < minimumRuntime) { _logger.Debug("[{0}] appears to be a sample. Runtime: {1} seconds. Expected at least: {2} seconds", path, runTime, minimumRuntime); return true; } } catch (DllNotFoundException) { _logger.Debug("Falling back to file size detection"); return CheckSize(size, quality); } _logger.Debug("Runtime is over 90 seconds"); return false; }
public void Clean(Series series) { _logger.Debug("Cleaning missing metadata files for series: {0}", series.Title); var metadataFiles = _metadataFileService.GetFilesBySeries(series.Id); foreach (var metadataFile in metadataFiles) { if (!_diskProvider.FileExists(Path.Combine(series.Path, metadataFile.RelativePath))) { _logger.Debug("Deleting metadata file from database: {0}", metadataFile.RelativePath); _metadataFileService.Delete(metadataFile.Id); } } }
public void OnGrab(Series series, RemoteEpisode episode, QualityModel quality, WebhookSettings settings) { var payload = new WebhookPayload { EventType = "Grab", Series = new WebhookSeries(series), Episodes = episode.Episodes.ConvertAll(x => new WebhookEpisode(x) { Quality = quality.Quality.Name, QualityVersion = quality.Revision.Version, ReleaseGroup = episode.ParsedEpisodeInfo.ReleaseGroup }) }; NotifyWebhook(payload, settings); }
public List<ImportDecision> GetImportDecisions(List<string> videoFiles, Series series, ParsedEpisodeInfo folderInfo, bool sceneSource) { var newFiles = _mediaFileService.FilterExistingFiles(videoFiles.ToList(), series); _logger.Debug("Analyzing {0}/{1} files.", newFiles.Count, videoFiles.Count()); var shouldUseFolderName = ShouldUseFolderName(videoFiles, series, folderInfo); var decisions = new List<ImportDecision>(); foreach (var file in newFiles) { decisions.AddIfNotNull(GetDecision(file, series, folderInfo, sceneSource, shouldUseFolderName)); } return decisions; }
public void Update(XbmcSettings settings, Series series) { if (!settings.AlwaysUpdate) { _logger.Debug("Determining if there are any active players on XBMC host: {0}", settings.Address); var activePlayers = GetActivePlayers(settings); if (activePlayers.Any(a => a.Type.Equals("video"))) { _logger.Debug("Video is currently playing, skipping library update"); return; } } UpdateLibrary(settings, series); }
public void OnDownload(Series series, EpisodeFile episodeFile, WebhookSettings settings) { var payload = new WebhookPayload { EventType = "Download", Series = new WebhookSeries(series), Episodes = episodeFile.Episodes.Value.ConvertAll(x => new WebhookEpisode(x) { Quality = episodeFile.Quality.Quality.Name, QualityVersion = episodeFile.Quality.Revision.Version, ReleaseGroup = episodeFile.ReleaseGroup, SceneName = episodeFile.SceneName }) }; NotifyWebhook(payload, settings); }
public void RemoveAddOptions(Series series) { _seriesRepository.SetFields(series, s => s.AddOptions); }