Fixed: (BroadcastheNet) Add tests & prefer TvdbId

Trim search term
Fixed: Clarify App Sync-Indexer Logging for tags
2026-04-16 21:35:04 -04:00 · 2023-04-29 19:00:26 +03:00 · 2023-04-29 19:00:26 +03:00 · 2023-04-29 09:12:31 -05:00 · 2023-04-28 22:38:19 -05:00 · 2023-04-26 07:11:28 +03:00
11 changed files with 641 additions and 58 deletions
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -9,7 +9,7 @@ variables:
  testsFolder: './_tests'
  yarnCacheFolder: $(Pipeline.Workspace)/.yarn
  nugetCacheFolder: $(Pipeline.Workspace)/.nuget/packages
-  majorVersion: '1.4.0'
+  majorVersion: '1.4.1'
  minorVersion: $[counter('minorVersion', 1)]
  prowlarrVersion: '$(majorVersion).$(minorVersion)'
  buildName: '$(Build.SourceBranchName).$(prowlarrVersion)'
--- a/frontend/src/Indexer/Index/IndexerIndex.tsx
+++ b/frontend/src/Indexer/Index/IndexerIndex.tsx
@@ -295,7 +295,10 @@ const IndexerIndex = withScrollPosition((props: IndexerIndexProps) => {
            ) : null}

            {!error && isPopulated && !items.length ? (
-              <NoIndexer totalItems={totalItems} />
+              <NoIndexer
+                totalItems={totalItems}
+                onAddIndexerPress={onAddIndexerPress}
+              />
            ) : null}
          </PageContentBody>
          {isLoaded && !!jumpBarItems.order.length ? (
--- a/src/NzbDrone.Core.Test/IndexerTests/BroadcastheNetTests/BroadcastheNetRequestGeneratorFixture.cs
+++ b/src/NzbDrone.Core.Test/IndexerTests/BroadcastheNetTests/BroadcastheNetRequestGeneratorFixture.cs
@@ -0,0 +1,296 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DryIoc;
+using FluentAssertions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using NzbDrone.Common.Http;
+using NzbDrone.Common.Serializer;
+using NzbDrone.Core.Indexers;
+using NzbDrone.Core.Indexers.BroadcastheNet;
+using NzbDrone.Core.Indexers.Definitions.HDBits;
+using NzbDrone.Core.IndexerSearch.Definitions;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.IndexerTests.BroadcastheNetTests
+{
+    public class BroadcastheNetRequestGeneratorFixture : CoreTest<BroadcastheNetRequestGenerator>
+    {
+        [SetUp]
+        public void Setup()
+        {
+            Subject.Settings = new BroadcastheNetSettings
+            {
+                BaseUrl = "https://api.broadcasthe.net/",
+                ApiKey = "abc"
+            };
+
+            Subject.Capabilities = new IndexerCapabilities
+            {
+                LimitsDefault = 100,
+                LimitsMax = 1000,
+                TvSearchParams = new List<TvSearchParam>
+                {
+                    TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep, TvSearchParam.TvdbId, TvSearchParam.RId
+                }
+            };
+        }
+
+        [Test]
+        public void should_have_empty_parameters_if_rss_search()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id }
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.GetAllTiers().Should().HaveCount(1);
+
+            var page = results.GetAllTiers().First().First();
+            var query = ParseTorrentQueryFromRequest(page.HttpRequest);
+
+            query.Tvdb.Should().BeNull();
+            query.Tvrage.Should().BeNull();
+            query.Search.Should().BeNullOrWhiteSpace();
+            query.Category.Should().BeNullOrWhiteSpace();
+            query.Name.Should().BeNullOrWhiteSpace();
+        }
+
+        [Test]
+        public void should_search_by_tvdbid_season_if_supported()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id },
+                TvdbId = 371980,
+                Season = 1
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.Tiers.Should().Be(1);
+            results.GetAllTiers().Should().HaveCount(2);
+
+            var firstPage = results.GetAllTiers().First().First();
+            var firstQuery = ParseTorrentQueryFromRequest(firstPage.HttpRequest);
+
+            firstQuery.Tvdb.Should().Be("371980");
+            firstQuery.Tvrage.Should().BeNull();
+            firstQuery.Search.Should().BeNull();
+            firstQuery.Category.Should().Be("Season");
+            firstQuery.Name.Should().Be("Season 1%");
+
+            var secondPage = results.GetAllTiers().Skip(1).First().First();
+            var secondQuery = ParseTorrentQueryFromRequest(secondPage.HttpRequest);
+
+            secondQuery.Tvdb.Should().Be("371980");
+            secondQuery.Tvrage.Should().BeNull();
+            secondQuery.Search.Should().BeNull();
+            secondQuery.Category.Should().Be("Episode");
+            secondQuery.Name.Should().Be("S01E%");
+        }
+
+        [Test]
+        public void should_search_by_tvdbid_season_episode_if_supported()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id },
+                TvdbId = 371980,
+                Season = 1,
+                Episode = "3"
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.Tiers.Should().Be(1);
+            results.GetAllTiers().Should().HaveCount(1);
+
+            var page = results.GetAllTiers().First().First();
+            var query = ParseTorrentQueryFromRequest(page.HttpRequest);
+
+            query.Tvdb.Should().Be("371980");
+            query.Tvrage.Should().BeNull();
+            query.Search.Should().BeNull();
+            query.Category.Should().Be("Episode");
+            query.Name.Should().Be("S01E03");
+        }
+
+        [Test]
+        public void should_search_by_tvdbid_daily_episode_if_supported()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id },
+                TvdbId = 289574,
+                Season = 2023,
+                Episode = "01/03"
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.Tiers.Should().Be(1);
+            results.GetAllTiers().Should().HaveCount(1);
+
+            var page = results.GetAllTiers().First().First();
+            var query = ParseTorrentQueryFromRequest(page.HttpRequest);
+
+            query.Tvdb.Should().Be("289574");
+            query.Tvrage.Should().BeNull();
+            query.Search.Should().BeNull();
+            query.Category.Should().Be("Episode");
+            query.Name.Should().Be("2023.01.03");
+        }
+
+        [Test]
+        public void should_prefer_search_by_tvdbid_if_rid_supported()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id },
+                TvdbId = 371980,
+                RId = 12345
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.Tiers.Should().Be(1);
+            results.GetAllTiers().Should().HaveCount(1);
+
+            var page = results.GetAllTiers().First().First();
+            var query = ParseTorrentQueryFromRequest(page.HttpRequest);
+
+            query.Tvdb.Should().Be("371980");
+            query.Tvrage.Should().BeNull();
+            query.Search.Should().BeNull();
+            query.Category.Should().BeNull();
+            query.Name.Should().BeNull();
+        }
+
+        [Test]
+        public void should_search_by_term_supported()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id },
+                SearchTerm = "Malcolm in the Middle"
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.Tiers.Should().Be(1);
+            results.GetAllTiers().Should().HaveCount(1);
+
+            var page = results.GetAllTiers().First().First();
+            var query = ParseTorrentQueryFromRequest(page.HttpRequest);
+
+            query.Tvdb.Should().BeNull();
+            query.Tvrage.Should().BeNull();
+            query.Search.Should().Be("Malcolm%in%the%Middle");
+            query.Category.Should().BeNull();
+            query.Name.Should().BeNull();
+        }
+
+        [Test]
+        public void should_search_by_term_season_if_supported()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id },
+                SearchTerm = "Malcolm in the Middle",
+                Season = 2
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.Tiers.Should().Be(1);
+            results.GetAllTiers().Should().HaveCount(2);
+
+            var firstPage = results.GetAllTiers().First().First();
+            var firstQuery = ParseTorrentQueryFromRequest(firstPage.HttpRequest);
+
+            firstQuery.Tvdb.Should().BeNull();
+            firstQuery.Tvrage.Should().BeNull();
+            firstQuery.Search.Should().Be("Malcolm%in%the%Middle");
+            firstQuery.Category.Should().Be("Season");
+            firstQuery.Name.Should().Be("Season 2%");
+
+            var secondPage = results.GetAllTiers().Skip(1).First().First();
+            var secondQuery = ParseTorrentQueryFromRequest(secondPage.HttpRequest);
+
+            secondQuery.Tvdb.Should().BeNull();
+            secondQuery.Tvrage.Should().BeNull();
+            secondQuery.Search.Should().Be("Malcolm%in%the%Middle");
+            secondQuery.Category.Should().Be("Episode");
+            secondQuery.Name.Should().Be("S02E%");
+        }
+
+        [Test]
+        public void should_search_by_term_season_episode_if_supported()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id },
+                SearchTerm = "Malcolm in the Middle",
+                Season = 2,
+                Episode = "3"
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.Tiers.Should().Be(1);
+            results.GetAllTiers().Should().HaveCount(1);
+
+            var page = results.GetAllTiers().First().First();
+            var query = ParseTorrentQueryFromRequest(page.HttpRequest);
+
+            query.Tvdb.Should().BeNull();
+            query.Tvrage.Should().BeNull();
+            query.Search.Should().Be("Malcolm%in%the%Middle");
+            query.Category.Should().Be("Episode");
+            query.Name.Should().Be("S02E03");
+        }
+
+        [Test]
+        public void should_search_by_term_daily_episode_if_supported()
+        {
+            var tvSearchCriteria = new TvSearchCriteria
+            {
+                Categories = new[] { NewznabStandardCategory.TV.Id, NewznabStandardCategory.TVHD.Id },
+                SearchTerm = "The Late Show with Stephen Colbert",
+                Season = 2023,
+                Episode = "01/03"
+            };
+
+            var results = Subject.GetSearchRequests(tvSearchCriteria);
+
+            results.Tiers.Should().Be(1);
+            results.GetAllTiers().Should().HaveCount(1);
+
+            var page = results.GetAllTiers().First().First();
+            var query = ParseTorrentQueryFromRequest(page.HttpRequest);
+
+            query.Tvdb.Should().BeNull();
+            query.Tvrage.Should().BeNull();
+            query.Search.Should().Be("The%Late%Show%with%Stephen%Colbert");
+            query.Category.Should().Be("Episode");
+            query.Name.Should().Be("2023.01.03");
+        }
+
+        private static BroadcastheNetTorrentQuery ParseTorrentQueryFromRequest(HttpRequest httpRequest)
+        {
+            var encoding = HttpHeader.GetEncodingFromContentType(httpRequest.Headers.ContentType);
+            var body = encoding.GetString(httpRequest.ContentData);
+
+            var rpcBody = JsonConvert.DeserializeObject<Dictionary<string, object>>(body);
+
+            return JsonConvert.DeserializeObject<BroadcastheNetTorrentQuery>(((JArray)rpcBody["params"])[1].ToJson());
+        }
+    }
+}
--- a/src/NzbDrone.Core/Applications/ApplicationService.cs
+++ b/src/NzbDrone.Core/Applications/ApplicationService.cs
@@ -210,11 +210,11 @@ namespace NzbDrone.Core.Applications

            if (intersectingTags.Any())
            {
-                _logger.Debug("Application {0} and indexer {1} [{2}] have {3} intersecting tags.", app.Name, indexer.Name, indexer.Id, intersectingTags.Length);
+                _logger.Debug("Application {0} and indexer {1} [{2}] have {3} intersecting (matching) tags.", app.Name, indexer.Name, indexer.Id, intersectingTags.Length);
                return true;
            }

