private async Task <string> GetRootPath(int pathId, RadarrSettings radarrSettings)
{
var rootFoldersResult = await Cache.GetOrSetAsync(CacheKeys.RadarrRootFolders, async() =>
{
return(await Task.Run(() => RadarrApi.GetRootFolders(radarrSettings.ApiKey, radarrSettings.FullUri)));
});
foreach (var r in rootFoldersResult.Where(r => r.id == pathId))
{
return(r.path);
}
int outRoot;
var defaultPath = int.TryParse(radarrSettings.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 MovieSenderResult SendToRadarr(RequestedModel model, RadarrSettings settings, 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(settings.QualityProfile, out qualityProfile);
}
var rootFolderPath = model.RootFolderSelected <= 0 ? settings.FullRootPath : GetRootPath(model.RootFolderSelected, settings);
var result = RadarrApi.AddMovie(model.ProviderId, model.Title, model.ReleaseDate.Year, qualityProfile, rootFolderPath, settings.ApiKey, settings.FullUri, true);
if (!string.IsNullOrEmpty(result.Error?.message))
{
Log.Error(result.Error.message);
return(new MovieSenderResult {
Result = false, Error = true, MovieSendingEnabled = true
});
}
if (!string.IsNullOrEmpty(result.title))
{
return(new MovieSenderResult {
Result = true, MovieSendingEnabled = true
});
}
return(new MovieSenderResult {
Result = false, MovieSendingEnabled = true
});
}
public void Queued()
{
var settings = RadarrSettings.GetSettings();
if (settings.Enabled)
{
Job.SetRunning(true, JobNames.RadarrCacher);
try
{
var movies = RadarrApi.GetMovies(settings.ApiKey, settings.FullUri);
if (movies != null)
{
var movieIds = new List <int>();
foreach (var m in movies)
{
if (m.tmdbId > 0)
{
movieIds.Add(m.tmdbId);
}
}
//var movieIds = movies.Select(x => x.tmdbId).ToList();
Cache.Set(CacheKeys.RadarrMovies, movieIds, CacheKeys.TimeFrameMinutes.SchedulerCaching);
}
}
catch (System.Exception ex)
{
Log.Error(ex, "Failed caching queued items from Radarr");
}
finally
{
Job.Record(JobNames.RadarrCacher);
Job.SetRunning(false, JobNames.RadarrCacher);
}
}
}
public async Task <MovieSenderResult> Send(RequestedModel model, string qualityId = "")
{
var cpSettings = await CouchPotatoSettings.GetSettingsAsync();
var watcherSettings = await WatcherSettings.GetSettingsAsync();
var radarrSettings = await RadarrSettings.GetSettingsAsync();
if (cpSettings.Enabled)
{
return(SendToCp(model, cpSettings, string.IsNullOrEmpty(qualityId) ? cpSettings.ProfileId : qualityId));
}
if (watcherSettings.Enabled)
{
return(SendToWatcher(model, watcherSettings));
}
if (radarrSettings.Enabled)
{
return(SendToRadarr(model, radarrSettings));
}
return(new MovieSenderResult {
Result = false, MovieSendingEnabled = false
});
}
private async Task <SenderResult> SendToRadarr(MovieRequests model, RadarrSettings settings)
{
var qualityToUse = int.Parse(settings.DefaultQualityProfile);
if (model.QualityOverride > 0)
{
qualityToUse = model.QualityOverride;
}
var rootFolderPath = model.RootPathOverride <= 0 ? settings.DefaultRootPath : await RadarrRootPath(model.RootPathOverride, settings);
var result = await RadarrApi.AddMovie(model.TheMovieDbId, model.Title, model.ReleaseDate.Year, qualityToUse, rootFolderPath, settings.ApiKey, settings.FullUri, !settings.AddOnly, settings.MinimumAvailability);
if (!string.IsNullOrEmpty(result.Error?.message))
{
Log.LogError(LoggingEvents.RadarrCacher, result.Error.message);
return(new SenderResult {
Success = false, Message = result.Error.message, Sent = false
});
}
if (!string.IsNullOrEmpty(result.title))
{
return(new SenderResult {
Success = true, Sent = false
});
}
return(new SenderResult {
Success = true, Sent = false
});
}
private async Task Process(RadarrSettings settings)
{
if (settings.Enabled)
{
try
{
var movies = await _api.GetMovies(settings.ApiKey, settings.FullUri);
var existingMovies = _radarrRepo.GetAll();
if (movies != null)
{
var movieIds = new List <RadarrCache>();
foreach (var m in movies)
{
if (m.monitored || m.hasFile)
{
if (m.tmdbId > 0)
{
var is4k = m.movieFile?.quality?.quality?.resolution >= 2160;
// Do we have a cached movie for this already?
var existing = await existingMovies.FirstOrDefaultAsync(x => x.TheMovieDbId == m.tmdbId);
if (existing != null)
{
existing.Has4K = is4k;
existing.HasFile = m.hasFile;
}
else
{
movieIds.Add(new RadarrCache
{
TheMovieDbId = m.tmdbId,
HasFile = m.hasFile,
Has4K = is4k,
HasRegular = !is4k
});
}
}
else
{
_logger.LogError($"TMDBId is not > 0 for movie {m.title}");
}
}
}
// Save from the updates made to the existing movies (they are in the EF Change Tracker)
await _radarrRepo.SaveChangesAsync();
await _radarrRepo.AddRange(movieIds);
}
await OmbiQuartz.TriggerJob(nameof(IArrAvailabilityChecker), "DVR");
}
catch (System.Exception ex)
{
_logger.LogError(LoggingEvents.Cacher, ex, "Failed caching queued items from Radarr");
}
}
}
public async Task <IEnumerable <RadarrRootFolder> > GetRootFolders([FromBody] RadarrSettings settings)
{
if (settings.V3)
{
return(await _radarrV3Api.GetRootFolders(settings.ApiKey, settings.FullUri));
}
return(await _radarrApi.GetRootFolders(settings.ApiKey, settings.FullUri));
}
private async Task <string> RadarrRootPath(int overrideId, RadarrSettings settings)
{
var paths = await RadarrApi.GetRootFolders(settings.ApiKey, settings.FullUri);
var selectedPath = paths.FirstOrDefault(x => x.id == overrideId);
return(selectedPath?.path ?? String.Empty);
}
public async Task <IActionResult> GetProfiles([FromBody] RadarrSettings settings)
{
if (settings.V3)
{
return(Ok(await _radarrV3Api.GetProfiles(settings.ApiKey, settings.FullUri)));
}
return(Ok(await _radarrApi.GetProfiles(settings.ApiKey, settings.FullUri)));
}
private async Task <SenderResult> SendToRadarr(MovieRequests model, RadarrSettings settings)
{
var qualityToUse = int.Parse(settings.DefaultQualityProfile);
if (model.QualityOverride > 0)
{
qualityToUse = model.QualityOverride;
}
var rootFolderPath = model.RootPathOverride <= 0 ? settings.DefaultRootPath : await RadarrRootPath(model.RootPathOverride, settings);
// Check if the movie already exists? Since it could be unmonitored
var movies = await RadarrApi.GetMovies(settings.ApiKey, settings.FullUri);
var existingMovie = movies.FirstOrDefault(x => x.tmdbId == model.TheMovieDbId);
if (existingMovie == null)
{
var result = await RadarrApi.AddMovie(model.TheMovieDbId, model.Title, model.ReleaseDate.Year,
qualityToUse, rootFolderPath, settings.ApiKey, settings.FullUri, !settings.AddOnly,
settings.MinimumAvailability);
if (!string.IsNullOrEmpty(result.Error?.message))
{
Log.LogError(LoggingEvents.RadarrCacher, result.Error.message);
return(new SenderResult {
Success = false, Message = result.Error.message, Sent = false
});
}
if (!string.IsNullOrEmpty(result.title))
{
return(new SenderResult {
Success = true, Sent = false
});
}
return(new SenderResult {
Success = true, Sent = false
});
}
// We have the movie, check if we can request it or change the status
if (!existingMovie.monitored)
{
// let's set it to monitored and search for it
existingMovie.monitored = true;
await RadarrApi.UpdateMovie(existingMovie, settings.ApiKey, settings.FullUri);
// Search for it
await RadarrApi.MovieSearch(new[] { existingMovie.id }, settings.ApiKey, settings.FullUri);
return(new SenderResult {
Success = true, Sent = true
});
}
return(new SenderResult {
Success = false, Sent = false, Message = "Movie is already monitored"
});
}
public async Task <IEnumerable <RadarrRootFolder> > GetRootFolders()
{
var settings = await RadarrSettings.GetSettingsAsync();
if (settings.Enabled)
{
return(await RadarrApi.GetRootFolders(settings.ApiKey, settings.FullUri));
}
return(null);
}
private string GetRootPath(int pathId, RadarrSettings sonarrSettings)
{
var rootFoldersResult = Cache.GetOrSet(CacheKeys.RadarrRootFolders, () => RadarrApi.GetRootFolders(sonarrSettings.ApiKey, sonarrSettings.FullUri));
foreach (var r in rootFoldersResult.Where(r => r.id == pathId))
{
return(r.path);
}
return(string.Empty);
}
public async Task CacheContent()
{
await SemaphoreSlim.WaitAsync();
try
{
var settings = await RadarrSettings.GetSettingsAsync();
if (settings.Enabled)
{
try
{
var movies = await RadarrApi.GetMovies(settings.ApiKey, settings.FullUri);
if (movies != null)
{
// Let's remove the old cached data
await _ctx.Database.ExecuteSqlCommandAsync("DELETE FROM RadarrCache");
var movieIds = new List <RadarrCache>();
foreach (var m in movies)
{
if (m.tmdbId > 0)
{
movieIds.Add(new RadarrCache
{
TheMovieDbId = m.tmdbId,
HasFile = m.hasFile
});
}
else
{
Logger.LogError("TMDBId is not > 0 for movie {0}", m.title);
}
}
await _ctx.RadarrCache.AddRangeAsync(movieIds);
await _ctx.SaveChangesAsync();
}
}
catch (System.Exception ex)
{
Logger.LogError(LoggingEvents.Cacher, ex, "Failed caching queued items from Radarr");
}
}
}
catch (Exception)
{
Logger.LogInformation(LoggingEvents.RadarrCacher, "Radarr is not setup, cannot cache episodes");
}
finally
{
SemaphoreSlim.Release();
}
}
public async Task <bool> RadarrSettings([FromBody] RadarrSettings settings)
{
var result = await Save(settings);
if (result)
{
_cache.Remove(CacheKeys.RadarrRootProfiles);
_cache.Remove(CacheKeys.RadarrQualityProfiles);
BackgroundJob.Enqueue(() => _radarrSync.CacheContent());
}
return(result);
}
public async Task <IEnumerable <RadarrRootFolder> > GetRootFolders()
{
return(await Cache.GetOrAdd(CacheKeys.RadarrRootProfiles, async() =>
{
var settings = await RadarrSettings.GetSettingsAsync();
if (settings.Enabled)
{
return await RadarrApi.GetRootFolders(settings.ApiKey, settings.FullUri);
}
return null;
}, DateTime.Now.AddHours(1)));
}
public async Task <bool> RadarrSettings([FromBody] RadarrSettings settings)
{
var result = await Save(settings);
if (result)
{
_cache.Remove(CacheKeys.RadarrRootProfiles);
_cache.Remove(CacheKeys.RadarrQualityProfiles);
await OmbiQuartz.TriggerJob(nameof(IRadarrSync), "DVR");
}
return(result);
}
public async Task <bool> Radarr([FromBody] RadarrSettings settings)
{
try
{
var result = await RadarrApi.SystemStatus(settings.ApiKey, settings.FullUri);
return(result.version != null);
}
catch (Exception e)
{
Log.LogError(LoggingEvents.Api, e, "Could not test Radarr");
return(false);
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
_ctx?.Dispose();
RadarrSettings?.Dispose();
}
_disposed = true;
}
private async Task <Response> SaveCouchPotato()
{
var couchPotatoSettings = this.Bind <CouchPotatoSettings>();
var valid = this.Validate(couchPotatoSettings);
if (!valid.IsValid)
{
return(Response.AsJson(valid.SendJsonError()));
}
var watcherSettings = await WatcherSettings.GetSettingsAsync();
if (watcherSettings.Enabled)
{
return
(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = "Cannot have Watcher and CouchPotato both enabled."
}));
}
var radarrSettings = await RadarrSettings.GetSettingsAsync();
if (radarrSettings.Enabled)
{
return
(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = "Cannot have Radarr and CouchPotato both enabled."
}));
}
couchPotatoSettings.ApiKey = couchPotatoSettings.ApiKey.Trim();
var result = await CpService.SaveSettingsAsync(couchPotatoSettings);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true, Message = "Successfully Updated the Settings for CouchPotato!"
}
: new JsonResponseModel {
Result = false, Message = "Could not update the settings, take a look at the logs."
}));
}
public async Task <SenderResult> Send(MovieRequests model)
{
var cpSettings = await CouchPotatoSettings.GetSettingsAsync();
//var watcherSettings = await WatcherSettings.GetSettingsAsync();
var radarrSettings = await RadarrSettings.GetSettingsAsync();
if (radarrSettings.Enabled)
{
return(await SendToRadarr(model, radarrSettings));
}
var dogSettings = await DogNzbSettings.GetSettingsAsync();
if (dogSettings.Enabled)
{
await SendToDogNzb(model, dogSettings);
return(new SenderResult
{
Success = true,
Sent = true,
});
}
if (cpSettings.Enabled)
{
return(await SendToCp(model, cpSettings, cpSettings.DefaultProfileId));
}
//if (watcherSettings.Enabled)
//{
// return SendToWatcher(model, watcherSettings);
//}
return(new SenderResult
{
Success = true,
Sent = false,
});
}
public async Task <TesterResultModel> Radarr([FromBody] RadarrSettings settings)
{
try
{
var result = await RadarrApi.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 Radarr");
return(new TesterResultModel {
IsValid = false
});
}
}
private async Task <Response> SaveRadarr()
{
var radarrSettings = this.Bind <RadarrSettings>();
//Check Watcher and CP make sure they are not enabled
var watcher = await WatcherSettings.GetSettingsAsync();
if (watcher.Enabled)
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Watcher is enabled, we cannot enable Watcher and Radarr"
}));
}
var cp = await CpSettings.GetSettingsAsync();
if (cp.Enabled)
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "CouchPotato is enabled, we cannot enable Watcher and CouchPotato"
}));
}
var valid = this.Validate(radarrSettings);
if (!valid.IsValid)
{
return(Response.AsJson(valid.SendJsonError()));
}
radarrSettings.ApiKey = radarrSettings.ApiKey.Trim();
var result = await RadarrSettings.SaveSettingsAsync(radarrSettings);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true, Message = "Successfully Updated the Settings for Radarr!"
}
: new JsonResponseModel {
Result = false, Message = "Could not update the settings, take a look at the logs."
}));
}
private MovieSenderResult SendToRadarr(RequestedModel model, RadarrSettings settings)
{
var qualityProfile = 0;
int.TryParse(settings.QualityProfile, out qualityProfile);
var result = RadarrApi.AddMovie(model.ProviderId, model.Title, model.ReleaseDate.Year, qualityProfile, settings.RootPath, settings.ApiKey, settings.FullUri, true);
if (!string.IsNullOrEmpty(result.Error?.message))
{
Log.Error(result.Error.message);
return(new MovieSenderResult {
Result = false, Error = true
});
}
if (!string.IsNullOrEmpty(result.title))
{
return(new MovieSenderResult {
Result = true, MovieSendingEnabled = true
});
}
return(new MovieSenderResult {
Result = false, MovieSendingEnabled = true
});
}
public async Task <SenderResult> Send(MovieRequests model)
{
try
{
var cpSettings = await CouchPotatoSettings.GetSettingsAsync();
//var watcherSettings = await WatcherSettings.GetSettingsAsync();
var radarrSettings = await RadarrSettings.GetSettingsAsync();
if (radarrSettings.Enabled)
{
return(await SendToRadarr(model, radarrSettings));
}
var dogSettings = await DogNzbSettings.GetSettingsAsync();
if (dogSettings.Enabled)
{
await SendToDogNzb(model, dogSettings);
return(new SenderResult
{
Success = true,
Sent = true,
});
}
if (cpSettings.Enabled)
{
return(await SendToCp(model, cpSettings, cpSettings.DefaultProfileId));
}
}
catch (Exception e)
{
Log.LogError(e, "Error when seing movie to DVR app, added to the request queue");
// Check if already in request quee
var existingQueue = await _requestQueuRepository.FirstOrDefaultAsync(x => x.RequestId == model.Id);
if (existingQueue != null)
{
existingQueue.RetryCount++;
existingQueue.Error = e.Message;
await _requestQueuRepository.SaveChangesAsync();
}
else
{
await _requestQueuRepository.Add(new RequestQueue
{
Dts = DateTime.UtcNow,
Error = e.Message,
RequestId = model.Id,
Type = RequestType.Movie,
RetryCount = 0
});
_notificationHelper.Notify(model, NotificationType.ItemAddedToFaultQueue);
}
}
return(new SenderResult
{
Success = true,
Sent = false,
});
}
public async Task <IEnumerable <RadarrProfile> > GetProfiles([FromBody] RadarrSettings settings)
{
return(await RadarrApi.GetProfiles(settings.ApiKey, settings.FullUri));
}
private async Task <Negotiator> Radarr()
{
var settings = await RadarrSettings.GetSettingsAsync();
return(View["Radarr", settings]);
}
private async Task <SenderResult> SendToRadarr(MovieRequests model, bool is4K, RadarrSettings settings)
{
var qualityToUse = int.Parse(settings.DefaultQualityProfile);
var rootFolderPath = settings.DefaultRootPath;
var profiles = await _userProfiles.GetAll().FirstOrDefaultAsync(x => x.UserId == model.RequestedUserId);
if (profiles != null)
{
if (profiles.RadarrRootPath > 0)
{
var tempPath = await RadarrRootPath(profiles.RadarrRootPath, settings);
if (tempPath.HasValue())
{
rootFolderPath = tempPath;
}
}
if (profiles.RadarrQualityProfile > 0)
{
qualityToUse = profiles.RadarrQualityProfile;
}
}
// Overrides on the request take priority
if (model.QualityOverride > 0)
{
qualityToUse = model.QualityOverride;
}
if (model.RootPathOverride > 0)
{
rootFolderPath = await RadarrRootPath(model.RootPathOverride, settings);
}
List <MovieResponse> movies;
// Check if the movie already exists? Since it could be unmonitored
movies = await _radarrV3Api.GetMovies(settings.ApiKey, settings.FullUri);
var existingMovie = movies.FirstOrDefault(x => x.tmdbId == model.TheMovieDbId);
if (existingMovie == null)
{
var result = await _radarrV3Api.AddMovie(model.TheMovieDbId, model.Title, model.ReleaseDate.Year,
qualityToUse, rootFolderPath, settings.ApiKey, settings.FullUri, !settings.AddOnly,
settings.MinimumAvailability);
if (!string.IsNullOrEmpty(result.Error?.message))
{
_log.LogError(LoggingEvents.RadarrCacher, result.Error.message);
return(new SenderResult {
Success = false, Message = result.Error.message, Sent = false
});
}
if (!string.IsNullOrEmpty(result.title))
{
return(new SenderResult {
Success = true, Sent = false
});
}
return(new SenderResult {
Success = true, Sent = false
});
}
// We have the movie, check if we can request it or change the status
if (!existingMovie.monitored)
{
// let's set it to monitored and search for it
existingMovie.monitored = true;
await _radarrV3Api.UpdateMovie(existingMovie, settings.ApiKey, settings.FullUri);
// Search for it
if (!settings.AddOnly)
{
await _radarrV3Api.MovieSearch(new[] { existingMovie.id }, settings.ApiKey, settings.FullUri);
}
return(new SenderResult {
Success = true, Sent = true
});
}
return(new SenderResult {
Success = false, Sent = false, Message = "Movie is already monitored"
});
}
public async Task Execute(IJobExecutionContext job)
{
await SemaphoreSlim.WaitAsync();
try
{
var settings = await RadarrSettings.GetSettingsAsync();
if (settings.Enabled)
{
try
{
var movies = await RadarrApi.GetMovies(settings.ApiKey, settings.FullUri);
if (movies != null)
{
var strat = _ctx.Database.CreateExecutionStrategy();
await strat.ExecuteAsync(async() =>
{
// Let's remove the old cached data
using (var tran = await _ctx.Database.BeginTransactionAsync())
{
await _ctx.Database.ExecuteSqlRawAsync("DELETE FROM RadarrCache");
tran.Commit();
}
});
var movieIds = new List <RadarrCache>();
foreach (var m in movies)
{
if (m.monitored || m.hasFile)
{
if (m.tmdbId > 0)
{
movieIds.Add(new RadarrCache
{
TheMovieDbId = m.tmdbId,
HasFile = m.hasFile
});
}
else
{
Logger.LogError("TMDBId is not > 0 for movie {0}", m.title);
}
}
}
strat = _ctx.Database.CreateExecutionStrategy();
await strat.ExecuteAsync(async() =>
{
using (var tran = await _ctx.Database.BeginTransactionAsync())
{
await _ctx.RadarrCache.AddRangeAsync(movieIds);
await _ctx.SaveChangesAsync();
tran.Commit();
}
});
}
await OmbiQuartz.TriggerJob(nameof(IArrAvailabilityChecker), "DVR");
}
catch (System.Exception ex)
{
Logger.LogError(LoggingEvents.Cacher, ex, "Failed caching queued items from Radarr");
}
}
}
catch (Exception)
{
Logger.LogInformation(LoggingEvents.RadarrCacher, "Radarr is not setup, cannot cache episodes");
}
finally
{
SemaphoreSlim.Release();
}
}
private static string GetCode(DiscordSettings settings, RadarrSettings radarrSettings, SonarrSettings sonarrSettings, OverseerrSettings overseerrSettings)
{
var code = File.ReadAllText("SlashCommands.txt");
code = code.Replace("[REQUEST_GROUP_NAME]", Language.Current.DiscordCommandRequestGroupName);
code = code.Replace("[REQUEST_GROUP_DESCRIPTION]", Language.Current.DiscordCommandRequestGroupDescription);
code = code.Replace("[REQUEST_MOVIE_TITLE_DESCRIPTION]", Language.Current.DiscordCommandMovieRequestTitleDescription);
code = code.Replace("[REQUEST_MOVIE_TITLE_OPTION_NAME]", Language.Current.DiscordCommandMovieRequestTitleOptionName);
code = code.Replace("[REQUEST_MOVIE_TITLE_OPTION_DESCRIPTION]", Language.Current.DiscordCommandMovieRequestTitleOptionDescription);
code = code.Replace("[REQUEST_MOVIE_TMDB_DESCRIPTION]", Language.Current.DiscordCommandMovieRequestTmbdDescription);
code = code.Replace("[REQUEST_MOVIE_TMDB_OPTION_NAME]", Language.Current.DiscordCommandMovieRequestTmbdOptionName);
code = code.Replace("[REQUEST_MOVIE_TMDB_OPTION_DESCRIPTION]", Language.Current.DiscordCommandMovieRequestTmbdOptionDescription);
code = code.Replace("[REQUEST_TV_TITLE_DESCRIPTION]", Language.Current.DiscordCommandTvRequestTitleDescription);
code = code.Replace("[REQUEST_TV_TITLE_OPTION_NAME]", Language.Current.DiscordCommandTvRequestTitleOptionName);
code = code.Replace("[REQUEST_TV_TITLE_OPTION_DESCRIPTION]", Language.Current.DiscordCommandTvRequestTitleOptionDescription);
code = code.Replace("[REQUEST_TV_TVDB_DESCRIPTION]", Language.Current.DiscordCommandTvRequestTvdbDescription);
code = code.Replace("[REQUEST_TV_TVDB_OPTION_NAME]", Language.Current.DiscordCommandTvRequestTvdbOptionName);
code = code.Replace("[REQUEST_TV_TVDB_OPTION_DESCRIPTION]", Language.Current.DiscordCommandTvRequestTvdbOptionDescription);
code = code.Replace("[REQUEST_PING_NAME]", Language.Current.DiscordCommandPingRequestName);
code = code.Replace("[REQUEST_PING_DESCRIPTION]", Language.Current.DiscordCommandPingRequestDescription);
code = code.Replace("[REQUEST_HELP_NAME]", Language.Current.DiscordCommandHelpRequestName);
code = code.Replace("[REQUEST_HELP_DESCRIPTION]", Language.Current.DiscordCommandHelpRequestDescription);
code = code.Replace("[REQUIRED_MOVIE_ROLE_IDS]", string.Join(",", settings.MovieRoles.Select(x => $"{x}UL")));
code = code.Replace("[REQUIRED_TV_ROLE_IDS]", string.Join(",", settings.TvShowRoles.Select(x => $"{x}UL")));
code = code.Replace("[REQUIRED_CHANNEL_IDS]", string.Join(",", settings.MonitoredChannels.Select(x => $"{x}UL")));
if (settings.MovieDownloadClient == DownloadClient.Disabled && settings.TvShowDownloadClient == DownloadClient.Disabled)
{
var beginIndex = code.IndexOf("[REQUEST_COMMAND_START]");
var endIndex = code.IndexOf("[REQUEST_COMMAND_END]") + "[REQUEST_COMMAND_END]".Length;
code = code.Replace(code.Substring(beginIndex, endIndex - beginIndex), string.Empty);
}
else
{
if (settings.MovieDownloadClient == DownloadClient.Disabled)
{
var beginIndex = code.IndexOf("[MOVIE_COMMAND_START]");
var endIndex = code.IndexOf("[MOVIE_COMMAND_END]") + "[MOVIE_COMMAND_END]".Length;
code = code.Replace(code.Substring(beginIndex, endIndex - beginIndex), string.Empty);
}
else if (settings.MovieDownloadClient == DownloadClient.Radarr)
{
code = GenerateMovieCategories(radarrSettings.Categories.Select(x => new Category {
Id = x.Id, Name = x.Name
}).ToArray(), code);
}
else if (settings.MovieDownloadClient == DownloadClient.Overseerr && overseerrSettings.Movies.Categories.Any())
{
code = GenerateMovieCategories(overseerrSettings.Movies.Categories.Select(x => new Category {
Id = x.Id, Name = x.Name
}).ToArray(), code);
}
else
{
code = code.Replace("[REQUEST_MOVIE_TITLE_NAME]", Language.Current.DiscordCommandMovieRequestTitleName);
code = code.Replace("[REQUEST_MOVIE_TMDB_NAME]", Language.Current.DiscordCommandMovieRequestTmbdName);
code = code.Replace("[MOVIE_COMMAND_START]", string.Empty);
code = code.Replace("[MOVIE_COMMAND_END]", string.Empty);
code = code.Replace("[TMDB_COMMAND_START]", string.Empty);
code = code.Replace("[TMDB_COMMAND_END]", string.Empty);
code = code.Replace("[MOVIE_CATEGORY_ID]", "99999");
}
if (settings.TvShowDownloadClient == DownloadClient.Disabled)
{
var beginIndex = code.IndexOf("[TV_COMMAND_START]");
var endIndex = code.IndexOf("[TV_COMMAND_END]") + "[TV_COMMAND_END]".Length;
code = code.Replace(code.Substring(beginIndex, endIndex - beginIndex), string.Empty);
}
else if (settings.TvShowDownloadClient == DownloadClient.Sonarr)
{
code = GenerateTvShowCategories(sonarrSettings.Categories.Select(x => new Category {
Id = x.Id, Name = x.Name
}).ToArray(), code);
}
else if (settings.TvShowDownloadClient == DownloadClient.Overseerr && overseerrSettings.TvShows.Categories.Any())
{
code = GenerateTvShowCategories(overseerrSettings.TvShows.Categories.Select(x => new Category {
Id = x.Id, Name = x.Name
}).ToArray(), code);
}
else
{
code = code.Replace("[REQUEST_TV_TITLE_NAME]", Language.Current.DiscordCommandTvRequestTitleName);
code = code.Replace("[REQUEST_TV_TVDB_NAME]", Language.Current.DiscordCommandTvRequestTvdbName);
code = code.Replace("[TV_COMMAND_START]", string.Empty);
code = code.Replace("[TV_COMMAND_END]", string.Empty);
code = code.Replace("[TVDB_COMMAND_START]", string.Empty);
code = code.Replace("[TVDB_COMMAND_END]", string.Empty);
code = code.Replace("[TV_CATEGORY_ID]", "99999");
}
code = code.Replace("[REQUEST_COMMAND_START]", string.Empty);
code = code.Replace("[REQUEST_COMMAND_END]", string.Empty);
}
return(code);
}
