mirror
/
Radarr
mirror of https://github.com/Radarr/Radarr
1
0
Fork 0
Code Issues Releases Wiki Activity

Fixed: Remove AwesomeHD 

Fixes #5978
This commit is contained in:
Qstick 2021-02-28 21:24:43 -05:00
parent 4acd885f19
commit 8a062d1cba
5 changed files with 14 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/NzbDrone.Core/Datastore/Migration/191_remove_awesomehd.cs Normal file
View File

@ -0,0 +1,14 @@
using FluentMigrator;
using NzbDrone.Core.Datastore.Migration.Framework;
namespace NzbDrone.Core.Datastore.Migration
{
[Migration(191)]
public class remove_awesomehd : NzbDroneMigrationBase
{
protected override void MainDbUpgrade()
{
Delete.FromTable("Indexers").Row(new { Implementation = "AwesomeHD" });
}
}
}

31
src/NzbDrone.Core/Indexers/AwesomeHD/AwesomeHD.cs
View File

@ -1,31 +0,0 @@
using NLog;
using NzbDrone.Common.Http;
using NzbDrone.Core.Configuration;
using NzbDrone.Core.Parser;
namespace NzbDrone.Core.Indexers.AwesomeHD
{
public class AwesomeHD : HttpIndexerBase<AwesomeHDSettings>
{
public override string Name => "AwesomeHD";
public override DownloadProtocol Protocol => DownloadProtocol.Torrent;
public override bool SupportsRss => true;
public override bool SupportsSearch => true;
public override int PageSize => 50;
public AwesomeHD(IHttpClient httpClient, IIndexerStatusService indexerStatusService, IConfigService configService, IParsingService parsingService, Logger logger)
: base(httpClient, indexerStatusService, configService, parsingService, logger)
{
}
public override IIndexerRequestGenerator GetRequestGenerator()
{
return new AwesomeHDRequestGenerator() { Settings = Settings };
}
public override IParseIndexerResponse GetParser()
{
return new AwesomeHDRssParser(Settings);
}
}
}

41
src/NzbDrone.Core/Indexers/AwesomeHD/AwesomeHDRequestGenerator.cs
View File

@ -1,41 +0,0 @@
using System;
using System.Collections.Generic;
using NzbDrone.Common.Http;
using NzbDrone.Core.IndexerSearch.Definitions;
namespace NzbDrone.Core.Indexers.AwesomeHD
{
public class AwesomeHDRequestGenerator : IIndexerRequestGenerator
{
public AwesomeHDSettings Settings { get; set; }
public virtual IndexerPageableRequestChain GetRecentRequests()
{
var pageableRequests = new IndexerPageableRequestChain();
pageableRequests.Add(GetRequest(null));
return pageableRequests;
}
public IndexerPageableRequestChain GetSearchRequests(MovieSearchCriteria searchCriteria)
{
var pageableRequests = new IndexerPageableRequestChain();
pageableRequests.Add(GetRequest(searchCriteria.Movie.ImdbId));
return pageableRequests;
}
public Func<IDictionary<string, string>> GetCookies { get; set; }
public Action<IDictionary<string, string>, DateTime?> CookiesUpdater { get; set; }
private IEnumerable<IndexerRequest> GetRequest(string searchParameters)
{
if (searchParameters != null)
{
yield return new IndexerRequest($"{Settings.BaseUrl.Trim().TrimEnd('/')}/searchapi.php?action=imdbsearch&passkey={Settings.Passkey.Trim()}&imdb={searchParameters}", HttpAccept.Rss);
}
else
{
yield return new IndexerRequest($"{Settings.BaseUrl.Trim().TrimEnd('/')}/searchapi.php?action=latestmovies&passkey={Settings.Passkey.Trim()}", HttpAccept.Rss);
}
}
}
}

168
src/NzbDrone.Core/Indexers/AwesomeHD/AwesomeHDRssParser.cs
View File

