public void Queued()
{
var settings = SonarrSettings.GetSettings();
if (settings.Enabled)
{
Job.SetRunning(true, JobNames.SonarrCacher);
try
{
var series = SonarrApi.GetSeries(settings.ApiKey, settings.FullUri);
if (series != null)
{
Cache.Set(CacheKeys.SonarrQueued, series, CacheKeys.TimeFrameMinutes.SchedulerCaching);
}
}
catch (System.Exception ex)
{
Log.Error(ex, "Failed caching queued items from Sonarr");
}
finally
{
Job.Record(JobNames.SonarrCacher);
Job.SetRunning(false, JobNames.SonarrCacher);
}
}
}
public static void ResetDatabase()
{
var defaultSettings = new PlexRequestSettings
{
RequireTvShowApproval = true,
RequireMovieApproval = true,
SearchForMovies = true,
SearchForTvShows = true,
BaseUrl = string.Empty,
CollectAnalyticData = true,
};
UpdateSettings(defaultSettings);
LandingPageSettings lp = null;
PlexSettings plexSettings = null;
SonarrSettings sonarr = null;
CouchPotatoSettings cp = null;
SickRageSettings sr = null;
UpdateSettings(lp);
UpdateSettings(plexSettings);
UpdateSettings(sonarr);
UpdateSettings(cp);
UpdateSettings(sr);
}
private async Task <SonarrAddSeries> ProcessSonarrRequestSeason(SonarrSettings sonarrSettings, RequestedModel model, int qualityId, string rootFolderPath)
{
// Does the series exist?
var series = await GetSonarrSeries(sonarrSettings, model.ProviderId);
if (series == null)
{
//WORKS
// Add the series
return(AddSeries(sonarrSettings, model, rootFolderPath, qualityId));
}
// Also make sure the series is now monitored otherwise we won't search for it
series.monitored = true;
foreach (var seasons in series.seasons)
{
seasons.monitored = true;
}
// Send the update command
series = SonarrApi.UpdateSeries(series, sonarrSettings.ApiKey, sonarrSettings.FullUri);
SonarrApi.SearchForSeries(series.id, sonarrSettings.ApiKey, sonarrSettings.FullUri);
return(new SonarrAddSeries {
title = series.title
});
}
public async Task <SenderResult> Send(ChildRequests model)
{
var sonarr = await SonarrSettings.GetSettingsAsync();
if (sonarr.Enabled)
{
var result = await SendToSonarr(model);
if (result != null)
{
return(new SenderResult
{
Sent = true,
Success = true
});
}
}
var dog = await DogNzbSettings.GetSettingsAsync();
if (dog.Enabled)
{
var result = await SendToDogNzb(model, dog);
if (!result.Failure)
{
return(new SenderResult
{
Sent = true,
Success = true
});
}
return(new SenderResult
{
Message = result.ErrorMessage
});
}
var sr = await SickRageSettings.GetSettingsAsync();
if (sr.Enabled)
{
var result = await SendToSickRage(model, sr);
if (result)
{
return(new SenderResult
{
Sent = true,
Success = true
});
}
return(new SenderResult
{
Message = "Could not send to SickRage!"
});
}
return(new SenderResult
{
Success = true
});
}
public void SetUp()
{
var mockRepo = new Mock <ISqlRepository <SonarrSettings> >();
ExpectedLink = new SonarrSettings
{
Id = 1,
Enabled = true,
IpAddress = "192",
Port = 25,
ShowOnDashboard = true,
ApiKey = "abc"
};
ExpectedGetLinks = new List <SonarrSettings>
{
ExpectedLink,
};
mockRepo.Setup(x => x.GetAll()).Returns(ExpectedGetLinks).Verifiable();
mockRepo.Setup(x => x.Get(1)).Returns(ExpectedLink).Verifiable();
mockRepo.Setup(x => x.Update(It.IsAny <SonarrSettings>())).Returns(true).Verifiable();
mockRepo.Setup(x => x.Insert(It.IsAny <SonarrSettings>())).Returns(1).Verifiable();
MockRepo = mockRepo;
Service = new SonarrSettingsService(MockRepo.Object);
}
private async Task <string> GetRootPath(int pathId, SonarrSettings sonarrSettings)
{
var rootFoldersResult = await Cache.GetOrSetAsync(CacheKeys.SonarrRootFolders, async() =>
{
return(await Task.Run(() => SonarrApi.GetRootFolders(sonarrSettings.ApiKey, sonarrSettings.FullUri)));
});
foreach (var r in rootFoldersResult.Where(r => r.id == pathId))
{
return(r.path);
}
int outRoot;
var defaultPath = int.TryParse(sonarrSettings.RootPath, out outRoot);
if (defaultPath)
{
// Return default path
return(rootFoldersResult.FirstOrDefault(x => x.id.Equals(outRoot))?.path ?? string.Empty);
}
else
{
return(rootFoldersResult.FirstOrDefault()?.path ?? string.Empty);
}
}
private async Task <Response> ChangeRootFolder(int id, int rootFolderId)
{
// Get all root folders
var settings = await SonarrSettings.GetSettingsAsync();
var rootFolders = SonarrApi.GetRootFolders(settings.ApiKey, settings.FullUri);
// Get Request
var allRequests = await Service.GetAllAsync();
var request = allRequests.FirstOrDefault(x => x.Id == id);
if (request == null)
{
return(Response.AsJson(new JsonResponseModel {
Result = false
}));
}
foreach (var folder in rootFolders)
{
if (folder.id.Equals(rootFolderId))
{
request.RootFolderSelected = folder.id;
break;
}
}
await Service.UpdateRequestAsync(request);
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
private async Task <Series> GetSonarrSeries(SonarrSettings sonarrSettings, int showId)
{
var task = await Task.Run(() => SonarrApi.GetSeries(sonarrSettings.ApiKey, sonarrSettings.FullUri)).ConfigureAwait(false);
var selectedSeries = task.FirstOrDefault(series => series.tvdbId == showId);
return(selectedSeries);
}
public async Task <bool> SonarrSettings([FromBody] SonarrSettings settings)
{
var result = await Save(settings);
if (result)
{
await OmbiQuartz.TriggerJob(nameof(ISonarrSync), "DVR");
}
return(result);
}
private SonarrSettings GetSonarrSettings()
{
var sonarrSettings = new SonarrSettings
{
ApiKey = "abc",
Enabled = true,
Ip = "192.168.1.1",
Port = 8989,
};
return(sonarrSettings);
}
private async Task <SonarrAddSeries> ProcessSonarrEpisodeRequest(SonarrSettings sonarrSettings, RequestedModel model, int qualityId, string rootFolderPath)
{
// Does the series exist?
var series = await GetSonarrSeries(sonarrSettings, model.ProviderId);
if (series == null)
{
var seriesToAdd = new SonarrAddSeries
{
seasonFolder = sonarrSettings.SeasonFolders,
title = model.Title,
qualityProfileId = qualityId,
tvdbId = model.ProviderId,
titleSlug = model.Title,
seasons = new List <Season>(),
rootFolderPath = rootFolderPath,
monitored = true, // Montior the series
images = new List <SonarrImage>(),
addOptions = new AddOptions
{
ignoreEpisodesWithFiles = true, // We don't really care about these
ignoreEpisodesWithoutFiles = true, // We do not want to grab random episodes missing
searchForMissingEpisodes = false // we want don't want to search for the missing episodes either
}
};
for (var i = 1; i <= model.SeasonCount; i++)
{
var season = new Season
{
seasonNumber = i,
monitored = false // Do not monitor any seasons
};
seriesToAdd.seasons.Add(season);
}
// Add the series now
var result = SonarrApi.AddSeries(seriesToAdd, sonarrSettings.ApiKey, sonarrSettings.FullUri);
await RequestEpisodesForSonarr(model, result.id, sonarrSettings);
}
else
{
await RequestEpisodesForSonarr(model, series.id, sonarrSettings);
}
return(new SonarrAddSeries()
{
title = model.Title
});
}
private void ProcessMissingInformation(List <RequestQueue> requests)
{
if (!requests.Any())
{
return;
}
var sonarrSettings = SonarrSettings.GetSettings();
var sickrageSettings = SickrageSettings.GetSettings();
var tv = requests.Where(x => x.Type == RequestType.TvShow);
// TV
var tvApi = new TvMazeApi();
foreach (var t in tv)
{
var providerId = int.Parse(t.PrimaryIdentifier);
var showInfo = tvApi.ShowLookup(providerId);
if (showInfo.externals?.thetvdb != null)
{
// We now have the info
var tvModel = ByteConverterHelper.ReturnObject <RequestedModel>(t.Content);
tvModel.ProviderId = showInfo.externals.thetvdb.Value;
var result = ProcessTvShow(tvModel, sonarrSettings, sickrageSettings);
if (!result)
{
// we now have the info but couldn't add it, so add it back into the queue but with a different fault
t.Content = ByteConverterHelper.ReturnBytes(tvModel);
t.FaultType = FaultType.RequestFault;
t.LastRetry = DateTime.UtcNow;
Repo.Update(t);
}
else
{
// Make sure it's been requested
var existingRequests = RequestService.GetAll();
var thisItem = existingRequests.Any(x => x.Title.Equals(tvModel.Title));
if (!thisItem)
{
tvModel.Approved = true;
RequestService.AddRequest(tvModel);
}
// Successful, remove from the fault queue
Repo.Delete(t);
}
}
}
}
private async Task <string> GetRootPath(int pathId, SonarrSettings sonarrSettings)
{
var rootFoldersResult = await Cache.GetOrSetAsync(CacheKeys.SonarrRootFolders, async() =>
{
return(await Task.Run(() => SonarrApi.GetRootFolders(sonarrSettings.ApiKey, sonarrSettings.FullUri)));
});
foreach (var r in rootFoldersResult.Where(r => r.id == pathId))
{
return(r.path);
}
return(string.Empty);
}
public async Task <bool> Sonarr([FromBody] SonarrSettings settings)
{
try
{
var result = await SonarrApi.SystemStatus(settings.ApiKey, settings.FullUri);
return(result.version != null);
}
catch (Exception e)
{
Log.LogError(LoggingEvents.Api, e, "Could not test Sonarr");
return(false);
}
}
public void Queued(long check)
{
Log.Trace("This is check no. {0}", check);
Log.Trace("Getting the settings");
var settings = SonarrSettings.GetSettings();
if (settings.Enabled)
{
Log.Trace("Getting all tv series from Sonarr");
var series = SonarrApi.GetSeries(settings.ApiKey, settings.FullUri);
Cache.Set(CacheKeys.SonarrQueued, series, 10);
}
}
public async Task <SonarrAddSeries> SendToSonarr(SonarrSettings sonarrSettings, RequestedModel model,
string qualityId)
{
var qualityProfile = 0;
if (!string.IsNullOrEmpty(qualityId)) // try to parse the passed in quality, otherwise use the settings default quality
{
int.TryParse(qualityId, out qualityProfile);
}
if (qualityProfile <= 0)
{
int.TryParse(sonarrSettings.QualityProfile, out qualityProfile);
}
var rootFolderPath = model.RootFolderSelected <= 0 ? sonarrSettings.FullRootPath : await GetSonarrRootPath(model.RootFolderSelected, sonarrSettings);
var episodeRequest = model.Episodes.Any();
var requestAll = model.SeasonsRequested?.Equals("All", StringComparison.CurrentCultureIgnoreCase);
var first = model.SeasonsRequested?.Equals("First", StringComparison.CurrentCultureIgnoreCase);
var latest = model.SeasonsRequested?.Equals("Latest", StringComparison.CurrentCultureIgnoreCase);
var specificSeasonRequest = model.SeasonList?.Any();
if (episodeRequest)
{
return(await ProcessSonarrEpisodeRequest(sonarrSettings, model, qualityProfile, rootFolderPath));
}
if (requestAll ?? false)
{
return(await ProcessSonarrRequestSeason(sonarrSettings, model, qualityProfile, rootFolderPath));
}
if (first ?? false)
{
return(await ProcessSonarrRequestSeason(sonarrSettings, model, qualityProfile, rootFolderPath));
}
if (latest ?? false)
{
return(await ProcessSonarrRequestSeason(sonarrSettings, model, qualityProfile, rootFolderPath));
}
if (specificSeasonRequest ?? false)
{
return(await ProcessSonarrRequestSeason(sonarrSettings, model, qualityProfile, rootFolderPath));
}
return(null);
}
private async Task <string> GetSonarrRootPath(int pathId, SonarrSettings sonarrSettings)
{
var rootFoldersResult = await SonarrApi.GetRootFolders(sonarrSettings.ApiKey, sonarrSettings.FullUri);
if (pathId == 0)
{
return(rootFoldersResult.FirstOrDefault().path);
}
foreach (var r in rootFoldersResult.Where(r => r.id == pathId))
{
return(r.path);
}
return(string.Empty);
}
private void ProcessTransientErrors(List <RequestQueue> requests)
{
var sonarrSettings = SonarrSettings.GetSettings();
var sickrageSettings = SickrageSettings.GetSettings();
var cpSettings = CpSettings.GetSettings();
var hpSettings = HeadphoneSettings.GetSettings();
if (!requests.Any())
{
return;
}
foreach (var request in requests)
{
var model = ByteConverterHelper.ReturnObject <RequestedModel>(request.Content);
bool result;
switch (request.Type)
{
case RequestType.Movie:
result = ProcessMovies(model);
break;
case RequestType.TvShow:
result = ProcessTvShow(model, sonarrSettings, sickrageSettings);
break;
case RequestType.Album:
result = ProcessAlbums(model, hpSettings);
break;
default:
throw new ArgumentOutOfRangeException();
}
if (!result)
{
// we now have the info but couldn't add it, so do nothing now.
request.LastRetry = DateTime.UtcNow;
Repo.Update(request);
}
else
{
// Successful, remove from the fault queue
Repo.Delete(request);
}
}
}
private Response GetSonarrSettings()
{
var model = new ApiModel <SonarrSettings>();
try
{
var settings = SonarrSettings.GetSettings();
model.Data = settings;
return(ReturnReponse(model));
}
catch (Exception e)
{
model.ErrorMessage = e.Message;
model.Error = true;
return(ReturnReponse(model));
}
}
public SonarrAddSeries SendToSonarr(SonarrSettings sonarrSettings, RequestedModel model, string qualityId)
{
int qualityProfile;
if (!string.IsNullOrEmpty(qualityId) || !int.TryParse(qualityId, out qualityProfile)) // try to parse the passed in quality, otherwise use the settings default quality
{
int.TryParse(sonarrSettings.QualityProfile, out qualityProfile);
}
var result = SonarrApi.AddSeries(model.ProviderId, model.Title, qualityProfile,
sonarrSettings.SeasonFolders, sonarrSettings.RootPath, model.SeasonCount, model.SeasonList, sonarrSettings.ApiKey,
sonarrSettings.FullUri);
Log.Trace("Sonarr Add Result: ");
Log.Trace(result.DumpJson());
return(result);
}
public async Task <TesterResultModel> Sonarr([FromBody] SonarrSettings settings)
{
try
{
var result = await SonarrApi.SystemStatus(settings.ApiKey, settings.FullUri);
return(new TesterResultModel
{
IsValid = result.urlBase == settings.SubDir || string.IsNullOrEmpty(result.urlBase) && string.IsNullOrEmpty(settings.SubDir),
ExpectedSubDir = result.urlBase
});
}
catch (Exception e)
{
Log.LogError(LoggingEvents.Api, e, "Could not test Sonarr");
return(new TesterResultModel {
IsValid = false
});
}
}
public void SaveBadSonarrSettings()
{
var model = new SonarrSettings
{
Ip = "q",
Ssl = true,
};
var browser = new Browser(Bootstrapper);
var result = browser.Post("/api/settings/sonarr", with =>
{
with.HttpRequest();
with.Header("Accept", "application/json");
with.Query("apikey", "api");
with.JsonBody(model);
});
var body = JsonConvert.DeserializeObject <ApiModel <bool> >(result.Body.AsString());
Assert.That(body.Data, Is.EqualTo(false));
Assert.That(body.Error, Is.True);
Assert.That(body.ErrorMessage, Is.EqualTo("Could not update the settings"));
}
private bool ProcessTvShow(RequestedModel tvModel, SonarrSettings sonarr, SickRageSettings sickrage)
{
try
{
var sender = new TvSenderOld(SonarrApi, SrApi);
if (sonarr.Enabled)
{
var task = sender.SendToSonarr(sonarr, tvModel, sonarr.QualityProfile);
var a = task.Result;
if (string.IsNullOrEmpty(a?.title))
{
// Couldn't send it
return(false);
}
return(true);
}
if (sickrage.Enabled)
{
var result = sender.SendToSickRage(sickrage, tvModel);
if (result?.result != "success")
{
// Couldn't send it
return(false);
}
// Approve it
tvModel.Approved = true;
RequestService.UpdateRequest(tvModel);
return(true);
}
return(false);
}
catch (Exception e)
{
Log.Error(e);
return(false); // It fails so it will get added back into the queue
}
}
private Response PostSonarrSettings()
{
var newSettings = JsonConvert.DeserializeObject <SonarrSettings>(Request.Body.AsString());
var result = this.Validate(newSettings);
if (!result.IsValid)
{
return(ReturnValidationReponse(result));
}
var model = new ApiModel <bool>();
var settings = SonarrSettings.SaveSettings(newSettings);
if (settings)
{
model.Data = true;
return(ReturnReponse(model));
}
model.Error = true;
model.ErrorMessage = "Could not update the settings";
return(ReturnReponse(model));
}
public bool SaveSettings(SonarrSettingsViewModelDto model)
{
var entity = Repo.Get(model.Id);
if (entity == null)
{
var newEntity = new SonarrSettings();
newEntity.InjectFrom(model);
var insertResult = Repo.Insert(newEntity);
return(insertResult != long.MinValue);
}
entity.Enabled = model.Enabled;
entity.IpAddress = model.IpAddress;
entity.Port = model.Port;
entity.ApiKey = model.ApiKey;
entity.Id = model.Id;
entity.ShowOnDashboard = model.ShowOnDashboard;
var result = Repo.Update(entity);
return(result);
}
public SonarrAddSeries AddSeries(SonarrSettings sonarrSettings, RequestedModel model, string rootFolderPath, int qualityId)
{
//WORKS
// Add the series
var seriesToAdd = new SonarrAddSeries
{
seasonFolder = sonarrSettings.SeasonFolders,
title = model.Title,
qualityProfileId = qualityId,
tvdbId = model.ProviderId,
titleSlug = model.Title,
seasons = new List <Season>(),
rootFolderPath = rootFolderPath,
monitored = true, // Montior the series
images = new List <SonarrImage>(),
addOptions = new AddOptions
{
ignoreEpisodesWithFiles = true, // We don't really care about these
ignoreEpisodesWithoutFiles = false, // We want to get the whole season
searchForMissingEpisodes = true // we want to search for missing
}
};
for (var i = 1; i <= model.SeasonCount; i++)
{
var season = new Season
{
seasonNumber = i,
// The model.SeasonList.Lenth is 0 when this is a "request all"
monitored = model.SeasonList.Length == 0 || model.SeasonList.Any(x => x == i)
};
seriesToAdd.seasons.Add(season);
}
return(SonarrApi.AddSeries(seriesToAdd, sonarrSettings.ApiKey, sonarrSettings.FullUri));
}
private Response GetTvShows() // TODO: async await the API calls
{
var settings = PrSettings.GetSettings();
List <Task> taskList = new List <Task>();
List <RequestedModel> dbTv = new List <RequestedModel>();
taskList.Add(Task.Factory.StartNew(() =>
{
return(Service.GetAll().Where(x => x.Type == RequestType.TvShow));
}).ContinueWith((t) =>
{
dbTv = t.Result.ToList();
if (settings.UsersCanViewOnlyOwnRequests && !IsAdmin)
{
dbTv = dbTv.Where(x => x.UserHasRequested(Username)).ToList();
}
}));
List <QualityModel> qualities = new List <QualityModel>();
if (IsAdmin)
{
var sonarrSettings = SonarrSettings.GetSettings();
if (sonarrSettings.Enabled)
{
taskList.Add(Task.Factory.StartNew(() =>
{
return(Cache.GetOrSet(CacheKeys.SonarrQualityProfiles, () =>
{
return SonarrApi.GetProfiles(sonarrSettings.ApiKey, sonarrSettings.FullUri); // TODO: cache this!
}));
}).ContinueWith((t) =>
{
qualities = t.Result.Select(x => new QualityModel()
{
Id = x.id.ToString(), Name = x.name
}).ToList();
}));
}
else
{
var sickRageSettings = SickRageSettings.GetSettings();
if (sickRageSettings.Enabled)
{
qualities = sickRageSettings.Qualities.Select(x => new QualityModel()
{
Id = x.Key, Name = x.Value
}).ToList();
}
}
}
Task.WaitAll(taskList.ToArray());
var viewModel = dbTv.Select(tv =>
{
return(new RequestViewModel
{
ProviderId = tv.ProviderId,
Type = tv.Type,
Status = tv.Status,
ImdbId = tv.ImdbId,
Id = tv.Id,
PosterPath = tv.PosterPath,
ReleaseDate = tv.ReleaseDate,
ReleaseDateTicks = tv.ReleaseDate.Ticks,
RequestedDate = tv.RequestedDate,
RequestedDateTicks = DateTimeHelper.OffsetUTCDateTime(tv.RequestedDate, DateTimeOffset).Ticks,
Released = DateTime.Now > tv.ReleaseDate,
Approved = tv.Available || tv.Approved,
Title = tv.Title,
Overview = tv.Overview,
RequestedUsers = IsAdmin ? tv.AllUsers.ToArray() : new string[] { },
ReleaseYear = tv.ReleaseDate.Year.ToString(),
Available = tv.Available,
Admin = IsAdmin,
Issues = tv.Issues.ToString().CamelCaseToWords(),
OtherMessage = tv.OtherMessage,
AdminNotes = tv.AdminNote,
TvSeriesRequestType = tv.SeasonsRequested,
Qualities = qualities.ToArray()
});
}).ToList();
return(Response.AsJson(viewModel));
}
public async Task <SonarrAddSeries> SendToSonarr(SonarrSettings sonarrSettings, RequestedModel model, string qualityId)
{
var qualityProfile = 0;
var episodeRequest = model.Episodes.Any();
if (!string.IsNullOrEmpty(qualityId)) // try to parse the passed in quality, otherwise use the settings default quality
{
int.TryParse(qualityId, out qualityProfile);
}
if (qualityProfile <= 0)
{
int.TryParse(sonarrSettings.QualityProfile, out qualityProfile);
}
var series = await GetSonarrSeries(sonarrSettings, model.ProviderId);
if (episodeRequest)
{
// Does series exist?
if (series != null)
{
// Series Exists
// Request the episodes in the existing series
await RequestEpisodesWithExistingSeries(model, series, sonarrSettings);
return(new SonarrAddSeries {
title = series.title
});
}
// Series doesn't exist, need to add it as unmonitored.
var addResult = await Task.Run(() => SonarrApi.AddSeries(model.ProviderId, model.Title, qualityProfile,
sonarrSettings.SeasonFolders, sonarrSettings.RootPath, 0, new int[0], sonarrSettings.ApiKey,
sonarrSettings.FullUri, false));
// Get the series that was just added
series = await GetSonarrSeries(sonarrSettings, model.ProviderId);
series.monitored = true; // We want to make sure we are monitoring the series
// Un-monitor all seasons
foreach (var season in series.seasons)
{
season.monitored = false;
}
// Update the series, Since we cannot add as un-monitored due to the following bug: https://github.com/Sonarr/Sonarr/issues/1404
SonarrApi.UpdateSeries(series, sonarrSettings.ApiKey, sonarrSettings.FullUri);
// We now have the series in Sonarr, update it to request the episodes.
await RequestAllEpisodesInASeasonWithExistingSeries(model, series, sonarrSettings);
return(addResult);
}
if (series != null)
{
var requestAll = model.SeasonsRequested.Equals("All", StringComparison.CurrentCultureIgnoreCase);
var first = model.SeasonsRequested.Equals("First", StringComparison.CurrentCultureIgnoreCase);
var latest = model.SeasonsRequested.Equals("Latest", StringComparison.CurrentCultureIgnoreCase);
if (model.SeasonList.Any())
{
// Monitor the seasons that we have chosen
foreach (var season in series.seasons)
{
if (model.SeasonList.Contains(season.seasonNumber))
{
season.monitored = true;
}
}
}
if (requestAll)
{
// Monitor all seasons
foreach (var season in series.seasons)
{
season.monitored = true;
}
}
if (first)
{
var firstSeries = series?.seasons?.OrderBy(x => x.seasonNumber)?.FirstOrDefault() ?? new Season();
firstSeries.monitored = true;
}
if (latest)
{
var lastSeries = series?.seasons?.OrderByDescending(x => x.seasonNumber)?.FirstOrDefault() ?? new Season();
lastSeries.monitored = true;
}
// Update the series in sonarr with the new monitored status
SonarrApi.UpdateSeries(series, sonarrSettings.ApiKey, sonarrSettings.FullUri);
await RequestAllEpisodesInASeasonWithExistingSeries(model, series, sonarrSettings);
return(new SonarrAddSeries {
title = series.title
}); // We have updated it
}
var result = SonarrApi.AddSeries(model.ProviderId, model.Title, qualityProfile,
sonarrSettings.SeasonFolders, sonarrSettings.RootPath, model.SeasonCount, model.SeasonList, sonarrSettings.ApiKey,
sonarrSettings.FullUri, true, true);
return(result);
}
public async Task <SonarrAddSeries> SendToSonarr(SonarrSettings sonarrSettings, RequestedModel model)
{
return(await SendToSonarr(sonarrSettings, model, string.Empty));
}
internal async Task RequestAllEpisodesInASeasonWithExistingSeries(RequestedModel model, Series selectedSeries, SonarrSettings sonarrSettings)
{
// Show Exists
// Look up all episodes
var ep = SonarrApi.GetEpisodes(selectedSeries.id.ToString(), sonarrSettings.ApiKey, sonarrSettings.FullUri);
var episodes = ep?.ToList() ?? new List <SonarrEpisodes>();
var internalEpisodeIds = new List <int>();
var tasks = new List <Task>();
var requestedEpisodes = model.Episodes;
foreach (var r in episodes)
{
if (r.hasFile) // If it already has the file, there is no point in updating it
{
continue;
}
var epComparison = new EpisodesModel
{
EpisodeNumber = r.episodeNumber,
SeasonNumber = r.seasonNumber
};
// Make sure we are looking for the right episode and season
if (!requestedEpisodes.Contains(epComparison))
{
continue;
}
// Lookup the individual episode details
var episodeInfo = SonarrApi.GetEpisode(r.id.ToString(), sonarrSettings.ApiKey, sonarrSettings.FullUri);
// If the season is not in thr
episodeInfo.monitored = true; // Set the episode to monitored
tasks.Add(Task.Run(() => SonarrApi.UpdateEpisode(episodeInfo, sonarrSettings.ApiKey,
sonarrSettings.FullUri)));
internalEpisodeIds.Add(r.id);
}
await Task.WhenAll(tasks.ToArray());
SonarrApi.SearchForEpisodes(internalEpisodeIds.ToArray(), sonarrSettings.ApiKey, sonarrSettings.FullUri);
}
