open-source-mirrors
/
Prowlarr
mirror of https://github.com/Prowlarr/Prowlarr
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

New: Indexer - Headphones VIP

Browse Source
pull/25/head
Qstick 4 years ago
parent cd17d419ac
commit 638b559a62
4 changed files with 522 additions and 0 deletions
Show Stats Download Patch File Download Diff File

91
src/NzbDrone.Core/Indexers/Definitions/Headphones/Headphones.cs
Unescape View File

@ -0,0 +1,91 @@
using System;
using System.Collections.Generic;
using System.Linq;
using FluentValidation.Results;
using NLog;
using NzbDrone.Common.Http;
using NzbDrone.Core.Configuration;
namespace NzbDrone.Core.Indexers.Headphones
{
public class Headphones : HttpIndexerBase<HeadphonesSettings>
{
public override string Name => "Headphones VIP";
public override DownloadProtocol Protocol => DownloadProtocol.Usenet;
public override IndexerPrivacy Privacy => IndexerPrivacy.Private;
public override string BaseUrl => "https://indexer.codeshy.com";
public override IndexerCapabilities Capabilities => SetCapabilities();
public override IIndexerRequestGenerator GetRequestGenerator()
{
return new HeadphonesRequestGenerator()
{
PageSize = PageSize,
Settings = Settings,
Capabilities = Capabilities,
BaseUrl = BaseUrl
};
}
public override IParseIndexerResponse GetParser()
{
return new HeadphonesRssParser(Capabilities.Categories);
}
public Headphones(IHttpClient httpClient, IIndexerStatusService indexerStatusService, IConfigService configService, Logger logger)
: base(httpClient, indexerStatusService, configService, logger)
{
}
protected override void Test(List<ValidationFailure> failures)
{
base.Test(failures);
if (failures.Any())
{
return;
}
}
public override byte[] Download(HttpUri link)
{
var requestBuilder = new HttpRequestBuilder(link.FullUri);
var downloadBytes = Array.Empty<byte>();
var request = requestBuilder.Build();
request.AddBasicAuthentication(Settings.Username, Settings.Password);
try
{
downloadBytes = _httpClient.Execute(request).ResponseData;
}
catch (Exception)
{
_indexerStatusService.RecordFailure(Definition.Id);
_logger.Error("Download failed");
}
return downloadBytes;
}
private IndexerCapabilities SetCapabilities()
{
var caps = new IndexerCapabilities
{
MusicSearchParams = new List<MusicSearchParam>
{
MusicSearchParam.Q
},
};
caps.Categories.AddCategoryMapping(3000, NewznabStandardCategory.Audio);
caps.Categories.AddCategoryMapping(3010, NewznabStandardCategory.AudioMP3);
caps.Categories.AddCategoryMapping(3040, NewznabStandardCategory.AudioLossless);
return caps;
}
}
}

144
src/NzbDrone.Core/Indexers/Definitions/Headphones/HeadphonesRequestGenerator.cs
Unescape View File

