291 lines
11 KiB
C#
291 lines
11 KiB
C#
using Jellyfin.Plugin.MediaCleaner.Models;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using System.Net.Http;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.AspNetCore.Http;
|
|
using System.Net.Http.Headers;
|
|
using System;
|
|
using System.Text.Json;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Globalization;
|
|
using Jellyfin.Plugin.MediaCleaner.Enums;
|
|
using Jellyfin.Plugin.MediaCleaner.Helpers;
|
|
|
|
namespace Jellyfin.Plugin.MediaCleaner.Controllers;
|
|
|
|
[Route("sonarr")]
|
|
public class SonarrController : Controller
|
|
{
|
|
private readonly HttpClient _httpClient;
|
|
|
|
public SonarrController(HttpClient httpClient)
|
|
{
|
|
_httpClient = httpClient;
|
|
|
|
// Set the default request headers
|
|
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
|
|
}
|
|
|
|
private async Task<ObjectResult> GetSeriesInfo(SeriesInfo seriesInfo, ServerType serverType){
|
|
HttpHelper httpHelper = new(serverType);
|
|
var responseBody = await httpHelper.SendHttpRequestAsync(
|
|
HttpMethod.Get,
|
|
$"/api/v3/series?tvdbId={Uri.EscapeDataString(seriesInfo.TvdbId ?? string.Empty)}"
|
|
).ConfigureAwait(false);
|
|
|
|
var seriesResponseObj = JsonSerializer.Deserialize<List<SonarrSeries>>(responseBody.GetRawText());
|
|
var series = seriesResponseObj?.FirstOrDefault();
|
|
|
|
if (series == null)
|
|
{
|
|
return NotFound("Series not found in Sonarr library.");
|
|
}
|
|
|
|
return Ok(series);
|
|
}
|
|
|
|
private async Task<ObjectResult> GetEpisodeInfo(SonarrSeries sonarrSeries, ServerType serverType){
|
|
HttpHelper httpHelper = new(serverType);
|
|
var responseBody = await httpHelper.SendHttpRequestAsync(
|
|
HttpMethod.Get,
|
|
$"/api/v3/episode?seriesId={sonarrSeries.Id.ToString(CultureInfo.InvariantCulture)}"
|
|
).ConfigureAwait(false);
|
|
|
|
var episodesResponseObj = JsonSerializer.Deserialize<List<EpisodeDeletionDetails>>(responseBody.GetRawText());
|
|
|
|
if(episodesResponseObj == null){
|
|
return NotFound("No episodes in response object.");
|
|
}
|
|
|
|
var seasonNumbers = new HashSet<int>(sonarrSeries.Seasons
|
|
.Select(s => s.SeasonNumber));
|
|
|
|
var staleEpisodesResponseObj = episodesResponseObj
|
|
.Where(episodeDeletionDetail => seasonNumbers.Contains(episodeDeletionDetail.SeasonNumber))
|
|
.ToList();
|
|
|
|
var episodeIds = staleEpisodesResponseObj
|
|
.Where(episodeDeletionDetail => episodeDeletionDetail.HasFile)
|
|
.Select(episodeDeletionDetail => episodeDeletionDetail.EpisodeId)
|
|
.ToList();
|
|
|
|
var episodeFileIds = staleEpisodesResponseObj
|
|
.Where(episodeDeletionDetail => episodeDeletionDetail.HasFile)
|
|
.Select(episodeDeletionDetail => episodeDeletionDetail.EpisodeFileId)
|
|
.ToList();
|
|
|
|
return Ok(new EpisodeIdLists(episodeIds, episodeFileIds));
|
|
}
|
|
|
|
[HttpPost("deleteSeriesFromAnimeSonarr")]
|
|
public async Task<IActionResult> DeleteSeriesFromAnimeSonarr([FromBody] SeriesInfo seriesInfo){
|
|
|
|
if (seriesInfo == null || string.IsNullOrEmpty(seriesInfo.TvdbId))
|
|
{
|
|
return BadRequest("Invalid series information provided.");
|
|
}
|
|
|
|
try
|
|
{
|
|
var sonarrSeriesInfoResult = await GetSeriesInfo(seriesInfo, ServerType.SonarrAnime).ConfigureAwait(false);
|
|
|
|
if(sonarrSeriesInfoResult.StatusCode != StatusCodes.Status200OK || sonarrSeriesInfoResult.Value is not SonarrSeries){
|
|
return sonarrSeriesInfoResult;
|
|
}
|
|
|
|
SonarrSeries retrievedSeries = (SonarrSeries)sonarrSeriesInfoResult.Value;
|
|
SonarrSeries staleSeries = new(
|
|
Id: retrievedSeries.Id,
|
|
Title: retrievedSeries.Title,
|
|
Seasons: [.. seriesInfo.Seasons.Select(season => new Season(SeasonNumber: int.Parse(season, CultureInfo.InvariantCulture)))],
|
|
Ended: retrievedSeries.Ended,
|
|
TvdbId: retrievedSeries.TvdbId
|
|
);
|
|
|
|
var episodesToPurgeResult = await GetEpisodeInfo(staleSeries, ServerType.SonarrAnime).ConfigureAwait(false);
|
|
if (episodesToPurgeResult.StatusCode != StatusCodes.Status200OK || episodesToPurgeResult.Value is not EpisodeIdLists)
|
|
{
|
|
return sonarrSeriesInfoResult;
|
|
}
|
|
|
|
EpisodeIdLists episodesToPurge = (EpisodeIdLists)episodesToPurgeResult.Value;
|
|
|
|
await UnmonitorSeasons(staleSeries, ServerType.SonarrAnime).ConfigureAwait(false);
|
|
await UnmonitorEpisodeIds(episodesToPurge.EpisodeIds, ServerType.SonarrAnime).ConfigureAwait(false);
|
|
await DeleteEpisodeFiles(episodesToPurge.EpisodeFileIds, ServerType.SonarrAnime).ConfigureAwait(false);
|
|
|
|
return Ok();
|
|
}
|
|
catch (HttpRequestException e)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, $"An unexpected error occurred. {e.Message}");
|
|
}
|
|
}
|
|
|
|
[HttpPost("deleteSeriesFromSonarr")]
|
|
public async Task<IActionResult> DeleteSeriesFromSonarr([FromBody] SeriesInfo seriesInfo){
|
|
|
|
if (seriesInfo == null || string.IsNullOrEmpty(seriesInfo.TvdbId))
|
|
{
|
|
return BadRequest("Invalid series information provided.");
|
|
}
|
|
|
|
try
|
|
{
|
|
var sonarrSeriesInfoResult = await GetSeriesInfo(seriesInfo, ServerType.Sonarr).ConfigureAwait(false);
|
|
|
|
if(sonarrSeriesInfoResult.StatusCode != StatusCodes.Status200OK || sonarrSeriesInfoResult.Value is not SonarrSeries){
|
|
return sonarrSeriesInfoResult;
|
|
}
|
|
|
|
SonarrSeries retrievedSeries = (SonarrSeries)sonarrSeriesInfoResult.Value;
|
|
SonarrSeries staleSeries = new(
|
|
Id: retrievedSeries.Id,
|
|
Title: retrievedSeries.Title,
|
|
Seasons: [.. seriesInfo.Seasons.Select(season => new Season(SeasonNumber: int.Parse(season, CultureInfo.InvariantCulture)))],
|
|
Ended: retrievedSeries.Ended,
|
|
TvdbId: retrievedSeries.TvdbId
|
|
);
|
|
|
|
var episodesToPurgeResult = await GetEpisodeInfo(staleSeries, ServerType.Sonarr).ConfigureAwait(false);
|
|
if (episodesToPurgeResult.StatusCode != StatusCodes.Status200OK || episodesToPurgeResult.Value is not EpisodeIdLists)
|
|
{
|
|
return sonarrSeriesInfoResult;
|
|
}
|
|
|
|
EpisodeIdLists episodesToPurge = (EpisodeIdLists)episodesToPurgeResult.Value;
|
|
|
|
await UnmonitorSeasons(staleSeries, ServerType.Sonarr).ConfigureAwait(false);
|
|
await UnmonitorEpisodeIds(episodesToPurge.EpisodeIds, ServerType.Sonarr).ConfigureAwait(false);
|
|
await DeleteEpisodeFiles(episodesToPurge.EpisodeFileIds, ServerType.Sonarr).ConfigureAwait(false);
|
|
|
|
return Ok();
|
|
}
|
|
catch (HttpRequestException e)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, $"An unexpected error occurred. {e.Message}");
|
|
}
|
|
}
|
|
|
|
private async Task<ObjectResult> UnmonitorSeasons(SonarrSeries staleSeries, ServerType serverType){
|
|
if (staleSeries == null)
|
|
{
|
|
return BadRequest("No stale series provided.");
|
|
}
|
|
|
|
HttpHelper httpHelper = new(serverType);
|
|
var series = await httpHelper.SendHttpRequestAsync(
|
|
HttpMethod.Get,
|
|
$"/api/v3/series/{staleSeries.Id}"
|
|
).ConfigureAwait(false);
|
|
|
|
var seriesDict = JsonSerializer.Deserialize<Dictionary<string, object>>(series.GetRawText());
|
|
if (seriesDict == null)
|
|
{
|
|
throw new InvalidOperationException("Failed to deserialize season.");
|
|
}
|
|
var seasons = series.GetProperty("seasons").EnumerateArray().ToList();
|
|
|
|
var staleSeasonNumbers = staleSeries.Seasons
|
|
.Select(s => s.SeasonNumber)
|
|
.ToHashSet();
|
|
|
|
var updatedSeasons = seasons.Select(season =>
|
|
{
|
|
var seasonNumber = season.GetProperty("seasonNumber").GetInt32();
|
|
|
|
if (staleSeasonNumbers.Contains(seasonNumber))
|
|
{
|
|
var seasonDict = JsonSerializer.Deserialize<Dictionary<string, object>>(season.GetRawText());
|
|
if (seasonDict == null)
|
|
{
|
|
throw new InvalidOperationException("Failed to deserialize season.");
|
|
}
|
|
seasonDict["monitored"] = false;
|
|
return seasonDict;
|
|
}
|
|
|
|
return JsonSerializer.Deserialize<Dictionary<string, object>>(season.GetRawText());
|
|
}).ToArray();
|
|
|
|
seriesDict["seasons"] = updatedSeasons;
|
|
|
|
var responseBody = await httpHelper.SendHttpRequestAsync(
|
|
HttpMethod.Put,
|
|
$"/api/v3/series/{staleSeries.Id}",
|
|
seriesDict
|
|
).ConfigureAwait(false);
|
|
|
|
return Ok(responseBody);
|
|
}
|
|
|
|
private async Task<ObjectResult> DeleteEpisodeFiles(IReadOnlyList<int> episodeFileIds, ServerType serverType)
|
|
{
|
|
if (episodeFileIds == null || episodeFileIds.Count == 0)
|
|
{
|
|
return BadRequest("No episode file IDs provided.");
|
|
}
|
|
|
|
HttpHelper httpHelper = new(serverType);
|
|
var responseBody = await httpHelper.SendHttpRequestAsync(
|
|
HttpMethod.Delete,
|
|
"/api/v3/episodefile/bulk",
|
|
new { episodeFileIds }
|
|
).ConfigureAwait(false);
|
|
|
|
return Ok(responseBody);
|
|
}
|
|
|
|
private async Task<ObjectResult> UnmonitorEpisodeIds(IReadOnlyList<int> episodeIds, ServerType serverType)
|
|
{
|
|
if (episodeIds == null || episodeIds.Count == 0)
|
|
{
|
|
return BadRequest("No episode IDs provided.");
|
|
}
|
|
|
|
|
|
HttpHelper httpHelper = new(serverType);
|
|
var responseBody = await httpHelper.SendHttpRequestAsync(
|
|
HttpMethod.Put,
|
|
"/api/v3/episode/monitor",
|
|
new { episodeIds, monitored = false }
|
|
).ConfigureAwait(false);
|
|
|
|
return Ok(responseBody);
|
|
}
|
|
|
|
[HttpPost("testConnection")]
|
|
public async Task<IActionResult> TestConnection([FromBody] ConnectionTestRequest request)
|
|
{
|
|
if (request == null || string.IsNullOrWhiteSpace(request.Address) || string.IsNullOrWhiteSpace(request.ApiKey))
|
|
{
|
|
return BadRequest("Address and ApiKey are required.");
|
|
}
|
|
|
|
var address = request.Address.Trim();
|
|
if (!address.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
|
|
!address.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
address = "http://" + address;
|
|
}
|
|
|
|
try
|
|
{
|
|
using var httpRequest = new HttpRequestMessage(HttpMethod.Get, address);
|
|
httpRequest.Headers.Add("X-Api-Key", request.ApiKey);
|
|
|
|
var response = await _httpClient.SendAsync(httpRequest).ConfigureAwait(false);
|
|
return Ok(new { success = response.IsSuccessStatusCode });
|
|
}
|
|
catch (HttpRequestException e)
|
|
{
|
|
return StatusCode(StatusCodes.Status502BadGateway, e.Message);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError, e.Message);
|
|
}
|
|
}
|
|
}
|