-            _logger.Info("Application {0} does not have any intersecting tags with {1} [{2}]. Indexer will not be handled.", app.Name, indexer.Name, indexer.Id);
+            _logger.Info("Application {0} does not have any intersecting (matching) tags with {1} [{2}]. Indexer will neither be synced to nor removed from the application.", app.Name, indexer.Name, indexer.Id);
            return false;
        }

--- a/src/NzbDrone.Core/IndexerSearch/ReleaseSearchService.cs
+++ b/src/NzbDrone.Core/IndexerSearch/ReleaseSearchService.cs
@@ -8,6 +8,7 @@ using NzbDrone.Core.Indexers;
 using NzbDrone.Core.Indexers.Events;
 using NzbDrone.Core.IndexerSearch.Definitions;
 using NzbDrone.Core.Messaging.Events;
+using NzbDrone.Core.Parser;
 using NzbDrone.Core.Parser.Model;

 namespace NzbDrone.Core.IndexerSearch
@@ -56,7 +57,9 @@ namespace NzbDrone.Core.IndexerSearch
        {
            var searchSpec = Get<MovieSearchCriteria>(request, indexerIds, interactiveSearch);

-            searchSpec.ImdbId = request.imdbid;
+            var imdbId = ParseUtil.GetImdbID(request.imdbid);
+
+            searchSpec.ImdbId = imdbId.HasValue ? imdbId.Value.ToString() : null;
            searchSpec.TmdbId = request.tmdbid;
            searchSpec.TraktId = request.traktid;
            searchSpec.DoubanId = request.doubanid;
@@ -84,10 +87,12 @@ namespace NzbDrone.Core.IndexerSearch
        {
            var searchSpec = Get<TvSearchCriteria>(request, indexerIds, interactiveSearch);

+            var imdbId = ParseUtil.GetImdbID(request.imdbid);
+
+            searchSpec.ImdbId = imdbId.HasValue ? imdbId.Value.ToString() : null;
            searchSpec.Season = request.season;
            searchSpec.Episode = request.ep;
            searchSpec.TvdbId = request.tvdbid;
-            searchSpec.ImdbId = request.imdbid;
            searchSpec.TraktId = request.traktid;
            searchSpec.TmdbId = request.tmdbid;
            searchSpec.DoubanId = request.doubanid;
@@ -136,7 +141,7 @@ namespace NzbDrone.Core.IndexerSearch
                spec.Categories = Array.Empty<int>();
            }

-            spec.SearchTerm = query.q;
+            spec.SearchTerm = query.q?.Trim();
            spec.SearchType = query.t;
            spec.Limit = query.limit;
            spec.Offset = query.offset;
--- a/src/NzbDrone.Core/Indexers/Definitions/AnimeBytes.cs
+++ b/src/NzbDrone.Core/Indexers/Definitions/AnimeBytes.cs
@@ -368,7 +368,7 @@ namespace NzbDrone.Core.Indexers.Definitions

                        if (_settings.EnableSonarrCompatibility)
                        {
-                            var simpleSeasonRegex = new Regex(@"Season (\d+)", RegexOptions.Compiled);
+                            var simpleSeasonRegex = new Regex(@"\bSeason (\d+)\b", RegexOptions.Compiled);
                            var simpleSeasonRegexMatch = simpleSeasonRegex.Match(releaseInfo);
                            if (simpleSeasonRegexMatch.Success)
                            {
@@ -376,7 +376,7 @@ namespace NzbDrone.Core.Indexers.Definitions
                            }
                        }

-                        var episodeRegex = new Regex(@"Episode (\d+)", RegexOptions.Compiled);
+                        var episodeRegex = new Regex(@"\bEpisode (\d+)\b", RegexOptions.Compiled);
                        var episodeRegexMatch = episodeRegex.Match(releaseInfo);
                        if (episodeRegexMatch.Success)
                        {
@@ -579,7 +579,7 @@ namespace NzbDrone.Core.Indexers.Definitions
        {
            var advancedSeasonRegex = new Regex(@"(\d+)(st|nd|rd|th) Season", RegexOptions.Compiled | RegexOptions.IgnoreCase);
            var seasonCharactersRegex = new Regex(@"(I{2,})$", RegexOptions.Compiled);
-            var seasonNumberRegex = new Regex(@"\b([2-9])$", RegexOptions.Compiled);
+            var seasonNumberRegex = new Regex(@"\b(?:S)?([2-9])$", RegexOptions.Compiled);

            foreach (var title in titles)
            {
--- a/src/NzbDrone.Core/Indexers/Definitions/BroadcastheNet/BroadcastheNetRequestGenerator.cs
+++ b/src/NzbDrone.Core/Indexers/Definitions/BroadcastheNet/BroadcastheNetRequestGenerator.cs
@@ -50,7 +50,7 @@ namespace NzbDrone.Core.Indexers.BroadcastheNet

            var parameters = new BroadcastheNetTorrentQuery();

-            var searchString = searchCriteria.SearchTerm ?? "";
+            var searchString = searchCriteria.SearchTerm ?? string.Empty;

            var btnResults = searchCriteria.Limit.GetValueOrDefault();
            if (btnResults == 0)
@@ -64,11 +64,14 @@ namespace NzbDrone.Core.Indexers.BroadcastheNet
            {
                parameters.Tvdb = $"{searchCriteria.TvdbId}";
            }
-
-            if (searchCriteria.RId > 0)
+            else if (searchCriteria.RId > 0)
            {
                parameters.Tvrage = $"{searchCriteria.RId}";
            }
+            else if (searchString.IsNotNullOrWhiteSpace())
+            {
+                parameters.Search = searchString.Replace(" ", "%");
+            }

            // If only the season/episode is searched for then change format to match expected format
            if (searchCriteria.Season > 0 && searchCriteria.Episode.IsNullOrWhiteSpace())
@@ -102,7 +105,6 @@ namespace NzbDrone.Core.Indexers.BroadcastheNet
            else
            {
                // Neither a season only search nor daily nor standard, fall back to query
-                parameters.Search = searchString.Replace(" ", "%");
                pageableRequests.Add(GetPagedRequests(parameters, btnResults, btnOffset));
            }

--- a/src/NzbDrone.Core/Indexers/Definitions/PixelHD.cs
+++ b/src/NzbDrone.Core/Indexers/Definitions/PixelHD.cs
@@ -0,0 +1,255 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Globalization;
+using System.Net;
+using System.Text;
+using AngleSharp.Html.Parser;
+using FluentValidation;
+using NLog;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Common.Http;
+using NzbDrone.Core.Annotations;
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.Indexers.Exceptions;
+using NzbDrone.Core.Indexers.Settings;
+using NzbDrone.Core.IndexerSearch.Definitions;
+using NzbDrone.Core.Messaging.Events;
+using NzbDrone.Core.Parser;
+using NzbDrone.Core.Parser.Model;
+using NzbDrone.Core.Validation;
+
+namespace NzbDrone.Core.Indexers.Definitions;
+
+public class PixelHD : TorrentIndexerBase<PixelHDSettings>
+{
+    public override string Name => "PiXELHD";
+    public override string[] IndexerUrls => new[] { "https://pixelhd.me/" };
+    public override string Description => "PixelHD (PxHD) is a ratioless Private Torrent Tracker for HD .MP4 MOVIES / TV";
+    public override string Language => "en-US";
+    public override Encoding Encoding => Encoding.UTF8;
+    public override DownloadProtocol Protocol => DownloadProtocol.Torrent;
+    public override IndexerPrivacy Privacy => IndexerPrivacy.Private;
+    public override IndexerCapabilities Capabilities => SetCapabilities();
+
+    public PixelHD(IIndexerHttpClient httpClient,
+                   IEventAggregator eventAggregator,
+                   IIndexerStatusService indexerStatusService,
+                   IConfigService configService,
+                   Logger logger)
+        : base(httpClient, eventAggregator, indexerStatusService, configService, logger)
+    {
+    }
+
+    public override IIndexerRequestGenerator GetRequestGenerator()
+    {
+        return new PixelHDRequestGenerator(Settings);
+    }
+
+    public override IParseIndexerResponse GetParser()
+    {
+        return new PixelHDParser(Settings);
+    }
+
+    protected override bool CheckIfLoginNeeded(HttpResponse httpResponse)
+    {
+        return false;
+    }
+
+    protected override IDictionary<string, string> GetCookies()
+    {
+        return CookieUtil.CookieHeaderToDictionary(Settings.Cookie);
+    }
+
+    private IndexerCapabilities SetCapabilities()
+    {
+        var caps = new IndexerCapabilities
+        {
+            MovieSearchParams = new List<MovieSearchParam>
+            {
+                MovieSearchParam.Q, MovieSearchParam.ImdbId
+            }
+        };
+
+        caps.Categories.AddCategoryMapping("1", NewznabStandardCategory.MoviesHD);
+
+        return caps;
+    }
+}
+
+public class PixelHDRequestGenerator : IIndexerRequestGenerator
+{
+    private readonly PixelHDSettings _settings;
+
+    public PixelHDRequestGenerator(PixelHDSettings settings)
+    {
+        _settings = settings;
+    }
+
+    public IndexerPageableRequestChain GetSearchRequests(MovieSearchCriteria searchCriteria)
+    {
+        var pageableRequests = new IndexerPageableRequestChain();
+
+        pageableRequests.Add(GetPagedRequests(searchCriteria.SanitizedSearchTerm, searchCriteria.FullImdbId));
+
+        return pageableRequests;
+    }
+
+    public IndexerPageableRequestChain GetSearchRequests(MusicSearchCriteria searchCriteria)
+    {
+        return new IndexerPageableRequestChain();
+    }
+
+    public IndexerPageableRequestChain GetSearchRequests(TvSearchCriteria searchCriteria)
+    {
+        return new IndexerPageableRequestChain();
+    }
+
+    public IndexerPageableRequestChain GetSearchRequests(BookSearchCriteria searchCriteria)
+    {
+        return new IndexerPageableRequestChain();
+    }
+
+    public IndexerPageableRequestChain GetSearchRequests(BasicSearchCriteria searchCriteria)
+    {
+        var pageableRequests = new IndexerPageableRequestChain();
+
+        pageableRequests.Add(GetPagedRequests(searchCriteria.SanitizedSearchTerm));
+
+        return pageableRequests;
+    }
+
+    private IEnumerable<IndexerRequest> GetPagedRequests(string term, string imdbId = null)
+    {
+        var parameters = new NameValueCollection
+        {
+            { "order_by", "time" },
+            { "order_way", "desc" }
+        };
+
+        if (imdbId.IsNotNullOrWhiteSpace())
+        {
+            parameters.Set("imdbid", imdbId);
+        }
+
+        if (term.IsNotNullOrWhiteSpace())
+        {
+            parameters.Set("groupname", term);
+        }
+
+        var searchUrl = $"{_settings.BaseUrl}torrents.php?{parameters.GetQueryString()}";
+
+        var request = new IndexerRequest(searchUrl, HttpAccept.Html);
+
+        if (_settings.UserAgent.IsNotNullOrWhiteSpace())
+        {
+            request.HttpRequest.Headers.UserAgent = _settings.UserAgent;
+        }
+
+        yield return request;
+    }
+
+    public Func<IDictionary<string, string>> GetCookies { get; set; }
+    public Action<IDictionary<string, string>, DateTime?> CookiesUpdater { get; set; }
+}
+
+public class PixelHDParser : IParseIndexerResponse
+{
+    private readonly PixelHDSettings _settings;
+
+    public PixelHDParser(PixelHDSettings settings)
+    {
+        _settings = settings;
+    }
+
+    public IList<ReleaseInfo> ParseResponse(IndexerResponse indexerResponse)
+    {
+        if (indexerResponse.HttpResponse.StatusCode != HttpStatusCode.OK)
+        {
+            throw new IndexerException(indexerResponse, $"Search returned unexpected result. Expected 200 OK but got {indexerResponse.HttpResponse.StatusCode}.");
+        }
+
+        var releaseInfos = new List<ReleaseInfo>();
+
+        var parser = new HtmlParser();
+        var dom = parser.ParseDocument(indexerResponse.Content);
+
+        var groups = dom.QuerySelectorAll("div.browsePoster");
+        foreach (var group in groups)
+        {
+            var groupName = group.QuerySelector("strong:has(a[title=\"View Torrent\"])")?.TextContent.Replace(" ]", "]");
+
+            var imdbLink = group.QuerySelector("a[href*=\"imdb.com/title/tt\"]")?.GetAttribute("href");
+            var imdbId = ParseUtil.GetImdbID(imdbLink) ?? 0;
+
+            var rows = group.QuerySelectorAll("tr.group_torrent:has(a[href^=\"torrents.php?id=\"])");
+            foreach (var row in rows)
+            {
+                var downloadUrl = _settings.BaseUrl + row.QuerySelector("a[href^=\"torrents.php?action=download\"]")?.GetAttribute("href");
+                var infoUrl = _settings.BaseUrl + row.QuerySelector("a[href^=\"torrents.php?id=\"]")?.GetAttribute("href");
+
+                var title = row.QuerySelector("a[href^=\"torrents.php?id=\"]")?.TextContent.Trim();
+
+                var seeders = ParseUtil.CoerceInt(row.QuerySelector("td:nth-child(7)")?.TextContent);
+                var peers = seeders + ParseUtil.CoerceInt(row.QuerySelector("td:nth-child(8)")?.TextContent.Trim());
+
+                var release = new TorrentInfo
+                {
+                    Guid = infoUrl,
+                    InfoUrl = infoUrl,
+                    DownloadUrl = downloadUrl,
+                    Title = $"{groupName} {title}".Trim(),
+                    Categories = new List<IndexerCategory> { NewznabStandardCategory.Movies, NewznabStandardCategory.MoviesHD },
+                    Seeders = seeders,
+                    Peers = peers,
+                    Size =  ParseUtil.GetBytes(row.QuerySelector("td:nth-child(4)")?.TextContent.Trim()),
+                    Grabs = ParseUtil.CoerceInt(row.QuerySelector("td:nth-child(6)")?.TextContent),
+                    DownloadVolumeFactor = 0,
+                    UploadVolumeFactor = 1,
+                    ImdbId = imdbId,
+                    MinimumRatio = 1,
+                    MinimumSeedTime = 259200 // 72 hours
+                };
+
+                try
+                {
+                    release.PublishDate = DateTime.ParseExact(
+                        row.QuerySelector("td:nth-child(3) span[class=\"time\"]")?.GetAttribute("title")?.Trim(),
+                        "MMM dd yyyy, HH:mm",
+                        CultureInfo.InvariantCulture);
+                }
+                catch (Exception)
+                {
+                    release.PublishDate = DateTimeUtil.FromTimeAgo(row.QuerySelector("td:nth-child(3)")?.TextContent.Trim());
+                }
+
+                releaseInfos.Add(release);
+            }
+        }
+
+        return releaseInfos.ToArray();
+    }
+
+    public Action<IDictionary<string, string>, DateTime?> CookiesUpdater { get; set; }
+}
+
+public class PixelHDSettingsValidator : CookieBaseSettingsValidator<PixelHDSettings>
+{
+    public PixelHDSettingsValidator()
+    {
+        RuleFor(c => c.UserAgent).NotEmpty();
+    }
+}
+
+public class PixelHDSettings : CookieTorrentBaseSettings
+{
+    private static readonly PixelHDSettingsValidator Validator = new ();
+
+    [FieldDefinition(3, Label = "Cookie User-Agent", Type = FieldType.Textbox, HelpText = "User-Agent associated with cookie used from Browser")]
+    public string UserAgent { get; set; }
+
+    public override NzbDroneValidationResult Validate()
+    {
+        return new NzbDroneValidationResult(Validator.Validate(this));
+    }
+}
--- a/src/NzbDrone.Core/Indexers/Definitions/XSpeeds.cs
+++ b/src/NzbDrone.Core/Indexers/Definitions/XSpeeds.cs
@@ -116,47 +116,59 @@ public class XSpeeds : TorrentIndexerBase<UserPassTorrentBaseSettings>
            }
        };

-        caps.Categories.AddCategoryMapping(92, NewznabStandardCategory.MoviesUHD, "4K Movies");
-        caps.Categories.AddCategoryMapping(91, NewznabStandardCategory.TVUHD, "4K TV");
-        caps.Categories.AddCategoryMapping(94, NewznabStandardCategory.TVUHD, "4K TV Boxsets");
        caps.Categories.AddCategoryMapping(70, NewznabStandardCategory.TVAnime, "Anime");
+        caps.Categories.AddCategoryMapping(113, NewznabStandardCategory.TVAnime, "Anime Boxsets");
+        caps.Categories.AddCategoryMapping(112, NewznabStandardCategory.MoviesOther, "Anime Movies");
+        caps.Categories.AddCategoryMapping(111, NewznabStandardCategory.MoviesOther, "Anime TV");
        caps.Categories.AddCategoryMapping(80, NewznabStandardCategory.AudioAudiobook, "Audiobooks");
-        caps.Categories.AddCategoryMapping(66, NewznabStandardCategory.MoviesBluRay, "Blu-Ray");
        caps.Categories.AddCategoryMapping(48, NewznabStandardCategory.Books, "Books Magazines");
        caps.Categories.AddCategoryMapping(68, NewznabStandardCategory.MoviesOther, "Cams/TS");
-        caps.Categories.AddCategoryMapping(65, NewznabStandardCategory.TVDocumentary, "Documentaries");
+        caps.Categories.AddCategoryMapping(140, NewznabStandardCategory.TVDocumentary, "Documentary");
        caps.Categories.AddCategoryMapping(10, NewznabStandardCategory.MoviesDVD, "DVDR");
+        caps.Categories.AddCategoryMapping(109, NewznabStandardCategory.MoviesBluRay, "Bluray Disc");
+        caps.Categories.AddCategoryMapping(131, NewznabStandardCategory.TVSport, "Fighting");
+        caps.Categories.AddCategoryMapping(134, NewznabStandardCategory.TVSport, "Fighting/Boxing");
+        caps.Categories.AddCategoryMapping(133, NewznabStandardCategory.TVSport, "Fighting/MMA");
+        caps.Categories.AddCategoryMapping(132, NewznabStandardCategory.TVSport, "Fighting/Wrestling");
        caps.Categories.AddCategoryMapping(72, NewznabStandardCategory.MoviesForeign, "Foreign");
-        caps.Categories.AddCategoryMapping(74, NewznabStandardCategory.TVOther, "Kids");
-        caps.Categories.AddCategoryMapping(95, NewznabStandardCategory.PCMac, "Mac Games");
-        caps.Categories.AddCategoryMapping(44, NewznabStandardCategory.TVSport, "MMA");
+        caps.Categories.AddCategoryMapping(116, NewznabStandardCategory.TVForeign, "Foreign Boxsets");
+        caps.Categories.AddCategoryMapping(114, NewznabStandardCategory.MoviesForeign, "Foreign Movies");
+        caps.Categories.AddCategoryMapping(115, NewznabStandardCategory.TVForeign, "Foreign TV");
+        caps.Categories.AddCategoryMapping(103, NewznabStandardCategory.ConsoleOther, "Games Console");
+        caps.Categories.AddCategoryMapping(105, NewznabStandardCategory.ConsoleOther, "Games Console/Nintendo");
+        caps.Categories.AddCategoryMapping(104, NewznabStandardCategory.ConsolePS4, "Games Console/Playstation");
+        caps.Categories.AddCategoryMapping(106, NewznabStandardCategory.ConsoleXBox, "Games Console/XBOX");
+        caps.Categories.AddCategoryMapping(6, NewznabStandardCategory.PCGames, "Games PC");
+        caps.Categories.AddCategoryMapping(108, NewznabStandardCategory.PC, "Games PC/Linux");
+        caps.Categories.AddCategoryMapping(107, NewznabStandardCategory.PCMac, "Games PC/Mac");
        caps.Categories.AddCategoryMapping(11, NewznabStandardCategory.Movies, "Movie Boxsets");
+        caps.Categories.AddCategoryMapping(118, NewznabStandardCategory.MoviesUHD, "Movie Boxsets/Boxset 4K");
+        caps.Categories.AddCategoryMapping(119, NewznabStandardCategory.MoviesHD, "Movie Boxsets/Boxset HEVC");
        caps.Categories.AddCategoryMapping(12, NewznabStandardCategory.Movies, "Movies");
+        caps.Categories.AddCategoryMapping(117, NewznabStandardCategory.MoviesUHD, "Movies 4K");
        caps.Categories.AddCategoryMapping(100, NewznabStandardCategory.MoviesHD, "Movies HEVC");
        caps.Categories.AddCategoryMapping(13, NewznabStandardCategory.Audio, "Music");
+        caps.Categories.AddCategoryMapping(135, NewznabStandardCategory.AudioLossless, "Music/FLAC");
+        caps.Categories.AddCategoryMapping(136, NewznabStandardCategory.Audio, "Music Boxset");
        caps.Categories.AddCategoryMapping(15, NewznabStandardCategory.AudioVideo, "Music Videos");
-        caps.Categories.AddCategoryMapping(32, NewznabStandardCategory.ConsoleNDS, "NDS Games");
        caps.Categories.AddCategoryMapping(9, NewznabStandardCategory.Other, "Other");
-        caps.Categories.AddCategoryMapping(6, NewznabStandardCategory.PCGames, "PC Games");
-        caps.Categories.AddCategoryMapping(45, NewznabStandardCategory.Other, "Pictures");
-        caps.Categories.AddCategoryMapping(31, NewznabStandardCategory.ConsolePS4, "Playstation");
-        caps.Categories.AddCategoryMapping(71, NewznabStandardCategory.TV, "PPV");
-        caps.Categories.AddCategoryMapping(54, NewznabStandardCategory.TV, "Soaps");
+        caps.Categories.AddCategoryMapping(125, NewznabStandardCategory.Other, "Other/Pictures");
+        caps.Categories.AddCategoryMapping(54, NewznabStandardCategory.TVOther, "Soaps");
        caps.Categories.AddCategoryMapping(20, NewznabStandardCategory.TVSport, "Sports");
-        caps.Categories.AddCategoryMapping(102, NewznabStandardCategory.TVSport, "Sports FIFA World Cup");
-        caps.Categories.AddCategoryMapping(86, NewznabStandardCategory.TVSport, "Sports MotorSports");
-        caps.Categories.AddCategoryMapping(89, NewznabStandardCategory.TVSport, "Sports Olympics");
-        caps.Categories.AddCategoryMapping(88, NewznabStandardCategory.TVSport, "Sports UK Football");
+        caps.Categories.AddCategoryMapping(88, NewznabStandardCategory.TVSport, "Sports/Football");
+        caps.Categories.AddCategoryMapping(86, NewznabStandardCategory.TVSport, "Sports/MotorSports");
+        caps.Categories.AddCategoryMapping(89, NewznabStandardCategory.TVSport, "Sports/Olympics");
        caps.Categories.AddCategoryMapping(83, NewznabStandardCategory.Movies, "TOTM");
+        caps.Categories.AddCategoryMapping(137, NewznabStandardCategory.Movies, "TOTW");
+        caps.Categories.AddCategoryMapping(126, NewznabStandardCategory.TV, "TV");
+        caps.Categories.AddCategoryMapping(127, NewznabStandardCategory.TVUHD, "TV 4K");
+        caps.Categories.AddCategoryMapping(129, NewznabStandardCategory.TVHD, "TV HD");
+        caps.Categories.AddCategoryMapping(130, NewznabStandardCategory.TVHD, "TV HEVC");
+        caps.Categories.AddCategoryMapping(128, NewznabStandardCategory.TVSD, "TV SD");
        caps.Categories.AddCategoryMapping(21, NewznabStandardCategory.TVSD, "TV Boxsets");
-        caps.Categories.AddCategoryMapping(76, NewznabStandardCategory.TVHD, "TV HD Boxsets");
-        caps.Categories.AddCategoryMapping(97, NewznabStandardCategory.TVHD, "TV HECV Boxsets");
-        caps.Categories.AddCategoryMapping(47, NewznabStandardCategory.TVHD, "TV HD");
-        caps.Categories.AddCategoryMapping(96, NewznabStandardCategory.TVHD, "TV HD HEVC");
-        caps.Categories.AddCategoryMapping(16, NewznabStandardCategory.TVSD, "TV SD");
-        caps.Categories.AddCategoryMapping(7, NewznabStandardCategory.ConsoleWii, "Wii Games");
-        caps.Categories.AddCategoryMapping(43, NewznabStandardCategory.TVSport, "Wrestling");
-        caps.Categories.AddCategoryMapping(8, NewznabStandardCategory.ConsoleXBox, "Xbox Games");
+        caps.Categories.AddCategoryMapping(120, NewznabStandardCategory.TVUHD, "Boxset TV-4K");
+        caps.Categories.AddCategoryMapping(76, NewznabStandardCategory.TVHD, "Boxset TV-HD");
+        caps.Categories.AddCategoryMapping(97, NewznabStandardCategory.TVHD, "Boxset TV-HEVC");

        return caps;
    }
--- a/src/NzbDrone.Core/Localization/Core/pt_BR.json
+++ b/src/NzbDrone.Core/Localization/Core/pt_BR.json
@@ -458,7 +458,7 @@
    "Parameters": "Parâmetros",
    "Queued": "Enfileirado",
    "GrabTitle": "Obter Título",
-    "LastDuration": "Última Duração",
+    "LastDuration": "Última duração",
    "NextExecution": "Próxima Execução",
    "Started": "Iniciado",
    "ApplicationLongTermStatusCheckAllClientMessage": "Todos os aplicativos estão indisponíveis devido a falhas por mais de 6 horas",
@@ -475,7 +475,7 @@
    "TheLatestVersionIsAlreadyInstalled": "A versão mais recente do Prowlarr já está instalada",
    "AddApplication": "Adicionar Aplicativo",
    "AddCustomFilter": "Adicionar Filtro Personalizado",
-    "OnGrabHelpText": "Ao Obter Lançamento",
+    "OnGrabHelpText": "Ao obter lançamento",
    "IncludeManualGrabsHelpText": "Incluir Capturas Manuais feitas no Prowlarr",
    "RssFeed": "Alimentador RSS",
    "VipExpiration": "Expiração VIP",
--- a/src/NzbDrone.Core/Update/UpdatePackageProvider.cs
+++ b/src/NzbDrone.Core/Update/UpdatePackageProvider.cs
@@ -34,15 +34,20 @@ namespace NzbDrone.Core.Update

        public UpdatePackage GetLatestUpdate(string branch, Version currentVersion)
        {
+            if (BuildInfo.IsDebug)
+            {
+                return null;
+            }
+
            var request = _requestBuilder.Create()
-                                         .Resource("/update/{branch}")
-                                         .AddQueryParam("version", currentVersion)
-                                         .AddQueryParam("os", OsInfo.Os.ToString().ToLowerInvariant())
-                                         .AddQueryParam("arch", RuntimeInformation.OSArchitecture)
-                                         .AddQueryParam("runtime", "netcore")
-                                         .AddQueryParam("runtimeVer", _platformInfo.Version)
-                                         .AddQueryParam("dbType", _mainDatabase.DatabaseType)
-                                         .SetSegment("branch", branch);
+                .Resource("/update/{branch}")
+                .AddQueryParam("version", currentVersion)
+                .AddQueryParam("os", OsInfo.Os.ToString().ToLowerInvariant())
+                .AddQueryParam("arch", RuntimeInformation.OSArchitecture)
+                .AddQueryParam("runtime", "netcore")
+                .AddQueryParam("runtimeVer", _platformInfo.Version)
+                .AddQueryParam("dbType", _mainDatabase.DatabaseType)
+                .SetSegment("branch", branch);

            if (_analyticsService.IsEnabled)
            {
@@ -62,15 +67,20 @@ namespace NzbDrone.Core.Update

        public List<UpdatePackage> GetRecentUpdates(string branch, Version currentVersion, Version previousVersion)
        {
+            if (BuildInfo.IsDebug)
+            {
+                return new List<UpdatePackage>();
+            }
+
            var request = _requestBuilder.Create()
-                                         .Resource("/update/{branch}/changes")
-                                         .AddQueryParam("version", currentVersion)
-                                         .AddQueryParam("os", OsInfo.Os.ToString().ToLowerInvariant())
-                                         .AddQueryParam("arch", RuntimeInformation.OSArchitecture)
-                                         .AddQueryParam("runtime", "netcore")
-                                         .AddQueryParam("runtimeVer", _platformInfo.Version)
-                                         .AddQueryParam("dbType", _mainDatabase.DatabaseType)
-                                         .SetSegment("branch", branch);
+                .Resource("/update/{branch}/changes")
+                .AddQueryParam("version", currentVersion)
+                .AddQueryParam("os", OsInfo.Os.ToString().ToLowerInvariant())
+                .AddQueryParam("arch", RuntimeInformation.OSArchitecture)
+                .AddQueryParam("runtime", "netcore")
+                .AddQueryParam("runtimeVer", _platformInfo.Version)
+                .AddQueryParam("dbType", _mainDatabase.DatabaseType)
+                .SetSegment("branch", branch);

            if (previousVersion != null && previousVersion != currentVersion)
            {
Author	SHA1	Message	Date
Bogdan	66f5fd2a26	Fixed: (BroadcastheNet) Add tests & prefer TvdbId	2023-04-29 19:00:26 +03:00
Bogdan	b5e5701791	Trim search term	2023-04-29 19:00:26 +03:00
Bakerboy448	1a9b202afe	Fixed: Clarify App Sync-Indexer Logging for tags	2023-04-29 09:12:31 -05:00
Qstick	309f42bac5	Fixed: Normalize ImdbId for incoming requests Fixes #1631	2023-04-28 22:38:19 -05:00
Weblate	ed330ea657	Translated using Weblate (Portuguese (Brazil)) Currently translated at 100.0% (484 of 484 strings) Co-authored-by: Lizandra Candido da Silva <lizandra.c.s@gmail.com> Translate-URL: https://translate.servarr.com/projects/servarr/prowlarr/pt_BR/ Translation: Servarr/Prowlarr	2023-04-26 07:11:28 +03:00
Bogdan	fc6a31ea78	Fixed: (AnimeBytes) Parsing season improvements	2023-04-25 15:20:55 +03:00
Bogdan	25ba9195cf	Fixed: (XSpeeds) Update category mappings	2023-04-25 15:18:35 +03:00
Bogdan	681f06e321	Fixed: Disable checking for updates when in debug runtime Same as `a8e2b1520a` Closes #1626	2023-04-24 17:08:02 +03:00
Bogdan	af7fb442d2	New: Add PixelHD	2023-04-24 14:38:34 +03:00
Bogdan	2061b9142f	Fixed: (XSpeeds) Update category mappings	2023-04-24 06:10:15 +03:00
Bogdan	b97f6f8ddf	Fixed: (UI) `Add New Indexer` button to open the `Add Indexer` modal Fixes #1625 Closes #1389	2023-04-24 04:31:11 +03:00
Qstick	f31c0bb1de	Bump version to 1.4.1	2023-04-23 13:18:30 -05:00