@ -0,0 +1,144 @@
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using NzbDrone.Common.Extensions;
using NzbDrone.Common.Http;
using NzbDrone.Core.IndexerSearch.Definitions;
using NzbDrone.Core.Parser;
namespace NzbDrone.Core.Indexers.Headphones
{
public class HeadphonesRequestGenerator : IIndexerRequestGenerator
{
public int MaxPages { get; set; }
public int PageSize { get; set; }
public HeadphonesSettings Settings { get; set; }
public IndexerCapabilities Capabilities { get; set; }
public string BaseUrl { get; set; }
public Func<IDictionary<string, string>> GetCookies { get; set; }
public Action<IDictionary<string, string>, DateTime?> CookiesUpdater { get; set; }
public HeadphonesRequestGenerator()
{
MaxPages = 30;
PageSize = 100;
}
public IndexerPageableRequestChain GetSearchRequests(MovieSearchCriteria searchCriteria)
{
var pageableRequests = new IndexerPageableRequestChain();
return pageableRequests;
}
public IndexerPageableRequestChain GetSearchRequests(MusicSearchCriteria searchCriteria)
{
var capabilities = Capabilities;
var pageableRequests = new IndexerPageableRequestChain();
var parameters = new NameValueCollection();
if (searchCriteria.Artist.IsNotNullOrWhiteSpace() && capabilities.MusicSearchArtistAvailable)
{
parameters.Add("artist", searchCriteria.Artist);
}
if (searchCriteria.Album.IsNotNullOrWhiteSpace() && capabilities.MusicSearchAlbumAvailable)
{
parameters.Add("album", searchCriteria.Album);
}
//Workaround issue with Sphinx search returning garbage results on some indexers. If we don't use id parameters, fallback to t=search
if (parameters.Count == 0)
{
searchCriteria.SearchType = "search";
if (searchCriteria.SearchTerm.IsNotNullOrWhiteSpace() && capabilities.SearchAvailable)
{
parameters.Add("q", NewsnabifyTitle(searchCriteria.SearchTerm));
}
}
else
{
if (searchCriteria.SearchTerm.IsNotNullOrWhiteSpace() && capabilities.MusicSearchAvailable)
{
parameters.Add("q", NewsnabifyTitle(searchCriteria.SearchTerm));
}
}
pageableRequests.Add(GetPagedRequests(searchCriteria,
parameters));
return pageableRequests;
}
public IndexerPageableRequestChain GetSearchRequests(TvSearchCriteria searchCriteria)
{
var pageableRequests = new IndexerPageableRequestChain();
return pageableRequests;
}
public IndexerPageableRequestChain GetSearchRequests(BookSearchCriteria searchCriteria)
{
var pageableRequests = new IndexerPageableRequestChain();
return pageableRequests;
}
public IndexerPageableRequestChain GetSearchRequests(BasicSearchCriteria searchCriteria)
{
var capabilities = Capabilities;
var pageableRequests = new IndexerPageableRequestChain();
var parameters = new NameValueCollection();
if (searchCriteria.SearchTerm.IsNotNullOrWhiteSpace() && capabilities.SearchAvailable)
{
parameters.Add("q", NewsnabifyTitle(searchCriteria.SearchTerm));
}
pageableRequests.Add(GetPagedRequests(searchCriteria, parameters));
return pageableRequests;
}
private IEnumerable<IndexerRequest> GetPagedRequests(SearchCriteriaBase searchCriteria, NameValueCollection parameters)
{
var baseUrl = string.Format("{0}{1}?t={2}&extended=1", BaseUrl.TrimEnd('/'), Settings.ApiPath.TrimEnd('/'), searchCriteria.SearchType);
var categories = searchCriteria.Categories;
if (categories != null && categories.Any())
{
var categoriesQuery = string.Join(",", categories.Distinct());
baseUrl += string.Format("&cat={0}", categoriesQuery);
}
if (Settings.ApiKey.IsNotNullOrWhiteSpace())
{
baseUrl += "&apikey=" + Settings.ApiKey;
}
if (searchCriteria.Limit.HasValue)
{
parameters.Add("limit", searchCriteria.Limit.ToString());
}
if (searchCriteria.Offset.HasValue)
{
parameters.Add("offset", searchCriteria.Offset.ToString());
}
var request = new IndexerRequest(string.Format("{0}&{1}", baseUrl, parameters.GetQueryString()), HttpAccept.Rss);
request.HttpRequest.AddBasicAuthentication(Settings.Username, Settings.Password);
yield return request;
}
private static string NewsnabifyTitle(string title)
{
return title.Replace("+", "%20");
}
}
}

245
src/NzbDrone.Core/Indexers/Definitions/Headphones/HeadphonesRssParser.cs
Unescape View File

