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 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);
}
public async Task <bool> SickRage([FromBody] SickRageSettings settings)
{
try
{
settings.Enabled = true;
var result = await SickRageApi.Ping(settings.ApiKey, settings.FullUri);
return(result?.data?.pid != null);
}
catch (Exception e)
{
Log.LogError(LoggingEvents.Api, e, "Could not test SickRage");
return(false);
}
}
public SickRageTvAdd SendToSickRage(SickRageSettings sickRageSettings, RequestedModel model, string qualityId)
{
Log.Info("Sending to SickRage {0}", model.Title);
if (sickRageSettings.Qualities.All(x => x.Key != qualityId))
{
qualityId = sickRageSettings.QualityProfile;
}
var apiResult = SickrageApi.AddSeries(model.ProviderId, model.SeasonCount, model.SeasonList, qualityId,
sickRageSettings.ApiKey, sickRageSettings.FullUri);
var result = apiResult.Result;
return(result);
}
private Response GetSickRageSettings()
{
var model = new ApiModel <SickRageSettings>();
try
{
var settings = SickRageSettings.GetSettings();
model.Data = settings;
return(ReturnReponse(model));
}
catch (Exception e)
{
model.ErrorMessage = e.Message;
model.Error = true;
return(ReturnReponse(model));
}
}
public void SaveBadSickRageSettings()
{
var model = new SickRageSettings
{
Ip = "q",
Ssl = true,
};
var browser = new Browser(Bootstrapper);
var result = browser.Post("/api/settings/sickrage", 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
}
}
public SickRageTvAdd SendToSickRage(SickRageSettings sickRageSettings, RequestedModel model, string qualityId)
{
Log.Info("Sending to SickRage {0}", model.Title);
if (!sickRageSettings.Qualities.Any(x => x.Key == qualityId))
{
qualityId = sickRageSettings.QualityProfile;
}
Log.Trace("Calling `AddSeries` with the following settings:");
Log.Trace(sickRageSettings.DumpJson());
Log.Trace("And the following `model`:");
Log.Trace(model.DumpJson());
var apiResult = SickrageApi.AddSeries(model.ProviderId, model.SeasonCount, model.SeasonList, qualityId,
sickRageSettings.ApiKey, sickRageSettings.FullUri);
var result = apiResult.Result;
Log.Trace("SickRage Add Result: ");
Log.Trace(result.DumpJson());
return(result);
}
private Response PostSickRageSettings()
{
var newSettings = JsonConvert.DeserializeObject <SickRageSettings>(Request.Body.AsString());
var result = this.Validate(newSettings);
if (!result.IsValid)
{
return(ReturnValidationReponse(result));
}
var model = new ApiModel <bool>();
var settings = SickRageSettings.SaveSettings(newSettings);
if (settings)
{
model.Data = true;
return(ReturnReponse(model));
}
model.Error = true;
model.ErrorMessage = "Could not update the settings";
return(ReturnReponse(model));
}
public SickRageTvAdd SendToSickRage(SickRageSettings sickRageSettings, RequestedModel model)
{
return(SendToSickRage(sickRageSettings, model, sickRageSettings.QualityProfile));
}
public async Task <bool> SickRageSettings([FromBody] SickRageSettings settings)
{
return(await Save(settings));
}
public async Task <SenderResult> Send(ChildRequests model)
{
try
{
var sonarr = await SonarrSettings.GetSettingsAsync();
if (sonarr.Enabled)
{
var result = await SendToSonarr(model, sonarr);
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
});
}
catch (Exception e)
{
Logger.LogError(e, "Exception thrown when sending a movie to DVR app, added to the request queue");
// Check if already in request queue
var existingQueue = await _requestQueueRepository.FirstOrDefaultAsync(x => x.RequestId == model.Id);
if (existingQueue != null)
{
existingQueue.RetryCount++;
existingQueue.Error = e.Message;
await _requestQueueRepository.SaveChangesAsync();
}
else
{
await _requestQueueRepository.Add(new RequestQueue
{
Dts = DateTime.UtcNow,
Error = e.Message,
RequestId = model.Id,
Type = RequestType.TvShow,
RetryCount = 0
});
_notificationHelper.Notify(model, NotificationType.ItemAddedToFaultQueue);
}
}
return(new SenderResult
{
Success = false,
Message = "Something went wrong!"
});
}
private async Task <bool> SendToSickRage(ChildRequests model, SickRageSettings settings, string qualityId = null)
{
var tvdbid = model.ParentRequest.TvDbId;
if (qualityId.HasValue())
{
var id = qualityId;
if (settings.Qualities.All(x => x.Value != id))
{
qualityId = settings.QualityProfile;
}
}
else
{
qualityId = settings.QualityProfile;
}
// Check if the show exists
var existingShow = await SickRageApi.GetShow(tvdbid, settings.ApiKey, settings.FullUri);
if (existingShow.message.Equals("Show not found", StringComparison.CurrentCultureIgnoreCase))
{
var addResult = await SickRageApi.AddSeries(model.ParentRequest.TvDbId, qualityId, SickRageStatus.Ignored,
settings.ApiKey, settings.FullUri);
Logger.LogDebug("Added the show (tvdbid) {0}. The result is '{2}' : '{3}'", tvdbid, addResult.result, addResult.message);
if (addResult.result.Equals("failure") || addResult.result.Equals("fatal"))
{
// Do something
return(false);
}
}
foreach (var seasonRequests in model.SeasonRequests)
{
var srEpisodes = await SickRageApi.GetEpisodesForSeason(tvdbid, seasonRequests.SeasonNumber, settings.ApiKey, settings.FullUri);
int retryTimes = 10;
var currentRetry = 0;
while (srEpisodes.message.Equals("Show not found", StringComparison.CurrentCultureIgnoreCase) || srEpisodes.message.Equals("Season not found", StringComparison.CurrentCultureIgnoreCase) && srEpisodes.data.Count <= 0)
{
if (currentRetry > retryTimes)
{
Logger.LogWarning("Couldnt find the SR Season or Show, message: {0}", srEpisodes.message);
break;
}
await Task.Delay(TimeSpan.FromSeconds(1));
currentRetry++;
srEpisodes = await SickRageApi.GetEpisodesForSeason(tvdbid, seasonRequests.SeasonNumber, settings.ApiKey, settings.FullUri);
}
var totalSrEpisodes = srEpisodes.data.Count;
if (totalSrEpisodes == seasonRequests.Episodes.Count)
{
// This is a request for the whole season
var wholeSeasonResult = await SickRageApi.SetEpisodeStatus(settings.ApiKey, settings.FullUri, tvdbid, SickRageStatus.Wanted,
seasonRequests.SeasonNumber);
Logger.LogDebug("Set the status to Wanted for season {0}. The result is '{1}' : '{2}'", seasonRequests.SeasonNumber, wholeSeasonResult.result, wholeSeasonResult.message);
continue;
}
foreach (var srEp in srEpisodes.data)
{
var epNumber = srEp.Key;
var epData = srEp.Value;
var epRequest = seasonRequests.Episodes.FirstOrDefault(x => x.EpisodeNumber == epNumber);
if (epRequest != null)
{
// We want to monior this episode since we have a request for it
// Let's check to see if it's wanted first, save an api call
if (epData.status.Equals(SickRageStatus.Wanted, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
var epResult = await SickRageApi.SetEpisodeStatus(settings.ApiKey, settings.FullUri, tvdbid,
SickRageStatus.Wanted, seasonRequests.SeasonNumber, epNumber);
Logger.LogDebug("Set the status to Wanted for Episode {0} in season {1}. The result is '{2}' : '{3}'", seasonRequests.SeasonNumber, epNumber, epResult.result, epResult.message);
}
}
}
return(true);
}
private Response UpdateRequests(RequestedModel[] requestedModels)
{
var cpSettings = CpService.GetSettings();
var updatedRequests = new List <RequestedModel>();
foreach (var r in requestedModels)
{
if (r.Type == RequestType.Movie)
{
if (cpSettings.Enabled)
{
var res = SendMovie(cpSettings, r, CpApi);
if (res)
{
r.Approved = true;
updatedRequests.Add(r);
}
else
{
Log.Error("Could not approve and send the movie {0} to couch potato!", r.Title);
}
}
else
{
r.Approved = true;
updatedRequests.Add(r);
}
}
if (r.Type == RequestType.TvShow)
{
var sender = new TvSender(SonarrApi, SickRageApi);
var sr = SickRageSettings.GetSettings();
var sonarr = SonarrSettings.GetSettings();
if (sr.Enabled)
{
var res = sender.SendToSickRage(sr, r);
if (res?.result == "success")
{
r.Approved = true;
updatedRequests.Add(r);
}
else
{
Log.Error("Could not approve and send the TV {0} to SickRage!", r.Title);
Log.Error("SickRage Message: {0}", res?.message);
}
}
else if (sonarr.Enabled)
{
var res = sender.SendToSonarr(sonarr, r);
if (!string.IsNullOrEmpty(res?.title))
{
r.Approved = true;
updatedRequests.Add(r);
}
else
{
Log.Error("Could not approve and send the TV {0} to Sonarr!", r.Title);
res?.ErrorMessages.ForEach(x => Log.Error("Error messages: {0}", x));
}
}
else
{
r.Approved = true;
updatedRequests.Add(r);
}
}
}
try
{
var result = Service.BatchUpdate(updatedRequests);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true
}
: new JsonResponseModel {
Result = false, Message = "We could not approve all of the requests. Please try again or check the logs."
}));
}
catch (Exception e)
{
Log.Fatal(e);
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Something bad happened, please check the logs!"
}));
}
}
private async Task <Response> GetTvShows()
{
var settingsTask = PrSettings.GetSettingsAsync();
var requests = await Service.GetAllAsync();
requests = requests.Where(x => x.Type == RequestType.TvShow);
var dbTv = requests;
var settings = await settingsTask;
if (settings.UsersCanViewOnlyOwnRequests && !IsAdmin)
{
dbTv = dbTv.Where(x => x.UserHasRequested(Username)).ToList();
}
IEnumerable <QualityModel> qualities = new List <QualityModel>();
if (IsAdmin)
{
try
{
var sonarrSettings = await SonarrSettings.GetSettingsAsync();
if (sonarrSettings.Enabled)
{
var result = Cache.GetOrSetAsync(CacheKeys.SonarrQualityProfiles, async() =>
{
return(await Task.Run(() => SonarrApi.GetProfiles(sonarrSettings.ApiKey, sonarrSettings.FullUri)));
});
qualities = result.Result.Select(x => new QualityModel {
Id = x.id.ToString(), Name = x.name
}).ToList();
}
else
{
var sickRageSettings = await SickRageSettings.GetSettingsAsync();
if (sickRageSettings.Enabled)
{
qualities = sickRageSettings.Qualities.Select(x => new QualityModel {
Id = x.Key, Name = x.Value
}).ToList();
}
}
}
catch (Exception e)
{
Log.Info(e);
}
}
var viewModel = dbTv.Select(tv => 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,
IssueId = tv.IssueId,
TvSeriesRequestType = tv.SeasonsRequested,
Qualities = qualities.ToArray(),
Episodes = tv.Episodes.ToArray(),
}).ToList();
return(Response.AsJson(viewModel));
}
private async Task <Response> GetTvShows()
{
var requests = await Service.GetAllAsync();
requests = requests.Where(x => x.Type == RequestType.TvShow);
var dbTv = requests;
if (Security.HasPermissions(User, Permissions.UsersCanViewOnlyOwnRequests) && !IsAdmin)
{
dbTv = dbTv.Where(x => x.UserHasRequested(Username)).ToList();
}
IEnumerable <QualityModel> qualities = new List <QualityModel>();
IEnumerable <RootFolderModel> rootFolders = new List <RootFolderModel>();
var sonarrSettings = await SonarrSettings.GetSettingsAsync();
if (IsAdmin)
{
try
{
if (sonarrSettings.Enabled)
{
var result = await Cache.GetOrSetAsync(CacheKeys.SonarrQualityProfiles, async() =>
{
return(await Task.Run(() => SonarrApi.GetProfiles(sonarrSettings.ApiKey, sonarrSettings.FullUri)));
});
qualities = result.Select(x => new QualityModel {
Id = x.id.ToString(), Name = x.name
}).ToList();
var rootFoldersResult = await Cache.GetOrSetAsync(CacheKeys.SonarrRootFolders, async() =>
{
return(await Task.Run(() => SonarrApi.GetRootFolders(sonarrSettings.ApiKey, sonarrSettings.FullUri)));
});
rootFolders = rootFoldersResult.Select(x => new RootFolderModel {
Id = x.id.ToString(), Path = x.path, FreeSpace = x.freespace
}).ToList();
}
else
{
var sickRageSettings = await SickRageSettings.GetSettingsAsync();
if (sickRageSettings.Enabled)
{
qualities = sickRageSettings.Qualities.Select(x => new QualityModel {
Id = x.Key, Name = x.Value
}).ToList();
}
}
}
catch (Exception e)
{
Log.Info(e);
}
}
var canManageRequest = Security.HasAnyPermissions(User, Permissions.Administrator, Permissions.ManageRequests);
var allowViewUsers = Security.HasAnyPermissions(User, Permissions.Administrator, Permissions.ViewUsers);
var viewModel = dbTv.Select(tv => new RequestViewModel
{
ProviderId = tv.ProviderId,
Type = tv.Type,
Status = tv.Status,
ImdbId = tv.ImdbId,
Id = tv.Id,
PosterPath = tv.PosterPath?.Contains("http:") ?? false ? tv.PosterPath?.Replace("http:", "https:") : tv.PosterPath ?? string.Empty, // We make the poster path https on request, but this is just incase
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 = canManageRequest || allowViewUsers ? tv.AllUsers.ToArray() : new string[] { },
ReleaseYear = tv.ReleaseDate.Year.ToString(),
Available = tv.Available,
Admin = canManageRequest,
IssueId = tv.IssueId,
Denied = tv.Denied,
DeniedReason = tv.DeniedReason,
TvSeriesRequestType = tv.SeasonsRequested,
Qualities = qualities.ToArray(),
Episodes = tv.Episodes.ToArray(),
RootFolders = rootFolders.ToArray(),
HasRootFolders = rootFolders.Any(),
CurrentRootPath = sonarrSettings.Enabled ? GetRootPath(tv.RootFolderSelected, sonarrSettings).Result : null
}).ToList();
return(Response.AsJson(viewModel));
}
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));
}
private Response RequestTvAndUpdateStatus(RequestedModel request, string qualityId)
{
var sender = new TvSender(SonarrApi, SickRageApi);
var sonarrSettings = SonarrSettings.GetSettings();
if (sonarrSettings.Enabled)
{
Log.Trace("Sending to Sonarr");
var result = sender.SendToSonarr(sonarrSettings, request, qualityId);
Log.Trace("Sonarr Result: ");
Log.Trace(result.DumpJson());
if (!string.IsNullOrEmpty(result.title))
{
Log.Info("Sent successfully, Approving request now.");
request.Approved = true;
var requestResult = Service.UpdateRequest(request);
Log.Trace("Approval result: {0}", requestResult);
if (requestResult)
{
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
return
(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = "Updated Sonarr but could not approve it in PlexRequests :("
}));
}
return(Response.AsJson(ValidationHelper.SendSonarrError(result.ErrorMessages)));
}
var srSettings = SickRageSettings.GetSettings();
if (srSettings.Enabled)
{
Log.Trace("Sending to SickRage");
var result = sender.SendToSickRage(srSettings, request, qualityId);
Log.Trace("SickRage Result: ");
Log.Trace(result.DumpJson());
if (result?.result == "success")
{
Log.Info("Sent successfully, Approving request now.");
request.Approved = true;
var requestResult = Service.UpdateRequest(request);
Log.Trace("Approval result: {0}", requestResult);
return(Response.AsJson(requestResult
? new JsonResponseModel {
Result = true
}
: new JsonResponseModel {
Result = false, Message = "Updated SickRage but could not approve it in PlexRequests :("
}));
}
return(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = result?.message != null ? "<b>Message From SickRage: </b>" + result.message : "Could not add the series to SickRage"
}));
}
request.Approved = true;
var res = Service.UpdateRequest(request);
return(Response.AsJson(res
? new JsonResponseModel {
Result = true, Message = "This has been approved, but It has not been sent to Sonarr/SickRage because it has not been configured"
}
: new JsonResponseModel {
Result = false, Message = "Updated SickRage but could not approve it in PlexRequests :("
}));
}
