Added PassThePopcorn indexer (#64)

* Added PassThePopcorn indexe

* Added checkboxes for Gold and Checked torrents thanks @evulhotdog

* Sorted movie releases by golden -> checked -> upload date

* Refactored logic.

* Added flags at the end of torrent name for golden / approved

* Updated PTP GOlden to be the popcorn emoji

* Revert "Updated PTP GOlden to be the popcorn emoji"

This reverts commit c6cf0f5fc520b84f43548afe558c0797e0866fbf.

* Opps, hopefully build will pass now.

* Move PTP props to new subclass.

src/NzbDrone.Core/Indexers/PassThePopcorn/PassThePopcorn.cs

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

src/NzbDrone.Core/Indexers/PassThePopcorn/PassThePopcornApi.cs

@@ -0,0 +1,59 @@
+using System;
+using Newtonsoft.Json;
+using System.Collections.Generic;
+
+namespace NzbDrone.Core.Indexers.PassThePopcorn
+{
+    public class Director
+    {
+        public string Name { get; set; }
+        public string Id { get; set; }
+    }
+
+    public class Torrent
+    {
+        public int Id { get; set; }
+        public string Quality { get; set; }
+        public string Source { get; set; }
+        public string Container { get; set; }
+        public string Codec { get; set; }
+        public string Resolution { get; set; }
+        public bool Scene { get; set; }
+        public string Size { get; set; }
+        public DateTime UploadTime { get; set; }
+        public string RemasterTitle { get; set; }
+        public string Snatched { get; set; }
+        public string Seeders { get; set; }
+        public string Leechers { get; set; }
+        public string ReleaseName { get; set; }
+        public bool Checked { get; set; }
+        public bool GoldenPopcorn { get; set; }
+    }
+
+    public class Movie
+    {
+        public string GroupId { get; set; }
+        public string Title { get; set; }
+        public string Year { get; set; }
+        public string Cover { get; set; }
+        public List<string> Tags { get; set; }
+        public List<Director> Directors { get; set; }
+        public string ImdbId { get; set; }
+        public int TotalLeechers { get; set; }
+        public int TotalSeeders { get; set; }
+        public int TotalSnatched { get; set; }
+        public long MaxSize { get; set; }
+        public string LastUploadTime { get; set; }
+        public List<Torrent> Torrents { get; set; }
+    }
+
+    public class PassThePopcornResponse
+    {
+        public string TotalResults { get; set; }
+        public List<Movie> Movies { get; set; }
+        public string Page { get; set; }
+        public string AuthKey { get; set; }
+        public string PassKey { get; set; }
+    }
+
+}

src/NzbDrone.Core/Indexers/PassThePopcorn/PassThePopcornInfo.cs

@@ -0,0 +1,15 @@
+using NzbDrone.Core.Parser.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NzbDrone.Core.Indexers.PassThePopcorn
+{
+    public class PassThePopcornInfo : TorrentInfo
+    {
+        public bool? Golden { get; set; }
+        public bool? Scene { get; set; }
+        public bool? Approved { get; set; }
+    }
+}

src/NzbDrone.Core/Indexers/PassThePopcorn/PassThePopcornParser.cs

@@ -0,0 +1,144 @@
+using System.Collections.Generic;
+using System.Net;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using NzbDrone.Common.Http;
+using NzbDrone.Core.Indexers.Exceptions;
+using NzbDrone.Core.Parser.Model;
+using System;
+using System.Linq;
+
+namespace NzbDrone.Core.Indexers.PassThePopcorn
+{
+    public class PassThePopcornParser : IParseIndexerResponse
+    {
+        private readonly PassThePopcornSettings _settings;
+
+        public PassThePopcornParser(PassThePopcornSettings 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);
+            }
+
+            var jsonResponse = JsonConvert.DeserializeObject<PassThePopcornResponse>(indexerResponse.Content);
+
+            var responseData = jsonResponse.Movies;
+            if (responseData == null)
+            {
+                throw new IndexerException(indexerResponse,
+                    "Indexer API call response missing result data");
+            }
+
+            foreach (var result in responseData)
+            {
+                foreach (var torrent in result.Torrents)
+                {
+                    var id = torrent.Id;
+                    var title = torrent.ReleaseName;
+
+                    if (torrent.GoldenPopcorn)
+                    {
+                        title = $"{title} 🍿";
+                    }
+
+                    if (torrent.Checked)
+                    {
+                        title = $"{title} ✔";
+                    }
+
+                    //if (IsPropertyExist(torrent, "RemasterTitle"))
+                    //{
+                    //    if (torrent.RemasterTitle != null)
+                    //    {
+                    //        title = $"{title} - {torrent.RemasterTitle}";
+                    //    }
+                    //}
+
+                    // Only add approved torrents
+                    if (_settings.Approved && torrent.Checked)
+                    {
+                        torrentInfos.Add(new PassThePopcornInfo()
+                        {
+                            Guid = string.Format("PassThePopcorn-{0}", id),
+                            Title = title,
+                            Size = long.Parse(torrent.Size),
+                            DownloadUrl = GetDownloadUrl(id, jsonResponse.AuthKey, jsonResponse.PassKey),
+                            InfoUrl = GetInfoUrl(result.GroupId, id),
+                            Seeders = int.Parse(torrent.Seeders),
+                            Peers = int.Parse(torrent.Leechers) + int.Parse(torrent.Seeders),
+                            PublishDate = torrent.UploadTime.ToUniversalTime(),
+                            Golden = torrent.GoldenPopcorn,
+                            Scene = torrent.Scene,
+                            Approved = torrent.Checked
+                        });
+                    }
+                    // Add all torrents
+                    else if (!_settings.Approved)
+                    {
+                        torrentInfos.Add(new PassThePopcornInfo()
+                        {
+                            Guid = string.Format("PassThePopcorn-{0}", id),
+                            Title = title,
+                            Size = long.Parse(torrent.Size),
+                            DownloadUrl = GetDownloadUrl(id, jsonResponse.AuthKey, jsonResponse.PassKey),
+                            InfoUrl = GetInfoUrl(result.GroupId, id),
+                            Seeders = int.Parse(torrent.Seeders),
+                            Peers = int.Parse(torrent.Leechers) + int.Parse(torrent.Seeders),
+                            PublishDate = torrent.UploadTime.ToUniversalTime(),
+                            Golden = torrent.GoldenPopcorn,
+                            Scene = torrent.Scene,
+                            Approved = torrent.Checked
+                        });
+                    }
+                    // Don't add any torrents
+                    else if (_settings.Approved && !torrent.Checked)
+                    {
+                        continue;
+                    }
+                }
+            }
+
+            // prefer golden
+            // prefer scene
+            // require approval
+            return torrentInfos.OrderBy(o => ((dynamic)o).Golden ? 0 : 1).ThenBy(o => ((dynamic)o).Scene ? 0 : 1).ThenByDescending(o => ((dynamic)o).PublishDate).ToArray();
+        }
+
+        private string GetDownloadUrl(int 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, int torrentId)
+        {
+            var url = new HttpUri(_settings.BaseUrl)
+                .CombinePath("/torrents.php")
+                .AddQueryParam("id", groupId)
+                .AddQueryParam("torrentid", torrentId);
+
+            return url.FullUri;
+        }
+
+        //public static bool IsPropertyExist(dynamic torrents, string name)
+        //{
+        //    return torrents.GetType().GetProperty(name) != null;
+        //}
+    }
+}