@ -1,168 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Xml;
using System.Xml.Linq;
using NzbDrone.Common.Http;
using NzbDrone.Core.Indexers.Exceptions;
using NzbDrone.Core.Parser.Model;
namespace NzbDrone.Core.Indexers.AwesomeHD
{
public class AwesomeHDRssParser : IParseIndexerResponse
{
private readonly AwesomeHDSettings _settings;
public AwesomeHDRssParser(AwesomeHDSettings settings)
{
_settings = settings;
}
public IList<ReleaseInfo> ParseResponse(IndexerResponse indexerResponse)
{
var torrentInfos = new List<ReleaseInfo>();
if (indexerResponse.HttpResponse.StatusCode != HttpStatusCode.OK)
{
throw new IndexerException(indexerResponse,
"Unexpected response status {0} code from API request",
indexerResponse.HttpResponse.StatusCode);
}
try
{
var xdoc = XDocument.Parse(indexerResponse.Content);
var searchResults = xdoc.Descendants("searchresults").Select(x => new
{
AuthKey = x.Element("authkey").Value,
}).FirstOrDefault();
var torrents = xdoc.Descendants("torrent")
.Select(x => new
{
Id = x.Element("id").Value,
Name = x.Element("name").Value,
Year = x.Element("year").Value,
GroupId = x.Element("groupid").Value,
Time = DateTime.Parse(x.Element("time").Value),
UserId = x.Element("userid").Value,
Size = long.Parse(x.Element("size").Value),
Snatched = x.Element("snatched").Value,
Seeders = x.Element("seeders").Value,
Leechers = x.Element("leechers").Value,
ReleaseGroup = x.Element("releasegroup").Value,
Resolution = x.Element("resolution").Value,
Media = x.Element("media").Value,
Format = x.Element("format").Value,
Encoding = x.Element("encoding").Value,
AudioFormat = x.Element("audioformat").Value,
AudioBitrate = x.Element("audiobitrate").Value,
AudioChannels = x.Element("audiochannels").Value,
Subtitles = x.Element("subtitles").Value,
EncodeStatus = x.Element("encodestatus").Value,
Freeleech = x.Element("freeleech").Value,
Internal = x.Element("internal").Value == "1",
UserRelease = x.Element("userrelease").Value == "1",
ImdbId = x.Element("imdb").Value
}).ToList();
foreach (var torrent in torrents)
{
var id = torrent.Id;
var title = $"{torrent.Name}.{torrent.Year}.{torrent.Resolution}.{torrent.Media}.{torrent.Encoding}.{torrent.AudioFormat}-{torrent.ReleaseGroup}";
if (torrent.Encoding.ToLower() == "x265")
{
//Per AHD staff they only allow HDR x265 encodes (https://github.com/Radarr/Radarr/issues/4386)
title = $"{torrent.Name}.{torrent.Year}.{torrent.Resolution}.{torrent.Media}.HDR.{torrent.Encoding}.{torrent.AudioFormat}-{torrent.ReleaseGroup}";
}
IndexerFlags flags = 0;
if (torrent.Freeleech == "0.00")
{
flags |= IndexerFlags.G_Freeleech;
}
if (torrent.Freeleech == "0.25")
{
flags |= IndexerFlags.G_Freeleech75;
}
if (torrent.Freeleech == "0.75")
{
flags |= IndexerFlags.G_Freeleech25;
}
if (torrent.Freeleech == "0.50")
{
flags |= IndexerFlags.G_Halfleech;
}
if (torrent.Internal)
{
flags |= IndexerFlags.AHD_Internal;
}
if (torrent.UserRelease)
{
flags |= IndexerFlags.AHD_UserRelease;
}
var imdbId = 0;
if (torrent.ImdbId.Length > 2)
{
imdbId = int.Parse(torrent.ImdbId.Substring(2));
}
torrentInfos.Add(new TorrentInfo()
{
Guid = string.Format("AwesomeHD-{0}", id),
Title = title,
Size = torrent.Size,
DownloadUrl = GetDownloadUrl(id, searchResults.AuthKey, _settings.Passkey),
InfoUrl = GetInfoUrl(torrent.GroupId, id),
Seeders = int.Parse(torrent.Seeders),
Peers = int.Parse(torrent.Leechers) + int.Parse(torrent.Seeders),
PublishDate = torrent.Time.ToUniversalTime(),
ImdbId = imdbId,
IndexerFlags = flags,
});
}
}
catch (XmlException)
{
throw new IndexerException(indexerResponse,
"An error occurred while processing feed, feed invalid");
}
return torrentInfos.OrderByDescending(o => ((dynamic)o).Seeders).ToArray();
}
public Action<IDictionary<string, string>, DateTime?> CookiesUpdater { get; set; }
private string GetDownloadUrl(string torrentId, string authKey, string passKey)
{
var url = new HttpUri(_settings.BaseUrl)
.CombinePath("/torrents.php")
.AddQueryParam("action", "download")
.AddQueryParam("id", torrentId)
.AddQueryParam("authkey", authKey)
.AddQueryParam("torrent_pass", passKey);
return url.FullUri;
}
private string GetInfoUrl(string groupId, string torrentId)
{
var url = new HttpUri(_settings.BaseUrl)
.CombinePath("/torrents.php")
.AddQueryParam("id", groupId)
.AddQueryParam("torrentid", torrentId);
return url.FullUri;
}
}
}

