public SickRageSeasonList VerifyShowHasLoaded(int tvdbId, string apiKey, Uri baseUrl) { Log.Trace("Entered `VerifyShowHasLoaded({0} <- id)`", tvdbId); var request = new RestRequest { Resource = "/api/{apiKey}/?cmd=show.seasonlist", Method = Method.GET }; request.AddUrlSegment("apiKey", apiKey); request.AddQueryParameter("tvdbid", tvdbId.ToString()); try { var policy = RetryHandler.RetryAndWaitPolicy( null, (exception, timespan) => Log.Error(exception, "Exception when calling VerifyShowHasLoaded for SR, Retrying {0}", timespan)); var obj = policy.Execute(() => Api.ExecuteJson <SickRageSeasonList>(request, baseUrl)); return(obj); } catch (Exception e) { Log.Error(e); return(new SickRageSeasonList()); } }
public async Task <SickrageShows> GetShows(string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/{apiKey}/?cmd=shows", Method = Method.GET }; request.AddUrlSegment("apiKey", apiKey); return(await Task.Run( () => { try { var policy = RetryHandler.RetryAndWaitPolicy( new[] { TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30) }, (exception, timespan) => Log.Error(exception, "Exception when calling GetShows for SR, Retrying {0}", timespan)); return policy.Execute(() => Api.Execute <SickrageShows>(request, baseUrl)); } catch (ApiRequestException) { Log.Error("There has been a API exception when Getting the Sickrage shows"); return null; } }).ConfigureAwait(false)); }
public PlexEpisodeMetadata GetEpisodeMetaData(string authToken, Uri host, string ratingKey) { //192.168.1.69:32400/library/metadata/3662/allLeaves // The metadata ratingkey should be in the Cache // Search for it and then call the above with the Directory.RatingKey // THEN! We need the episode metadata using result.Vide.Key ("/library/metadata/3664") // We then have the GUID which contains the TVDB ID plus the season and episode number: guid="com.plexapp.agents.thetvdb://269586/2/8?lang=en" var request = new RestRequest { Method = Method.GET, Resource = "/library/metadata/{ratingKey}" }; request.AddUrlSegment("ratingKey", ratingKey); AddHeaders(ref request, authToken); try { var lib = RetryHandler.Execute(() => Api.ExecuteXml <PlexEpisodeMetadata>(request, host), (exception, timespan) => Log.Error(exception, "Exception when calling GetEpisodeMetaData for Plex, Retrying {0}", timespan)); return(lib); } catch (Exception e) { Log.Error(e, "There has been a API Exception when attempting to get GetEpisodeMetaData"); return(new PlexEpisodeMetadata()); } }
public PlexAuthentication SignIn(string username, string password) { var userModel = new PlexUserRequest { user = new UserRequest { password = password, login = username } }; var request = new RestRequest { Method = Method.POST }; AddHeaders(ref request); request.AddJsonBody(userModel); var obj = RetryHandler.Execute <PlexAuthentication>(() => Api.Execute <PlexAuthentication> (request, new Uri(SignInUri)), null, (exception, timespan) => Log.Error(exception, "Exception when calling SignIn for Plex, Retrying {0}", timespan)); return(obj); }
public RecentlyAddedModel RecentlyAdded(string authToken, Uri plexFullHost, string sectionId) { var request = new RestRequest { Method = Method.GET, Resource = "library/sections/{sectionId}/recentlyAdded" }; request.AddUrlSegment("sectionId", sectionId); AddHeaders(ref request, authToken, true); AddLimitHeaders(ref request, 0, 25); try { var lib = RetryHandler.Execute(() => Api.ExecuteJson <RecentlyAddedModel>(request, plexFullHost), (exception, timespan) => Log.Error(exception, "Exception when calling RecentlyAddedModel for Plex, Retrying {0}", timespan), new[] { TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30) }); return(lib); } catch (Exception e) { Log.Error(e, "There has been a API Exception when attempting to get the Plex RecentlyAddedModel"); return(new RecentlyAddedModel()); } }
public PlexLibraries GetLibrarySections(string authToken, Uri plexFullHost) { var request = new RestRequest { Method = Method.GET, Resource = "library/sections" }; AddHeaders(ref request, authToken, false); try { var lib = RetryHandler.Execute(() => Api.ExecuteXml <PlexLibraries> (request, plexFullHost), (exception, timespan) => Log.Error(exception, "Exception when calling GetLibrarySections for Plex, Retrying {0}", timespan), new TimeSpan[] { TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30) }); return(lib); } catch (Exception e) { Log.Error(e, "There has been a API Exception when attempting to get the Plex Libraries"); return(new PlexLibraries()); } }
public CouchPotatoMovies GetMovies(Uri baseUrl, string apiKey, string[] status) { var request = new RestRequest { Resource = "/api/{apikey}/movie.list?status={status}", OnBeforeDeserialization = (x => { x.Content = x.Content.Replace("[]", "{}"); }) }; request.AddUrlSegment("apikey", apiKey); request.AddUrlSegment("status", string.Join(",", status)); try { var obj = RetryHandler.Execute(() => Api.Execute <CouchPotatoMovies>(request, baseUrl), (exception, timespan) => Log.Error(exception, "Exception when calling GetMovies for CP, Retrying {0}", timespan), new[] { TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30) }); return(obj); } catch (Exception e) // Request error is already logged in the ApiRequest class { Log.Error("Error when attempting to GetMovies."); Log.Error(e); return(new CouchPotatoMovies()); } }
public PlexSeasonMetadata GetSeasons(string authToken, Uri plexFullHost, string ratingKey) { var request = new RestRequest { Method = Method.GET, Resource = "library/metadata/{ratingKey}/children" }; request.AddUrlSegment("ratingKey", ratingKey); AddHeaders(ref request, authToken); try { var lib = RetryHandler.Execute(() => Api.ExecuteXml <PlexSeasonMetadata>(request, plexFullHost), (exception, timespan) => Log.Error(exception, "Exception when calling GetMetadata for Plex, Retrying {0}", timespan), new[] { TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30) }); return(lib); } catch (Exception e) { Log.Error(e, "There has been a API Exception when attempting to get the Plex GetMetadata"); return(new PlexSeasonMetadata()); } }
public SonarrSeriesSearchResult SearchForSeries(int seriesId, string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/Command", Method = Method.POST }; request.AddHeader("X-Api-Key", apiKey); var body = new SonarrSearchCommand { name = "SeriesSearch", seriesId = seriesId }; request.AddJsonBody(body); try { var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling SearchForSeries for Sonarr, Retrying {0}", timespan)); return(policy.Execute(() => Api.ExecuteJson <SonarrSeriesSearchResult>(request, baseUrl))); } catch (Exception e) { Log.Error(e, "There has been an API exception when put the Sonarr SearchForSeries"); return(null); } }
public async Task <SickRageTvAdd> AddSeason(int tvdbId, int season, string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/{apiKey}/?cmd=episode.setstatus", Method = Method.GET }; request.AddUrlSegment("apiKey", apiKey); request.AddQueryParameter("tvdbid", tvdbId.ToString()); request.AddQueryParameter("season", season.ToString()); request.AddQueryParameter("status", SickRageStatus.Wanted); await Task.Run(() => Thread.Sleep(2000)); return(await Task.Run( () => { var policy = RetryHandler.RetryAndWaitPolicy( null, (exception, timespan) => Log.Error(exception, "Exception when calling AddSeason for SR, Retrying {0}", timespan)); var result = policy.Execute(() => Api.Execute <SickRageTvAdd>(request, baseUrl)); return result; }).ConfigureAwait(false)); }
public PlexSearch GetAllEpisodes(string authToken, Uri host, string section, int startPage, int returnCount) { var request = new RestRequest { Method = Method.GET, Resource = "/library/sections/{section}/all" }; request.AddQueryParameter("type", 4.ToString()); request.AddQueryParameter("X-Plex-Container-Start", startPage.ToString()); request.AddQueryParameter("X-Plex-Container-Size", returnCount.ToString()); request.AddUrlSegment("section", section); AddHeaders(ref request, authToken); try { var lib = RetryHandler.Execute(() => Api.ExecuteXml <PlexSearch>(request, host), (exception, timespan) => Log.Error(exception, "Exception when calling GetAllEpisodes for Plex, Retrying {0}", timespan)); return(lib); } catch (Exception e) { Log.Error(e, "There has been a API Exception when attempting to get GetAllEpisodes"); return(new PlexSearch()); } }
public PlexSearch GetLibrary(string authToken, Uri plexFullHost, string libraryId) { var request = new RestRequest { Method = Method.GET, Resource = "library/sections/{libraryId}/all" }; request.AddUrlSegment("libraryId", libraryId); AddHeaders(ref request, authToken); try { var lib = RetryHandler.Execute(() => Api.ExecuteXml <PlexSearch> (request, plexFullHost), (exception, timespan) => Log.Error(exception, "Exception when calling GetLibrary for Plex, Retrying {0}", timespan), new TimeSpan[] { TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30) }); return(lib); } catch (Exception e) { Log.Error(e, "There has been a API Exception when attempting to get the Plex Library"); return(new PlexSearch()); } }
public SickRagePing Ping(string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/{apiKey}/?cmd=sb.ping", Method = Method.GET }; var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling Ping for SR, Retrying {0}", timespan), null); request.AddUrlSegment("apiKey", apiKey); var obj = policy.Execute(() => Api.ExecuteJson <SickRagePing>(request, baseUrl)); return(obj); }
public PlexAccount GetAccount(string authToken) { var request = new RestRequest { Method = Method.GET, }; AddHeaders(ref request, authToken); var account = RetryHandler.Execute(() => Api.ExecuteXml <PlexAccount> (request, new Uri(GetAccountUri)), (exception, timespan) => Log.Error(exception, "Exception when calling GetAccount for Plex, Retrying {0}", timespan), null); return(account); }
public PlexStatus GetStatus(string authToken, Uri uri) { var request = new RestRequest { Method = Method.GET, }; AddHeaders(ref request, authToken); var users = RetryHandler.Execute(() => Api.ExecuteXml <PlexStatus> (request, uri), (exception, timespan) => Log.Error(exception, "Exception when calling GetStatus for Plex, Retrying {0}", timespan), null); return(users); }
public CouchPotatoProfiles GetProfiles(Uri url, string apiKey) { var request = new RestRequest { Resource = "api/{apikey}/profile.list/", Method = Method.GET }; request.AddUrlSegment("apikey", apiKey); var obj = RetryHandler.Execute(() => Api.Execute <CouchPotatoProfiles>(request, url), (exception, timespan) => Log.Error(exception, "Exception when calling GetProfiles for CP, Retrying {0}", timespan), null); return(obj); }
public PlexServer GetServer(string authToken) { var request = new RestRequest { Method = Method.GET, }; AddHeaders(ref request, authToken); var servers = RetryHandler.Execute(() => Api.ExecuteXml <PlexServer>(request, new Uri(ServerUri)), (exception, timespan) => Log.Error(exception, "Exception when calling GetServer for Plex, Retrying {0}", timespan)); return(servers); }
public PlexFriends GetUsers(string authToken) { var request = new RestRequest { Method = Method.GET, }; AddHeaders(ref request, authToken, false); var users = RetryHandler.Execute(() => Api.ExecuteXml <PlexFriends> (request, new Uri(FriendsUri)), (exception, timespan) => Log.Error(exception, "Exception when calling GetUsers for Plex, Retrying {0}", timespan), null); return(users); }
public CouchPotatoApiKey GetApiKey(Uri baseUrl, string username, string password) { var request = new RestRequest { Resource = "getkey/?u={username}&p={password}", Method = Method.GET }; request.AddUrlSegment("username", StringHasher.CalcuateMd5Hash(username)); request.AddUrlSegment("password", StringHasher.CalcuateMd5Hash(password)); var obj = RetryHandler.Execute(() => Api.Execute <CouchPotatoApiKey>(request, baseUrl), (exception, timespan) => Log.Error(exception, "Exception when calling GetApiKey for CP, Retrying {0}", timespan), null); return(obj); }
/// <summary> /// Gets the users. /// </summary> /// <param name="authToken">The authentication token.</param> /// <param name="searchTerm">The search term.</param> /// <param name="plexFullHost">The full plex host.</param> /// <returns></returns> public PlexSearch SearchContent(string authToken, string searchTerm, Uri plexFullHost) { var request = new RestRequest { Method = Method.GET, Resource = "search?query={searchTerm}" }; request.AddUrlSegment("searchTerm", searchTerm); AddHeaders(ref request, authToken); var search = RetryHandler.Execute(() => Api.ExecuteXml <PlexSearch> (request, plexFullHost), (exception, timespan) => Log.Error(exception, "Exception when calling SearchContent for Plex, Retrying {0}", timespan), null); return(search); }
public bool AddMovie(string imdbid, string apiKey, string title, Uri baseUrl, string profileId = default(string)) { RestRequest request; request = string.IsNullOrEmpty(profileId) ? new RestRequest { Resource = "/api/{apikey}/movie.add?title={title}&identifier={imdbid}" } : new RestRequest { Resource = "/api/{apikey}/movie.add?title={title}&identifier={imdbid}&profile_id={profileId}" }; if (!string.IsNullOrEmpty(profileId)) { request.AddUrlSegment("profileId", profileId); } request.AddUrlSegment("apikey", apiKey); request.AddUrlSegment("imdbid", imdbid); request.AddUrlSegment("title", title); var obj = RetryHandler.Execute <JObject>(() => Api.ExecuteJson <JObject> (request, baseUrl), new TimeSpan[] { TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10) }, (exception, timespan) => Log.Error(exception, "Exception when calling AddMovie for CP, Retrying {0}", timespan)); Log.Trace("CP movie Add result count {0}", obj.Count); if (obj.Count > 0) { try { Log.Trace("CP movie obj[\"success\"] = {0}", obj["success"]); var result = (bool)obj["success"]; Log.Trace("CP movie Add result {0}", result); return(result); } catch (Exception e) { Log.Fatal(e); return(false); } } return(false); }
public List <SonarrProfile> GetProfiles(string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/profile", Method = Method.GET }; request.AddHeader("X-Api-Key", apiKey); var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling GetProfiles for Sonarr, Retrying {0}", timespan), new TimeSpan[] { TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10) }); var obj = policy.Execute(() => Api.ExecuteJson <List <SonarrProfile> >(request, baseUrl)); return(obj); }
public SystemStatus SystemStatus(string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/system/status", Method = Method.GET }; request.AddHeader("X-Api-Key", apiKey); var policy = RetryHandler.RetryAndWaitPolicy(new TimeSpan[] { TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10) }, (exception, timespan) => Log.Error(exception, "Exception when calling SystemStatus for Sonarr, Retrying {0}", timespan)); var obj = policy.Execute(() => Api.ExecuteJson <SystemStatus>(request, baseUrl)); return(obj); }
/// <summary> /// Gets the status. /// </summary> /// <param name="url">The URL.</param> /// <param name="apiKey">The API key.</param> /// <returns></returns> public CouchPotatoStatus GetStatus(Uri url, string apiKey) { var request = new RestRequest { Resource = "api/{apikey}/app.available/", Method = Method.GET }; request.AddUrlSegment("apikey", apiKey); var obj = RetryHandler.Execute <CouchPotatoStatus>(() => Api.Execute <CouchPotatoStatus>(request, url), (exception, timespan) => Log.Error(exception, "Exception when calling GetStatus for CP, Retrying {0}", timespan), new TimeSpan[] { TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10) }); return(obj); }
public SonarrEpisodes UpdateEpisode(SonarrEpisodes episodeInfo, string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/Episode", Method = Method.PUT }; request.AddHeader("X-Api-Key", apiKey); request.AddJsonBody(episodeInfo); try { var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling UpdateEpisode for Sonarr, Retrying {0}", timespan)); return(policy.Execute(() => Api.ExecuteJson <SonarrEpisodes>(request, baseUrl))); } catch (Exception e) { Log.Error(e, "There has been an API exception when put the Sonarr UpdateEpisode"); return(null); } }
/// <summary> /// Returns the episode with the matching id. /// </summary> /// <param name="episodeId">The episode identifier.</param> /// <param name="apiKey">The API key.</param> /// <param name="baseUrl">The base URL.</param> /// <returns></returns> public SonarrEpisode GetEpisode(string episodeId, string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/Episode/{episodeId}", Method = Method.GET }; request.AddHeader("X-Api-Key", apiKey); request.AddUrlSegment("episodeId", episodeId); try { var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling GetEpisode by ID for Sonarr, Retrying {0}", timespan)); return(policy.Execute(() => Api.ExecuteJson <SonarrEpisode>(request, baseUrl))); } catch (Exception e) { Log.Error(e, "There has been an API exception when getting the Sonarr GetEpisode by ID"); return(null); } }
/// <summary> /// Returns all episodes for the given series. /// </summary> /// <param name="seriesId">The series identifier.</param> /// <param name="apiKey">The API key.</param> /// <param name="baseUrl">The base URL.</param> /// <returns></returns> public IEnumerable <SonarrEpisodes> GetEpisodes(string seriesId, string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/Episode", Method = Method.GET }; request.AddHeader("X-Api-Key", apiKey); request.AddQueryParameter("seriesId", seriesId); try { var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling GetEpisodes for Sonarr, Retrying {0}", timespan)); return(policy.Execute(() => Api.ExecuteJson <List <SonarrEpisodes> >(request, baseUrl))); } catch (Exception e) { Log.Error(e, "There has been an API exception when getting the Sonarr GetEpisodes"); return(null); } }
public List <Series> GetSeries(string apiKey, Uri baseUrl) { var request = new RestRequest { Resource = "/api/series", Method = Method.GET }; request.AddHeader("X-Api-Key", apiKey); try { var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling GetSeries for Sonarr, Retrying {0}", timespan), new TimeSpan[] { TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30) }); return(policy.Execute(() => Api.ExecuteJson <List <Series> >(request, baseUrl))); } catch (Exception e) { Log.Error(e, "There has been an API exception when getting the Sonarr Series"); return(null); } }
public SonarrAddSeries AddSeries(int tvdbId, string title, int qualityId, bool seasonFolders, string rootPath, int seasonCount, int[] seasons, string apiKey, Uri baseUrl, bool monitor = true, bool searchForMissingEpisodes = false) { Log.Debug("Adding series {0}", title); Log.Debug("Seasons = {0}, out of {1} seasons", seasons.DumpJson(), seasonCount); var request = new RestRequest { Resource = "/api/Series?", Method = Method.POST }; var options = new SonarrAddSeries { seasonFolder = seasonFolders, title = title, qualityProfileId = qualityId, tvdbId = tvdbId, titleSlug = title, seasons = new List <Season>(), rootFolderPath = rootPath, monitored = monitor }; if (!searchForMissingEpisodes) { options.addOptions = new AddOptions { searchForMissingEpisodes = false, ignoreEpisodesWithFiles = true, ignoreEpisodesWithoutFiles = true }; } for (var i = 1; i <= seasonCount; i++) { var season = new Season { seasonNumber = i, // ReSharper disable once SimplifyConditionalTernaryExpression monitored = monitor ? seasons.Length == 0 || seasons.Any(x => x == i) : false }; options.seasons.Add(season); } Log.Debug("Sonarr API Options:"); Log.Debug(options.DumpJson()); request.AddHeader("X-Api-Key", apiKey); request.AddJsonBody(options); SonarrAddSeries result; try { var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling AddSeries for Sonarr, Retrying {0}", timespan), new TimeSpan[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), }); result = policy.Execute(() => Api.ExecuteJson <SonarrAddSeries>(request, baseUrl)); } catch (JsonSerializationException jse) { Log.Error(jse); var error = Api.ExecuteJson <List <SonarrError> >(request, baseUrl); var messages = error?.Select(x => x.errorMessage).ToList(); messages?.ForEach(x => Log.Error(x)); result = new SonarrAddSeries { ErrorMessages = messages }; } return(result); }
public async Task <SickRageTvAdd> AddSeries(int tvdbId, int seasonCount, int[] seasons, string quality, string apiKey, Uri baseUrl) { var futureStatus = seasons.Length > 0 && !seasons.Any(x => x == seasonCount) ? SickRageStatus.Skipped : SickRageStatus.Wanted; var status = seasons.Length > 0 ? SickRageStatus.Skipped : SickRageStatus.Wanted; Log.Trace("Future Status: {0}", futureStatus); Log.Trace("Current Status: {0}", status); var request = new RestRequest { Resource = "/api/{apiKey}/?cmd=show.addnew", Method = Method.GET }; request.AddUrlSegment("apiKey", apiKey); request.AddQueryParameter("tvdbid", tvdbId.ToString()); request.AddQueryParameter("status", status); request.AddQueryParameter("future_status", futureStatus); if (!quality.Equals("default", StringComparison.CurrentCultureIgnoreCase)) { Log.Trace("Settings quality to {0}", quality); request.AddQueryParameter("initial", quality); } var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) => Log.Error(exception, "Exception when calling AddSeries for SR, Retrying {0}", timespan), null); var obj = policy.Execute(() => Api.Execute <SickRageTvAdd>(request, baseUrl)); Log.Trace("obj Result:"); Log.Trace(obj.DumpJson()); if (obj.result != "failure") { var sw = new Stopwatch(); sw.Start(); var seasonIncrement = 0; var seasonList = new SickRageSeasonList(); try { while (seasonIncrement < seasonCount) { seasonList = VerifyShowHasLoaded(tvdbId, apiKey, baseUrl); if (seasonList.result.Equals("failure")) { Thread.Sleep(3000); continue; } seasonIncrement = seasonList.Data?.Length ?? 0; Log.Trace("New seasonIncrement -> {0}", seasonIncrement); if (sw.ElapsedMilliseconds > 30000) // Break out after 30 seconds, it's not going to get added { Log.Warn("Couldn't find out if the show had been added after 10 seconds. I doubt we can change the status to wanted."); break; } } sw.Stop(); } catch (Exception e) { Log.Error("Exception thrown when getting the seasonList"); Log.Error(e); } } Log.Trace("seasons.Length > 0 where seasons.Len -> {0}", seasons.Length); try { if (seasons.Length > 0) { //handle the seasons requested foreach (var s in seasons) { Log.Trace("Adding season {0}", s); var result = await AddSeason(tvdbId, s, apiKey, baseUrl); Log.Trace("SickRage adding season results: "); Log.Trace(result.DumpJson()); } } } catch (Exception e) { Log.Trace("Exception when adding seasons:"); Log.Error(e); throw; } Log.Trace("Finished with the API, returning the obj"); return(obj); }