src/NzbDrone.Core/Indexers/PassThePopcorn/PassThePopcornRequestGenerator.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NzbDrone.Common.Http;
+using NzbDrone.Common.Serializer;
+using NzbDrone.Core.IndexerSearch.Definitions;
+
+namespace NzbDrone.Core.Indexers.PassThePopcorn
+{
+    public class PassThePopcornRequestGenerator : IIndexerRequestGenerator
+    {
+        public PassThePopcornSettings 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 virtual IndexerPageableRequestChain GetSearchRequests(SingleEpisodeSearchCriteria searchCriteria)
+        {
+            return new IndexerPageableRequestChain();
+        }
+
+        public virtual IndexerPageableRequestChain GetSearchRequests(AnimeEpisodeSearchCriteria searchCriteria)
+        {
+            return new IndexerPageableRequestChain();
+        }
+
+        public virtual IndexerPageableRequestChain GetSearchRequests(SpecialEpisodeSearchCriteria searchCriteria)
+        {
+            return new IndexerPageableRequestChain();
+        }
+
+        public virtual IndexerPageableRequestChain GetSearchRequests(DailyEpisodeSearchCriteria searchCriteria)
+        {
+            return new IndexerPageableRequestChain();
+        }
+
+        public virtual IndexerPageableRequestChain GetSearchRequests(SeasonSearchCriteria searchCriteria)
+        {
+            return new IndexerPageableRequestChain();
+        }
+
+        private IEnumerable<IndexerRequest> GetRequest(string searchParameters)
+        {
+            var request = new IndexerRequest(string.Format("{0}/torrents.php?json=noredirect&searchstr={1}", Settings.BaseUrl.Trim().TrimEnd('/'), searchParameters), HttpAccept.Json);
+
+            foreach (var cookie in HttpHeader.ParseCookies(Settings.Cookie))
+            {
+                request.HttpRequest.Cookies[cookie.Key] = cookie.Value;
+            }
+
+            yield return request;
+        }
+    }
+}

