New: Indexer - Headphones VIP

src/NzbDrone.Core/Indexers/Definitions/Headphones/Headphones.cs

@@ -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;
+        }
+    }
+}

src/NzbDrone.Core/Indexers/Definitions/Headphones/HeadphonesRequestGenerator.cs

@@ -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");
+        }
+    }
+}

src/NzbDrone.Core/Indexers/Definitions/Headphones/HeadphonesRssParser.cs

@@ -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;
+        }
+    }
+}

src/NzbDrone.Core/Indexers/Definitions/Headphones/HeadphonesSettings.cs

@@ -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));
+        }
+    }
+}