@ -0,0 +1,245 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using NzbDrone.Common.Extensions;
using NzbDrone.Core.Indexers.Exceptions;
using NzbDrone.Core.Indexers.Newznab;
using NzbDrone.Core.Parser.Model;
namespace NzbDrone.Core.Indexers.Headphones
{
public class HeadphonesRssParser : RssParser
{
public const string ns = "{http://www.newznab.com/DTD/2010/feeds/attributes/}";
private readonly IndexerCapabilitiesCategories _categories;
public HeadphonesRssParser(IndexerCapabilitiesCategories categories)
{
PreferredEnclosureMimeTypes = UsenetEnclosureMimeTypes;
UseEnclosureUrl = true;
_categories = categories;
}
public static void CheckError(XDocument xdoc, IndexerResponse indexerResponse)
{
var error = xdoc.Descendants("error").FirstOrDefault();
if (error == null)
{
return;
}
var code = Convert.ToInt32(error.Attribute("code").Value);
var errorMessage = error.Attribute("description").Value;
if (code >= 100 && code <= 199)
{
throw new IndexerAuthException(errorMessage);
}
if (!indexerResponse.Request.Url.FullUri.Contains("apikey=") && (errorMessage == "Missing parameter" || errorMessage.Contains("apikey")))
{
throw new IndexerAuthException("Indexer requires an API key");
}
if (errorMessage == "Request limit reached")
{
throw new RequestLimitReachedException("API limit reached");
}
throw new NewznabException(indexerResponse, errorMessage);
}
protected override bool PreProcess(IndexerResponse indexerResponse)
{
var xdoc = LoadXmlDocument(indexerResponse);
CheckError(xdoc, indexerResponse);
return true;
}
protected override bool PostProcess(IndexerResponse indexerResponse, List<XElement> items, List<ReleaseInfo> releases)
{
var enclosureTypes = items.SelectMany(GetEnclosures).Select(v => v.Type).Distinct().ToArray();
if (enclosureTypes.Any() && enclosureTypes.Intersect(PreferredEnclosureMimeTypes).Empty())
{
if (enclosureTypes.Intersect(TorrentEnclosureMimeTypes).Any())
{
_logger.Warn("Feed does not contain {0}, found {1}, did you intend to add a Torznab indexer?", NzbEnclosureMimeType, enclosureTypes[0]);
}
else
{
_logger.Warn("Feed does not contain {0}, found {1}.", NzbEnclosureMimeType, enclosureTypes[0]);
}
}
return true;
}
protected override ReleaseInfo ProcessItem(XElement item, ReleaseInfo releaseInfo)
{
releaseInfo = base.ProcessItem(item, releaseInfo);
releaseInfo.ImdbId = GetImdbId(item);
releaseInfo.Grabs = GetGrabs(item);
releaseInfo.Files = GetFiles(item);
return releaseInfo;
}
protected override string GetInfoUrl(XElement item)
{
return ParseUrl(item.TryGetValue("comments").TrimEnd("#comments"));
}
protected override string GetCommentUrl(XElement item)
{
return ParseUrl(item.TryGetValue("comments"));
}
protected override ICollection<IndexerCategory> GetCategory(XElement item)
{
var cats = TryGetMultipleNewznabAttributes(item, "category");
var results = new List<IndexerCategory>();
foreach (var cat in cats)
{
if (int.TryParse(cat, out var intCategory))
{
var indexerCat = _categories.MapTrackerCatToNewznab(intCategory.ToString()) ?? null;
if (indexerCat != null)
{
results.AddRange(indexerCat);
}
}
}
return results;
}
protected override long GetSize(XElement item)
{
long size;
var sizeString = TryGetNewznabAttribute(item, "size");
if (!sizeString.IsNullOrWhiteSpace() && long.TryParse(sizeString, out size))
{
return size;
}
size = GetEnclosureLength(item);
return size;
}
protected override DateTime GetPublishDate(XElement item)
{
var dateString = TryGetNewznabAttribute(item, "usenetdate");
if (!dateString.IsNullOrWhiteSpace())
{
return XElementExtensions.ParseDate(dateString);
}
return base.GetPublishDate(item);
}
protected override string GetDownloadUrl(XElement item)
{
var url = base.GetDownloadUrl(item);
if (!Uri.IsWellFormedUriString(url, UriKind.Absolute))
{
url = ParseUrl((string)item.Element("enclosure").Attribute("url"));
}
return url;
}
protected virtual int GetImdbId(XElement item)
{
var imdbIdString = TryGetNewznabAttribute(item, "imdb");
int imdbId;
if (!imdbIdString.IsNullOrWhiteSpace() && int.TryParse(imdbIdString, out imdbId))
{
return imdbId;
}
return 0;
}
protected virtual int GetGrabs(XElement item)
{
var grabsString = TryGetNewznabAttribute(item, "grabs");
int grabs;
if (!grabsString.IsNullOrWhiteSpace() && int.TryParse(grabsString, out grabs))
{
return grabs;
}
return 0;
}
protected virtual int GetFiles(XElement item)
{
var filesString = TryGetNewznabAttribute(item, "files");
int files;
if (!filesString.IsNullOrWhiteSpace() && int.TryParse(filesString, out files))
{
return files;
}
return 0;
}
protected virtual int GetImdbYear(XElement item)
{
var imdbYearString = TryGetNewznabAttribute(item, "imdbyear");
int imdbYear;
if (!imdbYearString.IsNullOrWhiteSpace() && int.TryParse(imdbYearString, out imdbYear))
{
return imdbYear;
}
return 1900;
}
protected string TryGetNewznabAttribute(XElement item, string key, string defaultValue = "")
{
var attrElement = item.Elements(ns + "attr").FirstOrDefault(e => e.Attribute("name").Value.Equals(key, StringComparison.OrdinalIgnoreCase));
if (attrElement != null)
{
var attrValue = attrElement.Attribute("value");
if (attrValue != null)
{
return attrValue.Value;
}
}
return defaultValue;
}
protected List<string> TryGetMultipleNewznabAttributes(XElement item, string key)
{
var attrElements = item.Elements(ns + "attr").Where(e => e.Attribute("name").Value.Equals(key, StringComparison.OrdinalIgnoreCase));
var results = new List<string>();
foreach (var element in attrElements)
{
var attrValue = element.Attribute("value");
if (attrValue != null)
{
results.Add(attrValue.Value);
}
}
return results;
}
}
}