src/NzbDrone.Core/Indexers/PassThePopcorn/PassThePopcornSettings.cs

@@ -0,0 +1,52 @@
+using FluentValidation;
+using NzbDrone.Core.Annotations;
+using NzbDrone.Core.ThingiProvider;
+using NzbDrone.Core.Validation;
+using System.Text.RegularExpressions;
+
+namespace NzbDrone.Core.Indexers.PassThePopcorn
+{
+    public class PassThePopcornSettingsValidator : AbstractValidator<PassThePopcornSettings>
+    {
+        public PassThePopcornSettingsValidator()
+        {
+            RuleFor(c => c.BaseUrl).ValidRootUrl();
+            RuleFor(c => c.Cookie).NotEmpty();
+
+            RuleFor(c => c.Cookie)
+                .Matches(@"__cfduid=[0-9a-f]{43}", RegexOptions.IgnoreCase)
+                .WithMessage("Wrong pattern")
+                .AsWarning();
+        }
+    }
+
+    public class PassThePopcornSettings : IProviderConfig
+    {
+        private static readonly PassThePopcornSettingsValidator Validator = new PassThePopcornSettingsValidator();
+
+        public PassThePopcornSettings()
+        {
+            BaseUrl = "https://passthepopcorn.me";
+        }
+
+        [FieldDefinition(0, Label = "API URL", Advanced = true, HelpText = "Do not change this unless you know what you're doing. Since your cookie will be sent to that host.")]
+        public string BaseUrl { get; set; }
+
+        [FieldDefinition(1, Label = "Cookie", HelpText = "PassThePopcorn uses a login cookie needed to access the API, you'll have to retrieve it via a browser.")]
+        public string Cookie { get; set; }
+
+        [FieldDefinition(2, Type = FieldType.Checkbox, Label = "Prefer Golden", HelpText = "Favors Golden Popcorn-releases over all other releases.")]
+        public bool Golden { get; set; }
+
+        [FieldDefinition(3, Type = FieldType.Checkbox, Label = "Prefer Scene", HelpText = "Favors scene-releases over non-scene releases.")]
+        public bool Scene { get; set; }
+
+        [FieldDefinition(4, Type = FieldType.Checkbox, Label = "Require Approved", HelpText = "Require staff-approval for releases to be accepted.")]
+        public bool Approved { get; set; }
+
+        public NzbDroneValidationResult Validate()
+        {
+            return new NzbDroneValidationResult(Validator.Validate(this));
+        }
+    }
+}

src/NzbDrone.Core/NzbDrone.Core.csproj

@@ -593,6 +593,12 @@
     <Compile Include="Indexers\Fanzub\FanzubRequestGenerator.cs" />
     <Compile Include="Indexers\Fanzub\FanzubSettings.cs" />
     <Compile Include="Indexers\FetchAndParseRssService.cs" />
+    <Compile Include="Indexers\PassThePopcorn\PassThePopcorn.cs" />
+    <Compile Include="Indexers\PassThePopcorn\PassThePopcornApi.cs" />
+    <Compile Include="Indexers\PassThePopcorn\PassThePopcornInfo.cs" />
+    <Compile Include="Indexers\PassThePopcorn\PassThePopcornParser.cs" />
+    <Compile Include="Indexers\PassThePopcorn\PassThePopcornRequestGenerator.cs" />
+    <Compile Include="Indexers\PassThePopcorn\PassThePopcornSettings.cs" />
     <Compile Include="Indexers\HDBits\HDBits.cs" />
     <Compile Include="Indexers\HDBits\HDBitsApi.cs" />
     <Compile Include="Indexers\HDBits\HDBitsParser.cs" />