56
src/NzbDrone.Core/Indexers/AwesomeHD/AwesomeHDSettings.cs
View File

@ -1,56 +0,0 @@
using System.Collections.Generic;
using FluentValidation;
using NzbDrone.Core.Annotations;
using NzbDrone.Core.Languages;
using NzbDrone.Core.Parser.Model;
using NzbDrone.Core.Validation;
namespace NzbDrone.Core.Indexers.AwesomeHD
{
public class AwesomeHDSettingsValidator : AbstractValidator<AwesomeHDSettings>
{
public AwesomeHDSettingsValidator()
{
RuleFor(c => c.BaseUrl).ValidRootUrl();
RuleFor(c => c.Passkey).NotEmpty();
RuleFor(c => c.SeedCriteria).SetValidator(_ => new SeedCriteriaSettingsValidator());
}
}
public class AwesomeHDSettings : ITorrentIndexerSettings
{
private static readonly AwesomeHDSettingsValidator Validator = new AwesomeHDSettingsValidator();
public AwesomeHDSettings()
{
BaseUrl = "https://awesome-hd.club";
MinimumSeeders = 0;
MultiLanguages = new List<int>();
RequiredFlags = new List<int>();
}
[FieldDefinition(0, Label = "API URL", Advanced = true, HelpText = "Do not change this unless you know what you're doing. Since you Passkey will be sent to that host.")]
public string BaseUrl { get; set; }
[FieldDefinition(1, Type = FieldType.Select, SelectOptions = typeof(LanguageFieldConverter), Label = "Multi Languages", HelpText = "What languages are normally in a multi release on this indexer?", Advanced = true)]
public IEnumerable<int> MultiLanguages { get; set; }
[FieldDefinition(2, Label = "Passkey", Privacy = PrivacyLevel.ApiKey)]
public string Passkey { get; set; }
[FieldDefinition(3, Type = FieldType.Number, Label = "Minimum Seeders", HelpText = "Minimum number of seeders required.", Advanced = true)]
public int MinimumSeeders { get; set; }
[FieldDefinition(4, Type = FieldType.TagSelect, SelectOptions = typeof(IndexerFlags), Label = "Required Flags", HelpText = "What indexer flags are required?", HelpLink = "https://wiki.servarr.com/Definitions#Indexer_Flags", Advanced = true)]
public IEnumerable<int> RequiredFlags { get; set; }
[FieldDefinition(5)]
public SeedCriteriaSettings SeedCriteria { get; set; } = new SeedCriteriaSettings();
public NzbDroneValidationResult Validate()
{
return new NzbDroneValidationResult(Validator.Validate(this));
}
}
}