42
src/NzbDrone.Core/Indexers/Definitions/Headphones/HeadphonesSettings.cs
Unescape View File

@ -0,0 +1,42 @@
using FluentValidation;
using NzbDrone.Core.Annotations;
using NzbDrone.Core.ThingiProvider;
using NzbDrone.Core.Validation;
namespace NzbDrone.Core.Indexers.Headphones
{
public class HeadphonesSettingsValidator : AbstractValidator<HeadphonesSettings>
{
public HeadphonesSettingsValidator()
{
RuleFor(c => c.Username).NotEmpty();
RuleFor(c => c.Password).NotEmpty();
}
}
public class HeadphonesSettings : IProviderConfig
{
private static readonly HeadphonesSettingsValidator Validator = new HeadphonesSettingsValidator();
public HeadphonesSettings()
{
ApiPath = "/api";
ApiKey = "964d601959918a578a670984bdee9357";
}
public string ApiPath { get; set; }
public string ApiKey { get; set; }
[FieldDefinition(1, Label = "Username")]
public string Username { get; set; }
[FieldDefinition(2, Label = "Password", Type = FieldType.Password)]
public string Password { get; set; }
public virtual NzbDroneValidationResult Validate()
{
return new NzbDroneValidationResult(Validator.Validate(this));
}
}
}
Write Preview
Loading…
Cancel
Save