App version increment

HDTorrents

README.md

@@ -1,5 +1,7 @@
 # Jackett
 
+Use just about any tracker with Sonarr
+
 ### API Access to your favorite trackers
 
 This software creates a [Torznab](https://github.com/Sonarr/Sonarr/wiki/Implementing-a-Torznab-indexer) API server on your machine that any Torznab enabled software can consume. Jackett works as a proxy server: it translates Torznab queries into tracker-site-specific http queries, parses the html response into Torznab results, then sends results back to the requesting software. 
@@ -28,6 +30,17 @@ Download in the [Releases page](https://github.com/zone117x/Jackett/releases)
  * [TorrentLeech](http://www.torrentleech.org/)
  * [Strike](https://getstrike.net/)
  * [The Pirate Bay](https://thepiratebay.se/)
+ * [RARBG](https://rarbg.com)
+ * [TorrentDay](https://torrentday.eu/)
+ * [TorrentShack](http://torrentshack.me/)
+ * [AlphaRatio](https://alpharatio.cc/)
+ * [AnimeBytes](https://animebytes.tv/)
+ * [SceneAccess](https://sceneaccess.eu/login)
+ * [ShowRSS](https://showrss.info/)
+ * [Torrentz](https://torrentz.eu/)
+ * [HD-Torrents.org](https://hd-torrents.org/)
+ * [SceneTime](https://www.scenetime.com/)
+ * [BeyondHD](https://beyondhd.me/)
 
 
 ### Additional Trackers

src/CurlSharp/CurlSharp.csproj

@@ -10,8 +10,6 @@
     <RootNamespace>CurlSharp</RootNamespace>
     <AssemblyName>CurlSharp</AssemblyName>
     <FileAlignment>512</FileAlignment>
-    <ProductVersion>12.0.0</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -86,4 +84,14 @@
   </Target>
   -->
   <ItemGroup />
+  <ProjectExtensions>
+    <MonoDevelop>
+      <Properties>
+        <Policies>
+          <TextStylePolicy inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" />
+          <CSharpFormattingPolicy IndentSwitchBody="True" IndentBlocksInsideExpressions="True" AnonymousMethodBraceStyle="NextLine" PropertyBraceStyle="NextLine" PropertyGetBraceStyle="NextLine" PropertySetBraceStyle="NextLine" EventBraceStyle="NextLine" EventAddBraceStyle="NextLine" EventRemoveBraceStyle="NextLine" StatementBraceStyle="NextLine" ElseNewLinePlacement="NewLine" CatchNewLinePlacement="NewLine" FinallyNewLinePlacement="NewLine" WhileNewLinePlacement="DoNotCare" ArrayInitializerWrapping="DoNotChange" ArrayInitializerBraceStyle="NextLine" BeforeMethodDeclarationParentheses="False" BeforeMethodCallParentheses="False" BeforeConstructorDeclarationParentheses="False" NewLineBeforeConstructorInitializerColon="NewLine" NewLineAfterConstructorInitializerColon="SameLine" BeforeDelegateDeclarationParentheses="False" NewParentheses="False" SpacesBeforeBrackets="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" />
+        </Policies>
+      </Properties>
+    </MonoDevelop>
+  </ProjectExtensions>
 </Project>

src/Jackett.sln

@@ -1,3 +1,4 @@
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2013
 VisualStudioVersion = 12.0.31101.0
@@ -6,6 +7,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Jackett", "Jackett\Jackett.
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CurlSharp", "CurlSharp\CurlSharp.csproj", "{74420A79-CC16-442C-8B1E-7C1B913844F0}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{BE7B0C8A-6144-47CD-821E-B09BA1B7BADE}"
+	ProjectSection(SolutionItems) = preProject
+		..\LICENSE = ..\LICENSE
+		..\README.md = ..\README.md
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -24,4 +31,39 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(MonoDevelopProperties) = preSolution
+		Policies = $0
+		$0.TextStylePolicy = $1
+		$1.inheritsSet = VisualStudio
+		$1.inheritsScope = text/plain
+		$1.scope = text/x-csharp
+		$0.CSharpFormattingPolicy = $2
+		$2.IndentSwitchBody = True
+		$2.IndentBlocksInsideExpressions = True
+		$2.AnonymousMethodBraceStyle = NextLine
+		$2.PropertyBraceStyle = NextLine
+		$2.PropertyGetBraceStyle = NextLine
+		$2.PropertySetBraceStyle = NextLine
+		$2.EventBraceStyle = NextLine
+		$2.EventAddBraceStyle = NextLine
+		$2.EventRemoveBraceStyle = NextLine
+		$2.StatementBraceStyle = NextLine
+		$2.ElseNewLinePlacement = NewLine
+		$2.CatchNewLinePlacement = NewLine
+		$2.FinallyNewLinePlacement = NewLine
+		$2.WhileNewLinePlacement = DoNotCare
+		$2.ArrayInitializerWrapping = DoNotChange
+		$2.ArrayInitializerBraceStyle = NextLine
+		$2.BeforeMethodDeclarationParentheses = False
+		$2.BeforeMethodCallParentheses = False
+		$2.BeforeConstructorDeclarationParentheses = False
+		$2.NewLineBeforeConstructorInitializerColon = NewLine
+		$2.NewLineAfterConstructorInitializerColon = SameLine
+		$2.BeforeDelegateDeclarationParentheses = False
+		$2.NewParentheses = False
+		$2.SpacesBeforeBrackets = False
+		$2.inheritsSet = Mono
+		$2.inheritsScope = text/x-csharp
+		$2.scope = text/x-csharp
+	EndGlobalSection
 EndGlobal

src/Jackett/BrowserUtil.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+    public static class BrowserUtil
+    {
+        public static string ChromeUserAgent
+        {
+            get { return "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36"; }
+        }
+    }
+}

src/Jackett/CachedResult.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+    public class CachedResult
+    {
+        private List<ReleaseInfo> results;
+        private DateTime created;
+        private string query;
+
+        public CachedResult(string query, List<ReleaseInfo> results){
+            this.results = results;
+            created = DateTime.Now;
+            this.query = query;
+        }
+
+        public IReadOnlyList<ReleaseInfo> Results
+        {
+            get { return results.AsReadOnly(); }
+        }
+
+        public DateTime Created
+        {
+            get { return created; }
+        }
+
+        public string Query
+        {
+            get { return query; }
+        }
+    }
+}

src/Jackett/ConfigurationDataCookie.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+
+    public class ConfigurationDataCookie : ConfigurationData
+    {
+        public StringItem Cookie { get; private set; }
+        public DisplayItem CookieHint { get; private set; }
+        public DisplayItem CookieExample { get; private set; }
+
+        public ConfigurationDataCookie()
+        {
+            Cookie = new StringItem { Name = "Cookie" };
+            CookieHint = new DisplayItem(
+            "<ol><li>Login to BeyondHD in your browser <li>Open the developer console, go the network tab <li>Find 'cookie' in the request headers <li>Copy & paste it to here</ol>")
+            {
+                Name = "CookieHint"
+            };
+            CookieExample = new DisplayItem(
+            "Example cookie header (usually longer than this):<br><code>PHPSESSID=8rk27odm; ipsconnect_63ad9c=1; more_stuff=etc;</code>")
+            {
+                Name = "CookieExample"
+            };
+        }
+
+        public override Item[] GetItems()
+        {
+            return new Item[] { Cookie, CookieHint, CookieExample };
+        }
+
+        public string CookieHeader
+        {
+            get
+            {
+                return Cookie.Value.Trim().TrimStart(new char[] { '"' }).TrimEnd(new char[] { '"' });
+            }
+        }
+    }
+
+}

src/Jackett/ConfigurationDataUrl.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+    public class ConfigurationDataUrl : ConfigurationData
+    {
+        public StringItem Url { get; private set; }
+
+        public ConfigurationDataUrl(string defaultUrl)
+        {
+            Url = new StringItem { Name = "Url", Value = defaultUrl };
+        }
+
+        public override Item[] GetItems()
+        {
+            return new Item[] { Url };
+        }
+
+        public string GetFormattedHostUrl()
+        {
+            var uri = new Uri(Url.Value);
+            return string.Format("{0}://{1}", uri.Scheme, uri.Host);
+        }
+    }
+}

src/Jackett/CookieContainerExtensions.cs

@@ -5,29 +5,53 @@ using System.Linq;
 using System.Net;
 using System.Text;
 using System.Threading.Tasks;
+using System.Web;
 
 namespace Jackett
 {
-	public static class CookieContainerExtensions
-	{
-		public static void FillFromJson (this CookieContainer cookies, Uri uri, JArray json)
-		{
-			foreach (string cookie in json) {
+    public static class CookieContainerExtensions
+    {
 
-				var w = cookie.Split ('=');
-				if (w.Length == 1)
-					cookies.Add (uri, new Cookie{ Name = cookie.Trim () });
-				else
-					cookies.Add (uri, new Cookie (w [0].Trim (), w [1].Trim ()));
-			}
-		}
+        public static void FillFromJson(this CookieContainer cookies, Uri uri, JToken json)
+        {
+            if (json["cookies"] != null)
+            {
+                var cookieArray = (JArray)json["cookies"];
+                foreach (string cookie in cookieArray)
+                {
+                    var w = cookie.Split('=');
+                    if (w.Length == 1)
+                    {
+                        cookies.Add(uri, new Cookie { Name = cookie.Trim() });
+                    }
+                    else
+                    {
+                        cookies.Add(uri, new Cookie(w[0].Trim(), w[1].Trim()));
+                    }
+                }
+            }
 
-		public static JArray ToJson (this CookieContainer cookies, Uri baseUrl)
-		{
-			return new JArray ((
-			    from cookie in cookies.GetCookies (baseUrl).Cast<Cookie> ()
-			    select cookie.Name.Trim () + "=" + cookie.Value.Trim ()
-			).ToArray ());
-		}
-	}
+            if (json["cookie_header"] != null)
+            {
+                var cfh = (string)json["cookie_header"];
+                var cookieHeaders = ((string)json["cookie_header"]).Split(';');
+                foreach (var c in cookieHeaders)
+                {
+                    try
+                    {
+                        cookies.SetCookies(uri, c);
+                    }
+                    catch (CookieException ex)
+                    {
+                        Program.LoggerInstance.Info("(Non-critical) Problem loading cookie {0}, {1}, {2}", uri, c, ex.Message);
+                    }
+                }
+            }
+        }
+
+        public static void DumpToJson(this CookieContainer cookies, Uri uri, JToken json)
+        {
+            json["cookie_header"] = cookies.GetCookieHeader(uri);
+        }
+    }
 }

src/Jackett/HttpClientExtensions.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+    public static class HttpClientExtensions
+    {
+        public static async Task<string> GetStringAsync(this HttpClient client, string uri, int retries)
+        {
+            Exception exception = null;
+            try
+            {
+                return await client.GetStringAsync(uri);
+            }
+            catch (Exception ex)
+            {
+                exception = ex;
+            }
+            if (retries > 0)
+                return await client.GetStringAsync(uri, --retries);
+            throw exception;
+        }
+    }
+}

src/Jackett/IndexerInterface.cs

@@ -14,6 +14,8 @@ namespace Jackett
         // Invoked when the indexer configuration has been applied and verified so the cookie needs to be saved
         event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
 
+        event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
         string DisplayName { get; }
         string DisplayDescription { get; }
         Uri SiteLink { get; }

src/Jackett/IndexerManager.cs

@@ -43,6 +43,7 @@ namespace Jackett
 
             IndexerInterface newIndexer = (IndexerInterface)Activator.CreateInstance(indexerType);
             newIndexer.OnSaveConfigurationRequested += newIndexer_OnSaveConfigurationRequested;
+            newIndexer.OnResultParsingError += newIndexer_OnResultParsingError;
 
             var configFilePath = GetIndexerConfigFilePath(newIndexer);
             if (File.Exists(configFilePath))
@@ -54,6 +55,14 @@ namespace Jackett
             Indexers.Add(name, newIndexer);
         }
 
+        void newIndexer_OnResultParsingError(IndexerInterface indexer, string results, Exception ex)
+        {
+            var fileName = string.Format("Error on {0} for {1}.txt", DateTime.Now.ToString("yyyyMMddHHmmss"), indexer.DisplayName);
+            var spacing = string.Join("", Enumerable.Repeat(Environment.NewLine, 5));
+            var fileContents = string.Format("{0}{1}{2}", ex, spacing, results);
+            File.WriteAllText(Path.Combine(Program.AppConfigDirectory, fileName), fileContents);
+        }
+
         string GetIndexerConfigFilePath(IndexerInterface indexer)
         {
             return Path.Combine(IndexerConfigDirectory, indexer.GetType().Name.ToLower() + ".json");

src/Jackett/Indexers/AlphaRatio.cs

@@ -0,0 +1,253 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+using System.Net.Http.Headers;
+
+namespace Jackett.Indexers
+{
+    public class AlphaRatio : IndexerInterface
+    {
+        public string DisplayName
+        {
+            get { return "AlphaRatio"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "Legendary"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public bool IsConfigured { get; private set; }
+
+        static string BaseUrl = "https://alpharatio.cc";
+
+        static string LoginUrl = BaseUrl + "/login.php";
+
+        static string SearchUrl = BaseUrl + "/ajax.php?action=browse&searchstr=";
+
+        static string DownloadUrl = BaseUrl + "/torrents.php?action=download&id=";
+
+        static string GuidUrl = BaseUrl + "/torrents.php?torrentid=";
+
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        string cookieHeader;
+
+        public AlphaRatio()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var configSaveData = new JObject();
+            if (OnSaveConfigurationRequested != null)
+                OnSaveConfigurationRequested(this, configSaveData);
+
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", @config.Password.Value },
+				{ "login", "Login" },
+			    { "keeplogged", "1" }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+            var message = CreateHttpRequest(new Uri(LoginUrl));
+            message.Content = content;
+
+            //message.Headers.Referrer = new Uri(LoginUrl);
+            string responseContent;
+
+            configSaveData = new JObject();
+
+            if (Program.IsWindows)
+            {
+                // If Windows use .net http
+                var response = await client.SendAsync(message);
+                responseContent = await response.Content.ReadAsStringAsync();
+                cookies.DumpToJson(SiteLink, configSaveData);
+            }
+            else
+            {
+                // If UNIX system use curl, probably broken due to missing chromeUseragent record for CURL...cannot test
+                var response = await CurlHelper.PostAsync(LoginUrl, pairs);
+                responseContent = Encoding.UTF8.GetString(response.Content);
+                cookieHeader = response.CookieHeader;
+                configSaveData["cookie_header"] = cookieHeader;
+            }
+
+            if (!responseContent.Contains("logout.php?"))
+            {
+                CQ dom = responseContent;
+                dom["#loginform > table"].Remove();
+                var errorMessage = dom["#loginform"].Text().Trim().Replace("\n\t", " ");
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+
+            }
+            else
+            {
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        HttpRequestMessage CreateHttpRequest(Uri uri)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Post;
+            message.RequestUri = uri;
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
+            return message;
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(SiteLink, jsonConfig);
+            cookieHeader = cookies.GetCookieHeader(SiteLink);
+            IsConfigured = true;
+        }
+
+        void FillReleaseInfoFromJson(ReleaseInfo release, JObject r)
+        {
+            var id = r["torrentId"];
+            release.Size = (long)r["size"];
+            release.Seeders = (int)r["seeders"];
+            release.Peers = (int)r["leechers"] + release.Seeders;
+            release.Guid = new Uri(GuidUrl + id);
+            release.Comments = release.Guid;
+            release.Link = new Uri(DownloadUrl + id);
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = SearchUrl + HttpUtility.UrlEncode(searchString);
+
+                string results;
+                if (Program.IsWindows)
+                {
+                    var request = CreateHttpRequest(new Uri(episodeSearchUrl));
+                    request.Method = HttpMethod.Get;
+                    var response = await client.SendAsync(request);
+                    results = await response.Content.ReadAsStringAsync();
+                }
+                else
+                {
+                    var response = await CurlHelper.GetAsync(episodeSearchUrl, cookieHeader);
+                    results = Encoding.UTF8.GetString(response.Content);
+                }
+                try
+                {
+
+                    var json = JObject.Parse(results);
+                    foreach (JObject r in json["response"]["results"])
+                    {
+                        DateTime pubDate = DateTime.MinValue;
+                        double dateNum;
+                        if (double.TryParse((string)r["groupTime"], out dateNum))
+                            pubDate = UnixTimestampToDateTime(dateNum);
+
+                        var groupName = (string)r["groupName"];
+
+                        if (r["torrents"] is JArray)
+                        {
+                            foreach (JObject t in r["torrents"])
+                            {
+                                var release = new ReleaseInfo();
+                                release.PublishDate = pubDate;
+                                release.Title = groupName;
+                                release.Description = groupName;
+                                FillReleaseInfoFromJson(release, t);
+                                releases.Add(release);
+                            }
+                        }
+                        else
+                        {
+                            var release = new ReleaseInfo();
+                            release.PublishDate = pubDate;
+                            release.Title = groupName;
+                            release.Description = groupName;
+                            FillReleaseInfoFromJson(release, r);
+                            releases.Add(release);
+                        }
+
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+
+        static DateTime UnixTimestampToDateTime(double unixTime)
+        {
+            DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
+            long unixTimeStampInTicks = (long)(unixTime * TimeSpan.TicksPerSecond);
+            return new DateTime(unixStart.Ticks + unixTimeStampInTicks);
+        }
+
+        public async Task<byte[]> Download(Uri link)
+        {
+            if (Program.IsWindows)
+            {
+                return await client.GetByteArrayAsync(link);
+            }
+            else
+            {
+                var response = await CurlHelper.GetAsync(link.ToString(), cookieHeader);
+                return response.Content;
+            }
+
+        }
+
+    }
+}

src/Jackett/Indexers/AnimeBytes.cs

@@ -0,0 +1,408 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class AnimeBytes : IndexerInterface
+    {
+        class ConfigurationDataBasicLoginAnimeBytes : ConfigurationDataBasicLogin
+        {
+            public BoolItem IncludeRaw { get; private set; }
+            public DisplayItem RageIdWarning { get; private set; }
+            public DisplayItem DateWarning { get; private set; }
+
+            public ConfigurationDataBasicLoginAnimeBytes()
+                : base()
+            {
+                IncludeRaw = new BoolItem() { Name = "IncludeRaw", Value = false };
+                RageIdWarning = new DisplayItem("Ensure rageid lookup is disabled in Sonarr for this tracker.") { Name = "RageWarning" };
+                DateWarning = new DisplayItem("This tracker does not supply upload dates so they are based off year of release.") { Name = "DateWarning" };
+            }
+
+            public override Item[] GetItems()
+            {
+                return new Item[] { Username, Password, IncludeRaw, RageIdWarning, DateWarning };
+            }
+        }
+
+        private static List<CachedResult> cache = new List<CachedResult>();
+        private static readonly TimeSpan cacheTime = new TimeSpan(0, 9, 0);
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
+
+        public string DisplayName
+        {
+            get { return "AnimeBytes"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "The web's best Chinese cartoons"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        const string BaseUrl = "https://animebytes.tv";
+        const string LoginUrl = BaseUrl + "/user/login";
+        const string SearchUrl = BaseUrl + "/torrents.php?filter_cat[1]=1";
+
+        public bool IsConfigured { get; private set; }
+        public bool AllowRaws { get; private set; }
+
+
+        CookieContainer cookieContainer;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public AnimeBytes()
+        {
+            IsConfigured = false;
+            cookieContainer = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookieContainer,
+                AllowAutoRedirect = false,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+            client.DefaultRequestHeaders.Add("User-Agent", chromeUserAgent);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLoginAnimeBytes();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLoginAnimeBytes();
+            config.LoadValuesFromJson(configJson);
+
+
+            // Get the login form as we need the CSRF Token
+            var loginPage = await client.GetAsync(LoginUrl);
+            CQ loginPageDom = await loginPage.Content.ReadAsStringAsync();
+            var csrfToken = loginPageDom["input[name=\"csrf_token\"]"].Last();
+
+            // Build login form
+            var pairs = new Dictionary<string, string> {
+                  { "csrf_token", csrfToken.Attr("value") },
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value },
+                { "keeplogged_sent", "true" },
+                { "keeplogged", "on" },
+                { "login", "Log In!" }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            // Do the login
+            var response = await client.PostAsync(LoginUrl, content);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            // Compatiblity issue between the cookie format and httpclient
+            // Pull it out manually ignoring the expiry date then set it manually
+            // http://stackoverflow.com/questions/14681144/httpclient-not-storing-cookies-in-cookiecontainer
+            IEnumerable<string> cookies;
+            if (response.Headers.TryGetValues("set-cookie", out cookies))
+            {
+                foreach (var c in cookies)
+                {
+                    cookieContainer.SetCookies(new Uri(BaseUrl), c.Substring(0, c.LastIndexOf(';')));
+                }
+            }
+
+            foreach (Cookie cookie in cookieContainer.GetCookies(new Uri(BaseUrl)))
+            {
+                if (cookie.Name == "session")
+                {
+                    cookie.Expires = DateTime.Now.AddDays(360);
+                    break;
+                }
+            }
+
+            // Get the home page now we are logged in as AllowAutoRedirect is false as we needed to get the cookie manually.
+            response = await client.GetAsync(BaseUrl);
+            responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("/user/logout"))
+            {
+                throw new ExceptionWithConfigData("Failed to login, 6 failed attempts will get you banned for 6 hours.", (ConfigurationData)config);
+            }
+            else
+            {
+                AllowRaws = config.IncludeRaw.Value;
+                var configSaveData = new JObject();
+                cookieContainer.DumpToJson(SiteLink, configSaveData);
+                configSaveData["raws"] = AllowRaws;
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookieContainer.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            IsConfigured = true;
+            AllowRaws = jsonConfig["raws"].Value<bool>();
+        }
+
+
+        private string Hash(string input)
+        {
+            // Use input string to calculate MD5 hash
+            MD5 md5 = System.Security.Cryptography.MD5.Create();
+            byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(input);
+            byte[] hashBytes = md5.ComputeHash(inputBytes);
+
+            // Convert the byte array to hexadecimal string
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < hashBytes.Length; i++)
+            {
+                sb.Append(hashBytes[i].ToString("X2"));
+            }
+            return sb.ToString();
+        }
+
+        private void CleanCache()
+        {
+            foreach (var expired in cache.Where(i => i.Created - DateTime.Now > cacheTime).ToList())
+            {
+                cache.Remove(expired);
+            }
+        }
+
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            // This tracker only deals with full seasons so chop off the episode/season number if we have it D:
+            if (!string.IsNullOrWhiteSpace(query.SearchTerm))
+            {
+                var splitindex = query.SearchTerm.LastIndexOf(' ');
+                if (splitindex > -1)
+                    query.SearchTerm = query.SearchTerm.Substring(0, splitindex);
+            }
+
+            // The result list
+            var releases = new List<ReleaseInfo>();
+
+            // Check cache first so we don't query the server for each episode when searching for each episode in a series.
+            lock (cache)
+            {
+                // Remove old cache items
+                CleanCache();
+
+                var cachedResult = cache.Where(i => i.Query == query.SearchTerm).FirstOrDefault();
+                if (cachedResult != null)
+                    return cachedResult.Results.Select(s => (ReleaseInfo)s.Clone()).ToArray();
+            }
+
+            var queryUrl = SearchUrl;
+            // Only include the query bit if its required as hopefully the site caches the non query page
+            if (!string.IsNullOrWhiteSpace(query.SearchTerm))
+            {
+
+                queryUrl += "&action=advanced&search_type=title&sort=time_added&way=desc&anime%5Btv_series%5D=1&searchstr=" + WebUtility.UrlEncode(query.SearchTerm);
+            }
+
+            // Get the content from the tracker
+            var response = await client.GetAsync(queryUrl);
+            var responseContent = await response.Content.ReadAsStringAsync();
+            CQ dom = responseContent;
+
+            // Parse
+            try
+            {
+                var releaseInfo = "S01";
+                var root = dom.Find(".anime");
+                // We may have got redirected to the series page if we have none of these
+                if (root.Count() == 0)
+                    root = dom.Find(".torrent_table");
+
+                foreach (var series in root)
+                {
+                    var seriesCq = series.Cq();
+
+                    var synonyms = new List<string>();
+                    var mainTitle = seriesCq.Find(".group_title strong a").First().Text().Trim();
+
+                    var yearStr = seriesCq.Find(".group_title strong").First().Text().Trim().Replace("]", "").Trim();
+                    int yearIndex = yearStr.LastIndexOf("[");
+                    if (yearIndex > -1)
+                        yearStr = yearStr.Substring(yearIndex + 1);
+
+                    int year = 0;
+                    if (!int.TryParse(yearStr, out year))
+                        year = DateTime.Now.Year;
+
+                    synonyms.Add(mainTitle);
+
+                    // If the title contains a comma then we can't use the synonyms as they are comma seperated
+                    if (!mainTitle.Contains(","))
+                    {
+                        var symnomnNames = string.Empty;
+                        foreach (var e in seriesCq.Find(".group_statbox li"))
+                        {
+                            if (e.FirstChild.InnerText == "Synonyms:")
+                            {
+                                symnomnNames = e.InnerText;
+                            }
+                        }
+
+                        if (!string.IsNullOrWhiteSpace(symnomnNames))
+                        {
+                            foreach (var name in symnomnNames.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
+                            {
+                                var theName = name.Trim();
+                                if (!theName.Contains("&#") && !string.IsNullOrWhiteSpace(theName))
+                                {
+                                    synonyms.Add(theName);
+                                }
+                            }
+                        }
+                    }
+
+                    foreach (var title in synonyms)
+                    {
+                        var releaseRows = seriesCq.Find(".torrent_group tr");
+
+                        // Skip the first two info rows
+                        for (int r = 2; r < releaseRows.Count(); r++)
+                        {
+                            var row = releaseRows.Get(r);
+                            var rowCq = row.Cq();
+                            if (rowCq.HasClass("edition_info"))
+                            {
+                                releaseInfo = rowCq.Find("td").Text();
+
+                                if (string.IsNullOrWhiteSpace(releaseInfo))
+                                {
+                                    // Single episodes alpha - Reported that this info is missing.
+                                    // It should self correct when availible
+                                    break;
+                                }
+
+                                releaseInfo = releaseInfo.Replace("Episode ", "");
+                                releaseInfo = releaseInfo.Replace("Season ", "S");
+                                releaseInfo = releaseInfo.Trim();
+                            }
+                            else if (rowCq.HasClass("torrent"))
+                            {
+                                var links = rowCq.Find("a");
+                                // Protect against format changes
+                                if (links.Count() != 2)
+                                {
+                                    continue;
+                                }
+
+                                var release = new ReleaseInfo();
+                                release.MinimumRatio = 1;
+                                release.MinimumSeedTime = 259200;
+                                var downloadLink = links.Get(0);
+                                release.Guid = new Uri(BaseUrl + "/" + downloadLink.Attributes.GetAttribute("href") + "&nh=" + Hash(title)); // Sonarr should dedupe on this url - allow a url per name.
+                                release.Link = release.Guid;// We dont know this so try to fake based on the release year
+                                release.PublishDate = new DateTime(year, 1, 1);
+                                release.PublishDate = release.PublishDate.AddDays(Math.Min(DateTime.Now.DayOfYear, 365) - 1);
+
+                                var infoLink = links.Get(1);
+                                release.Comments = new Uri(BaseUrl + "/" + infoLink.Attributes.GetAttribute("href"));
+
+                                // We dont actually have a release name >.> so try to create one
+                                var releaseTags = infoLink.InnerText.Split("|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries).ToList();
+                                for (int i = releaseTags.Count - 1; i >= 0; i--)
+                                {
+                                    releaseTags[i] = releaseTags[i].Trim();
+                                    if (string.IsNullOrWhiteSpace(releaseTags[i]))
+                                        releaseTags.RemoveAt(i);
+                                }
+
+                                var group = releaseTags.Last();
+                                if (group.Contains("(") && group.Contains(")"))
+                                {
+                                    // Skip raws if set
+                                    if (group.ToLowerInvariant().StartsWith("raw") && !AllowRaws)
+                                    {
+                                        continue;
+                                    }
+
+                                    var start = group.IndexOf("(");
+                                    group = "[" + group.Substring(start + 1, (group.IndexOf(")") - 1) - start) + "] ";
+                                }
+                                else
+                                {
+                                    group = string.Empty;
+                                }
+
+                                var infoString = "";
+
+                                for (int i = 0; i + 1 < releaseTags.Count(); i++)
+                                {
+                                    infoString += "[" + releaseTags[i] + "]";
+                                }
+
+                                release.Title = string.Format("{0}{1} {2} {3}", group, title, releaseInfo, infoString);
+                                release.Description = title;
+
+                                var size = rowCq.Find(".torrent_size");
+                                if (size.Count() > 0)
+                                {
+                                    var sizeParts = size.First().Text().Split(' ');
+                                    release.Size = ReleaseInfo.GetBytes(sizeParts[1], ParseUtil.CoerceFloat(sizeParts[0]));
+                                }
+
+                                //  Additional 5 hours per GB 
+                                release.MinimumSeedTime += (release.Size / 1000000000) * 18000;
+
+                                // Peer info
+                                release.Seeders = ParseUtil.CoerceInt(rowCq.Find(".torrent_seeders").Text());
+                                release.Peers = release.Seeders + ParseUtil.CoerceInt(rowCq.Find(".torrent_leechers").Text());
+
+                                releases.Add(release);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                OnResultParsingError(this, responseContent, ex);
+                throw ex;
+            }
+
+
+            // Add to the cache
+            lock (cache)
+            {
+                cache.Add(new CachedResult(query.SearchTerm, releases));
+            }
+
+            return releases.Select(s => (ReleaseInfo)s.Clone()).ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+    }
+}

src/Jackett/Indexers/BeyondHD.cs

@@ -0,0 +1,180 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class BeyondHD : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "BeyondHD"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "Without BeyondHD, your HDTV is just a TV"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        public bool IsConfigured { get; private set; }
+
+        const string BaseUrl = "https://beyondhd.me";
+        const string SearchUrl = BaseUrl + "/browse.php?c40=1&c44=1&c48=1&c89=1&c46=1&c45=1&searchin=title&incldead=0&search={0}";
+        const string DownloadUrl = BaseUrl + "/download.php?torrent={0}";
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public BeyondHD()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataCookie();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataCookie();
+            config.LoadValuesFromJson(configJson);
+
+            var jsonCookie = new JObject();
+            jsonCookie["cookie_header"] = config.CookieHeader;
+            cookies.FillFromJson(new Uri(BaseUrl), jsonCookie);
+
+            var responseContent = await client.GetStringAsync(BaseUrl);
+
+            if (!responseContent.Contains("logout.php"))
+            {
+                CQ dom = responseContent;
+                throw new ExceptionWithConfigData("Invalid cookie header", (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                cookies.DumpToJson(SiteLink, configSaveData);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
+                var results = await client.GetStringAsync(episodeSearchUrl);
+
+                try
+                {
+                    CQ dom = results;
+                    var rows = dom["table.torrenttable > tbody > tr.browse_color"];
+                    foreach (var row in rows)
+                    {
+                        var release = new ReleaseInfo();
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+
+                        var qRow = row.Cq();
+
+                        var qLink = row.ChildElements.ElementAt(2).FirstChild.Cq();
+                        release.Link = new Uri(BaseUrl + "/" + qLink.Attr("href"));
+                        var torrentID = qLink.Attr("href").Split('=').Last();
+
+                        var descCol = row.ChildElements.ElementAt(3);
+                        var qCommentLink = descCol.FirstChild.Cq();
+                        release.Title = qCommentLink.Text();
+                        release.Description = release.Title;
+                        release.Comments = new Uri(BaseUrl + "/" + qCommentLink.Attr("href"));
+                        release.Guid = release.Comments;
+
+                        var dateStr = descCol.ChildElements.Last().Cq().Text().Split('|').Last().ToLowerInvariant().Replace("ago.", "").Trim();
+                        var dateParts = dateStr.Split(new char[] { ' ', ' ' }, StringSplitOptions.RemoveEmptyEntries);
+                        var timeSpan = TimeSpan.Zero;
+                        for (var i = 0; i < dateParts.Length / 2; i++)
+                        {
+                            var timeVal = ParseUtil.CoerceInt(dateParts[i * 2]);
+                            var timeUnit = dateParts[i * 2 + 1];
+                            if (timeUnit.Contains("year"))
+                                timeSpan += TimeSpan.FromDays(365 * timeVal);
+                            else if (timeUnit.Contains("month"))
+                                timeSpan += TimeSpan.FromDays(30 * timeVal);
+                            else if (timeUnit.Contains("day"))
+                                timeSpan += TimeSpan.FromDays(timeVal);
+                            else if (timeUnit.Contains("hour"))
+                                timeSpan += TimeSpan.FromHours(timeVal);
+                            else if (timeUnit.Contains("min"))
+                                timeSpan += TimeSpan.FromMinutes(timeVal);
+                        }
+                        release.PublishDate = DateTime.SpecifyKind(DateTime.Now - timeSpan, DateTimeKind.Local);
+
+                        var sizeEl = row.ChildElements.ElementAt(7);
+                        var sizeVal = ParseUtil.CoerceFloat(sizeEl.ChildNodes.First().NodeValue);
+                        var sizeUnit = sizeEl.ChildNodes.Last().NodeValue;
+
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+
+                        release.Seeders = ParseUtil.CoerceInt(row.ChildElements.ElementAt(9).Cq().Text());
+                        release.Peers = ParseUtil.CoerceInt(row.ChildElements.ElementAt(10).Cq().Text()) + release.Seeders;
+
+                        releases.Add(release);
+
+                    }
+                }
+
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+    }
+}

src/Jackett/Indexers/BitHdtv.cs

@@ -12,139 +12,159 @@ using System.Web;
 
 namespace Jackett.Indexers
 {
-	public class BitHdtv : IndexerInterface
-	{
-		public string DisplayName {
-			get { return "BIT-HDTV"; }
-		}
+    public class BitHdtv : IndexerInterface
+    {
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
-		public string DisplayDescription {
-			get { return "Home of high definition invites"; }
-		}
+        public string DisplayName
+        {
+            get { return "BIT-HDTV"; }
+        }
 
-		public Uri SiteLink {
-			get { return new Uri (BaseUrl); }
-		}
+        public string DisplayDescription
+        {
+            get { return "Home of high definition invites"; }
+        }
 
-		static string BaseUrl = "https://www.bit-hdtv.com";
-		static string LoginUrl = BaseUrl + "/takelogin.php";
-		static string SearchUrl = BaseUrl + "/torrents.php?cat=0&search=";
-		static string DownloadUrl = BaseUrl + "/download.php?/{0}/dl.torrent";
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
 
-		CookieContainer cookies;
-		HttpClientHandler handler;
-		HttpClient client;
+        static string BaseUrl = "https://www.bit-hdtv.com";
+        static string LoginUrl = BaseUrl + "/takelogin.php";
+        static string SearchUrl = BaseUrl + "/torrents.php?cat=0&search=";
+        static string DownloadUrl = BaseUrl + "/download.php?/{0}/dl.torrent";
 
-		public BitHdtv ()
-		{
-			IsConfigured = false;
-			cookies = new CookieContainer ();
-			handler = new HttpClientHandler {
-				CookieContainer = cookies,
-				AllowAutoRedirect = true,
-				UseCookies = true,
-			};
-			client = new HttpClient (handler);
-		}
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
 
-		public Task<ConfigurationData> GetConfigurationForSetup ()
-		{
-			var config = new ConfigurationDataBasicLogin ();
-			return Task.FromResult<ConfigurationData> (config);
-		}
+        public BitHdtv()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
 
-		public async Task ApplyConfiguration (JToken configJson)
-		{
-			var config = new ConfigurationDataBasicLogin ();
-			config.LoadValuesFromJson (configJson);
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
 
-			var pairs = new Dictionary<string, string> {
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
 				{ "username", config.Username.Value },
 				{ "password", config.Password.Value }
 			};
 
-			var content = new FormUrlEncodedContent (pairs);
+            var content = new FormUrlEncodedContent(pairs);
 
-			var response = await client.PostAsync (LoginUrl, content);
-			var responseContent = await response.Content.ReadAsStringAsync ();
+            var response = await client.PostAsync(LoginUrl, content);
+            var responseContent = await response.Content.ReadAsStringAsync();
 
-			if (!responseContent.Contains ("logout.php")) {
-				CQ dom = responseContent;
-				var messageEl = dom ["table.detail td.text"].Last ();
-				messageEl.Children ("a").Remove ();
-				messageEl.Children ("style").Remove ();
-				var errorMessage = messageEl.Text ().Trim ();
-				throw new ExceptionWithConfigData (errorMessage, (ConfigurationData)config);
-			} else {
-				var configSaveData = new JObject ();
-				configSaveData ["cookies"] = cookies.ToJson (SiteLink);
+            if (!responseContent.Contains("logout.php"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom["table.detail td.text"].Last();
+                messageEl.Children("a").Remove();
+                messageEl.Children("style").Remove();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                cookies.DumpToJson(SiteLink, configSaveData);
 
-				if (OnSaveConfigurationRequested != null)
-					OnSaveConfigurationRequested (this, configSaveData);
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
 
-				IsConfigured = true;
-			}
-		}
+                IsConfigured = true;
+            }
+        }
 
-		public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
 
-		public bool IsConfigured { get; private set; }
+        public bool IsConfigured { get; private set; }
 
-		public void LoadFromSavedConfiguration (JToken jsonConfig)
-		{
-			cookies.FillFromJson (new Uri (BaseUrl), (JArray)jsonConfig ["cookies"]);
-			IsConfigured = true;
-		}
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            IsConfigured = true;
+        }
 
-		public async Task<ReleaseInfo[]> PerformQuery (TorznabQuery query)
-		{
-			List<ReleaseInfo> releases = new List<ReleaseInfo> ();
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = SearchUrl + HttpUtility.UrlEncode(searchString);
+                var results = await client.GetStringAsync(episodeSearchUrl);
+                try
+                {
+                    CQ dom = results;
+                    dom["#needseed"].Remove();
+                    var rows = dom["table[width='750'] > tbody"].Children();
+                    foreach (var row in rows.Skip(1))
+                    {
+
+                        var release = new ReleaseInfo();
+
+                        var qRow = row.Cq();
+                        var qLink = qRow.Children().ElementAt(2).Cq().Children("a").First();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qLink.Attr("title");
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + qLink.Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(string.Format(DownloadUrl, qLink.Attr("href").Split('=')[1]));
+
+                        var dateString = qRow.Children().ElementAt(5).Cq().Text().Trim();
+                        var pubDate = DateTime.ParseExact(dateString, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
+                        release.PublishDate = DateTime.SpecifyKind(pubDate, DateTimeKind.Local);
+
+                        var sizeCol = qRow.Children().ElementAt(6);
+                        var sizeVal = sizeCol.ChildNodes[0].NodeValue;
+                        var sizeUnit = sizeCol.ChildNodes[2].NodeValue;
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, ParseUtil.CoerceFloat(sizeVal));
+
+                        release.Seeders = ParseUtil.CoerceInt(qRow.Children().ElementAt(8).Cq().Text().Trim());
+                        release.Peers = ParseUtil.CoerceInt(qRow.Children().ElementAt(9).Cq().Text().Trim()) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
 
 
-			foreach (var title in query.ShowTitles ?? new string[] { string.Empty }) {
-				var searchString = title + " " + query.GetEpisodeSearchString ();
-				var episodeSearchUrl = SearchUrl + HttpUtility.UrlEncode (searchString);
-				var results = await client.GetStringAsync (episodeSearchUrl);
-				CQ dom = results;
-				dom ["#needseed"].Remove ();
-				var rows = dom ["table[width='750'] > tbody"].Children ();
-				foreach (var row in rows.Skip(1)) {
-
-					var release = new ReleaseInfo ();
-
-					var qRow = row.Cq ();
-					var qLink = qRow.Children ().ElementAt (2).Cq ().Children ("a").First ();
-
-					release.MinimumRatio = 1;
-					release.MinimumSeedTime = 172800;
-					release.Title = qLink.Attr ("title");
-					release.Description = release.Title;
-					release.Guid = new Uri (BaseUrl + qLink.Attr ("href"));
-					release.Comments = release.Guid;
-					release.Link = new Uri (string.Format (DownloadUrl, qLink.Attr ("href").Split ('=') [1]));
-
-					var dateString = qRow.Children ().ElementAt (5).Cq ().Text ().Trim ();
-					var pubDate = DateTime.ParseExact (dateString, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
-					release.PublishDate = pubDate;
-
-					var sizeCol = qRow.Children ().ElementAt (6);
-					var sizeVal = sizeCol.ChildNodes [0].NodeValue;
-					var sizeUnit = sizeCol.ChildNodes [2].NodeValue;
-					release.Size = ReleaseInfo.GetBytes (sizeUnit, float.Parse (sizeVal));
-
-					release.Seeders = int.Parse (qRow.Children ().ElementAt (8).Cq ().Text ().Trim ());
-					release.Peers = int.Parse (qRow.Children ().ElementAt (9).Cq ().Text ().Trim ()) + release.Seeders;
-
-					releases.Add (release);
-				}
-			}
-
-			return releases.ToArray ();
-		}
-
-		public Task<byte[]> Download (Uri link)
-		{
-			return client.GetByteArrayAsync (link);
-		}
-	}
+    }
 }

src/Jackett/Indexers/BitMeTV.cs

@@ -50,6 +50,7 @@ namespace Jackett
         HttpClient client;
 
         public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         public BitMeTV()
         {
@@ -110,7 +111,7 @@ namespace Jackett
             else
             {
                 var configSaveData = new JObject();
-                configSaveData["cookies"] = cookies.ToJson(SiteLink);
+                cookies.DumpToJson(SiteLink, configSaveData);
 
                 if (OnSaveConfigurationRequested != null)
                     OnSaveConfigurationRequested(this, configSaveData);
@@ -121,7 +122,7 @@ namespace Jackett
 
         public void LoadFromSavedConfiguration(JToken jsonConfig)
         {
-            cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
             IsConfigured = true;
         }
 
@@ -136,46 +137,55 @@ namespace Jackett
                 var searchString = title + " " + query.GetEpisodeSearchString();
                 var episodeSearchUrl = string.Format("{0}?search={1}&cat=0", SearchUrl, HttpUtility.UrlEncode(searchString));
                 var results = await client.GetStringAsync(episodeSearchUrl);
-                CQ dom = results;
-
-                var table = dom["tbody > tr > .latest"].Parent().Parent();
-
-                foreach (var row in table.Children().Skip(1))
+                try
                 {
-                    var release = new ReleaseInfo();
+                    CQ dom = results;
 
-                    CQ qDetailsCol = row.ChildElements.ElementAt(1).Cq();
-                    CQ qLink = qDetailsCol.Children("a").First();
+                    var table = dom["tbody > tr > .latest"].Parent().Parent();
 
-                    release.MinimumRatio = 1;
-                    release.MinimumSeedTime = 172800;
-                    release.Comments = new Uri(BaseUrl + "/" + qLink.Attr("href"));
-                    release.Guid = release.Comments;
-                    release.Title = qLink.Attr("title");
-                    release.Description = release.Title;
+                    foreach (var row in table.Children().Skip(1))
+                    {
+                        var release = new ReleaseInfo();
 
-                    //"Tuesday, June 11th 2013 at 03:52:53 AM" to...
-                    //"Tuesday June 11 2013 03:52:53 AM"
-                    var timestamp = qDetailsCol.Children("font").Text().Trim() + " ";
-                    var timeParts = new List<string>(timestamp.Replace(" at", "").Replace(",", "").Split(' '));
-                    timeParts[2] = Regex.Replace(timeParts[2], "[^0-9.]", "");
-                    var formattedTimeString = string.Join(" ", timeParts.ToArray()).Trim();
-                    release.PublishDate = DateTime.ParseExact(formattedTimeString, "dddd MMMM d yyyy hh:mm:ss tt", CultureInfo.InvariantCulture);
+                        CQ qDetailsCol = row.ChildElements.ElementAt(1).Cq();
+                        CQ qLink = qDetailsCol.Children("a").First();
 
-                    release.Link = new Uri(BaseUrl + "/" + row.ChildElements.ElementAt(2).Cq().Children("a.index").Attr("href"));
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Comments = new Uri(BaseUrl + "/" + qLink.Attr("href"));
+                        release.Guid = release.Comments;
+                        release.Title = qLink.Attr("title");
+                        release.Description = release.Title;
 
-                    var sizeCol = row.ChildElements.ElementAt(6);
-                    var sizeVal = float.Parse(sizeCol.ChildNodes[0].NodeValue);
-                    var sizeUnit = sizeCol.ChildNodes[2].NodeValue;
-                    release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+                        //"Tuesday, June 11th 2013 at 03:52:53 AM" to...
+                        //"Tuesday June 11 2013 03:52:53 AM"
+                        var timestamp = qDetailsCol.Children("font").Text().Trim() + " ";
+                        var timeParts = new List<string>(timestamp.Replace(" at", "").Replace(",", "").Split(' '));
+                        timeParts[2] = Regex.Replace(timeParts[2], "[^0-9.]", "");
+                        var formattedTimeString = string.Join(" ", timeParts.ToArray()).Trim();
+                        var date = DateTime.ParseExact(formattedTimeString, "dddd MMMM d yyyy hh:mm:ss tt", CultureInfo.InvariantCulture);
+                        release.PublishDate = DateTime.SpecifyKind(date, DateTimeKind.Utc).ToLocalTime();
 
-                    release.Seeders = int.Parse(row.ChildElements.ElementAt(8).Cq().Text());
-                    release.Peers = int.Parse(row.ChildElements.ElementAt(9).Cq().Text()) + release.Seeders;
+                        release.Link = new Uri(BaseUrl + "/" + row.ChildElements.ElementAt(2).Cq().Children("a.index").Attr("href"));
 
-                    if (!release.Title.ToLower().Contains(title.ToLower()))
-                        continue;
+                        var sizeCol = row.ChildElements.ElementAt(6);
+                        var sizeVal = ParseUtil.CoerceFloat(sizeCol.ChildNodes[0].NodeValue);
+                        var sizeUnit = sizeCol.ChildNodes[2].NodeValue;
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
 
-                    releases.Add(release);
+                        release.Seeders = ParseUtil.CoerceInt(row.ChildElements.ElementAt(8).Cq().Text());
+                        release.Peers = ParseUtil.CoerceInt(row.ChildElements.ElementAt(9).Cq().Text()) + release.Seeders;
+
+                        //if (!release.Title.ToLower().Contains(title.ToLower()))
+                        //    continue;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
             }
 
@@ -187,5 +197,6 @@ namespace Jackett
         {
             return client.GetByteArrayAsync(link);
         }
+
     }
 }

src/Jackett/Indexers/Freshon.cs

@@ -14,168 +14,183 @@ using System.Web.UI.WebControls;
 
 namespace Jackett
 {
-	public class Freshon : IndexerInterface
-	{
+    public class Freshon : IndexerInterface
+    {
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
-		static string BaseUrl = "https://freshon.tv";
-		static string LoginUrl = BaseUrl + "/login.php";
-		static string LoginPostUrl = BaseUrl + "/login.php?action=makelogin";
-		static string SearchUrl = BaseUrl + "/browse.php";
+        static string BaseUrl = "https://freshon.tv";
+        static string LoginUrl = BaseUrl + "/login.php";
+        static string LoginPostUrl = BaseUrl + "/login.php?action=makelogin";
+        static string SearchUrl = BaseUrl + "/browse.php";
 
-		static string chromeUserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36";
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
 
-		CookieContainer cookies;
-		HttpClientHandler handler;
-		HttpClient client;
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
 
-		public bool IsConfigured { get; private set; }
+        public bool IsConfigured { get; private set; }
 
-		public string DisplayName { get { return "FreshOnTV"; } }
+        public string DisplayName { get { return "FreshOnTV"; } }
 
-		public string DisplayDescription { get { return "Our goal is to provide the latest stuff in the TV show domain"; } }
+        public string DisplayDescription { get { return "Our goal is to provide the latest stuff in the TV show domain"; } }
 
-		public Uri SiteLink { get { return new Uri (BaseUrl); } }
+        public Uri SiteLink { get { return new Uri(BaseUrl); } }
 
-		public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
 
-		public Freshon ()
-		{
-			IsConfigured = false;
-			cookies = new CookieContainer ();
-			handler = new HttpClientHandler {
-				CookieContainer = cookies,
-				AllowAutoRedirect = true,
-				UseCookies = true,
-			};
-			client = new HttpClient (handler);
-		}
+        public Freshon()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
 
-		public async Task<ConfigurationData> GetConfigurationForSetup ()
-		{
-			var request = CreateHttpRequest (new Uri (LoginUrl));
-			var response = await client.SendAsync (request);
-			await response.Content.ReadAsStreamAsync ();
-			var config = new ConfigurationDataBasicLogin ();
-			return config;
-		}
+        public async Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var request = CreateHttpRequest(new Uri(LoginUrl));
+            var response = await client.SendAsync(request);
+            await response.Content.ReadAsStreamAsync();
+            var config = new ConfigurationDataBasicLogin();
+            return config;
+        }
 
-		public async Task ApplyConfiguration (JToken configJson)
-		{
-			var config = new ConfigurationDataBasicLogin ();
-			config.LoadValuesFromJson (configJson);
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
 
-			var pairs = new Dictionary<string, string> {
+            var pairs = new Dictionary<string, string> {
 				{ "username", config.Username.Value },
 				{ "password", config.Password.Value }
 			};
 
-			var content = new FormUrlEncodedContent (pairs);
-			var message = CreateHttpRequest (new Uri (LoginPostUrl));
-			message.Method = HttpMethod.Post;
-			message.Content = content;
-			message.Headers.Referrer = new Uri (LoginUrl);
+            var content = new FormUrlEncodedContent(pairs);
+            var message = CreateHttpRequest(new Uri(LoginPostUrl));
+            message.Method = HttpMethod.Post;
+            message.Content = content;
+            message.Headers.Referrer = new Uri(LoginUrl);
 
-			var response = await client.SendAsync (message);
-			var responseContent = await response.Content.ReadAsStringAsync ();
+            var response = await client.SendAsync(message);
+            var responseContent = await response.Content.ReadAsStringAsync();
 
-			if (!responseContent.Contains ("/logout.php")) {
-				CQ dom = responseContent;
-				var messageEl = dom [".error_text"];
-				var errorMessage = messageEl.Text ().Trim ();
-				throw new ExceptionWithConfigData (errorMessage, (ConfigurationData)config);
-			} else {
-				var configSaveData = new JObject ();
-				configSaveData ["cookies"] = cookies.ToJson (SiteLink);
+            if (!responseContent.Contains("/logout.php"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom[".error_text"];
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                cookies.DumpToJson(SiteLink, configSaveData);
 
-				if (OnSaveConfigurationRequested != null)
-					OnSaveConfigurationRequested (this, configSaveData);
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
 
-				IsConfigured = true;
-			}
-		}
+                IsConfigured = true;
+            }
+        }
 
-		public void LoadFromSavedConfiguration (JToken jsonConfig)
-		{
-			cookies.FillFromJson (new Uri (BaseUrl), (JArray)jsonConfig ["cookies"]);
-			IsConfigured = true;
-		}
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            IsConfigured = true;
+        }
 
-		HttpRequestMessage CreateHttpRequest (Uri uri)
-		{
-			var message = new HttpRequestMessage ();
-			message.Method = HttpMethod.Get;
-			message.RequestUri = uri;
-			message.Headers.UserAgent.ParseAdd (chromeUserAgent);
-			return message;
-		}
+        HttpRequestMessage CreateHttpRequest(Uri uri)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Get;
+            message.RequestUri = uri;
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
+            return message;
+        }
 
-		public async Task<ReleaseInfo[]> PerformQuery (TorznabQuery query)
-		{
-			List<ReleaseInfo> releases = new List<ReleaseInfo> ();
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
 
-			foreach (var title in query.ShowTitles ?? new string[] { string.Empty }) {
-				string episodeSearchUrl;
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                string episodeSearchUrl;
 
-				if (string.IsNullOrEmpty (title))
-					episodeSearchUrl = SearchUrl;
-				else {
-					var searchString = title + " " + query.GetEpisodeSearchString ();
-					episodeSearchUrl = string.Format ("{0}?search={1}&cat=0", SearchUrl, HttpUtility.UrlEncode (searchString));
-				}
+                if (string.IsNullOrEmpty(title))
+                    episodeSearchUrl = SearchUrl;
+                else
+                {
+                    var searchString = title + " " + query.GetEpisodeSearchString();
+                    episodeSearchUrl = string.Format("{0}?search={1}&cat=0", SearchUrl, HttpUtility.UrlEncode(searchString));
+                }
 
-				var request = CreateHttpRequest (new Uri (episodeSearchUrl));
-				var response = await client.SendAsync (request);
-				var results = await response.Content.ReadAsStringAsync ();
+                var request = CreateHttpRequest(new Uri(episodeSearchUrl));
+                var response = await client.SendAsync(request);
+                var results = await response.Content.ReadAsStringAsync();
+                try
+                {
+                    CQ dom = results;
 
-				CQ dom = results;
+                    var rows = dom["#highlight > tbody > tr"];
 
-				var rows = dom ["#highlight > tbody > tr"];
+                    foreach (var row in rows.Skip(1))
+                    {
+                        var release = new ReleaseInfo();
 
-				foreach (var row in rows.Skip(1)) {
-					var release = new ReleaseInfo ();
+                        var qRow = row.Cq();
+                        var qLink = qRow.Find("a.torrent_name_link").First();
 
-					var qRow = row.Cq ();
-					var qLink = qRow.Find ("a.torrent_name_link").First ();
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qLink.Attr("title");
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + qLink.Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(BaseUrl + qRow.Find("td.table_links > a").First().Attr("href"));
 
-					release.MinimumRatio = 1;
-					release.MinimumSeedTime = 172800;
-					release.Title = qLink.Attr ("title");
-					release.Description = release.Title;
-					release.Guid = new Uri (BaseUrl + qLink.Attr ("href"));
-					release.Comments = release.Guid;
-					release.Link = new Uri (BaseUrl + qRow.Find ("td.table_links > a").First ().Attr ("href"));
+                        DateTime pubDate;
+                        var dateString = qRow.Find("td.table_added").Text().Trim();
+                        if (dateString.StartsWith("Today "))
+                            pubDate = (DateTime.UtcNow + TimeSpan.Parse(dateString.Split(' ')[1])).ToLocalTime();
+                        else if (dateString.StartsWith("Yesterday "))
+                            pubDate = (DateTime.UtcNow + TimeSpan.Parse(dateString.Split(' ')[1]) - TimeSpan.FromDays(1)).ToLocalTime();
+                        else
+                            pubDate = DateTime.ParseExact(dateString, "d-MMM-yyyy HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal).ToLocalTime();
+                        release.PublishDate = pubDate;
 
-					DateTime pubDate;
-					var dateString = qRow.Find ("td.table_added").Text ().Trim ();
-					if (dateString.StartsWith ("Today "))
-						pubDate = (DateTime.UtcNow + TimeSpan.Parse (dateString.Split (' ') [1])).ToLocalTime ();
-					else if (dateString.StartsWith ("Yesterday "))
-						pubDate = (DateTime.UtcNow + TimeSpan.Parse (dateString.Split (' ') [1]) - TimeSpan.FromDays (1)).ToLocalTime ();
-					else
-						pubDate = DateTime.ParseExact (dateString, "d-MMM-yyyy HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal).ToLocalTime ();
-					release.PublishDate = pubDate;
+                        release.Seeders = ParseUtil.CoerceInt(qRow.Find("td.table_seeders").Text().Trim());
+                        release.Peers = ParseUtil.CoerceInt(qRow.Find("td.table_leechers").Text().Trim()) + release.Seeders;
 
-					release.Seeders = int.Parse (qRow.Find ("td.table_seeders").Text ().Trim ());
-					release.Peers = int.Parse (qRow.Find ("td.table_leechers").Text ().Trim ()) + release.Seeders;
+                        var sizeCol = qRow.Find("td.table_size")[0];
+                        var sizeVal = ParseUtil.CoerceFloat(sizeCol.ChildNodes[0].NodeValue.Trim());
+                        var sizeUnit = sizeCol.ChildNodes[2].NodeValue.Trim();
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
 
-					var sizeCol = qRow.Find ("td.table_size") [0];
-					var sizeVal = float.Parse (sizeCol.ChildNodes [0].NodeValue.Trim ());
-					var sizeUnit = sizeCol.ChildNodes [2].NodeValue.Trim ();
-					release.Size = ReleaseInfo.GetBytes (sizeUnit, sizeVal);
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
 
-					releases.Add (release);
-				}
-			}
+            return releases.ToArray();
+        }
 
-			return releases.ToArray ();
-		}
-
-		public async Task<byte[]> Download (Uri link)
-		{
-			var request = CreateHttpRequest (link);
-			var response = await client.SendAsync (request);
-			var bytes = await response.Content.ReadAsByteArrayAsync ();
-			return bytes;
-		}
-	}
+        public async Task<byte[]> Download(Uri link)
+        {
+            var request = CreateHttpRequest(link);
+            var response = await client.SendAsync(request);
+            var bytes = await response.Content.ReadAsByteArrayAsync();
+            return bytes;
+        }
+    }
 }

src/Jackett/Indexers/HDTorrents.cs

@@ -0,0 +1,243 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class HDTorrents : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        const string DefaultUrl = "http://hd-torrents.org";
+        string BaseUrl = DefaultUrl;
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
+        private string SearchUrl = DefaultUrl + "/torrents.php?search={0}&active=1&options=0&category%5B%5D=59&category%5B%5D=60&category%5B%5D=30&category%5B%5D=38&page={1}";
+        private static string LoginUrl = DefaultUrl + "/login.php";
+        private static string LoginPostUrl = DefaultUrl + "/login.php?returnto=index.php";
+        private const int MAXPAGES = 3;
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public HDTorrents()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public string DisplayName
+        {
+            get { return "HD-Torrents"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "HD-Torrents is a private torrent website with HD torrents and strict rules on their content."; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(DefaultUrl); }
+        }
+
+        public bool IsConfigured
+        {
+            get;
+            private set;
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        HttpRequestMessage CreateHttpRequest(string url)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Get;
+            message.RequestUri = new Uri(url);
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
+            return message;
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var startMessage = CreateHttpRequest(LoginUrl);
+            var results = await (await client.SendAsync(startMessage)).Content.ReadAsStringAsync();
+
+
+            var pairs = new Dictionary<string, string> {
+				{ "uid", config.Username.Value },
+				{ "pwd", config.Password.Value }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            var loginRequest = CreateHttpRequest(LoginUrl);
+            loginRequest.Method = HttpMethod.Post;
+            loginRequest.Content = content;
+            loginRequest.Headers.Referrer = new Uri("https://hd-torrents.org/torrents.php");
+
+            var response = await client.SendAsync(loginRequest);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("If your browser doesn't have javascript enabled"))
+            {
+                var errorMessage = "Couldn't login";
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                cookies.DumpToJson(SiteLink, configSaveData);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(SiteLink, jsonConfig);
+            IsConfigured = true;
+        }
+
+        async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query, string baseUrl)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+            List<string> searchurls = new List<string>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                for (int page = 0; page < MAXPAGES; page++)
+                    searchurls.Add(string.Format(SearchUrl, HttpUtility.UrlEncode(searchString.Trim()), page));
+            }
+
+            foreach (string SearchUrl in searchurls)
+            {
+                var results = await client.GetStringAsync(SearchUrl);
+                try
+                {
+                    CQ dom = results;
+                    ReleaseInfo release;
+
+                    int rowCount = 0;
+                    var rows = dom[".mainblockcontenttt > tbody > tr"];
+                    foreach (var row in rows)
+                    {
+                        CQ qRow = row.Cq();
+                        if (rowCount < 2 || qRow.Children().Count() != 12) //skip 2 rows because there's an empty row & a title/sort row
+                        {
+                            rowCount++;
+                            continue;
+                        }
+
+                        release = new ReleaseInfo();
+                        long? size;
+
+                        release.Title = qRow.Find("td.mainblockcontent b a").Text();
+                        release.Description = release.Title;
+
+                        if (0 != qRow.Find("td.mainblockcontent u").Length)
+                        {
+                            var imdbStr = qRow.Find("td.mainblockcontent u").Parent().First().Attr("href").Replace("http://www.imdb.com/title/tt", "").Replace("/", "");
+                            long imdb;
+                            if (ParseUtil.TryCoerceLong(imdbStr, out imdb))
+                            {
+                                release.Imdb = imdb;
+                            }
+                        }
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+
+                        release.MagnetUri = new Uri(DefaultUrl + "/" + qRow.Find("td.mainblockcontent").Get(3).FirstChild.GetAttribute("href"));
+
+                        int seeders, peers;
+                        if (ParseUtil.TryCoerceInt(qRow.Find("td").Get(9).FirstChild.FirstChild.InnerText, out seeders))
+                        {
+                            release.Seeders = seeders;
+                            if (ParseUtil.TryCoerceInt(qRow.Find("td").Get(10).FirstChild.FirstChild.InnerText, out peers))
+                            {
+                                release.Peers = peers + release.Seeders;
+                            }
+                        }
+
+                        string fullSize = qRow.Find("td.mainblockcontent").Get(6).InnerText;
+                        string[] sizeSplit = fullSize.Split(' ');
+                        switch (sizeSplit[1].ToLower())
+                        {
+                            case "kb":
+                                size = ReleaseInfo.BytesFromKB(ParseUtil.CoerceFloat(sizeSplit[0]));
+                                break;
+                            case "mb":
+                                size = ReleaseInfo.BytesFromMB(ParseUtil.CoerceFloat(sizeSplit[0]));
+                                break;
+                            case "gb":
+                                size = ReleaseInfo.BytesFromGB(ParseUtil.CoerceFloat(sizeSplit[0]));
+                                break;
+                            default:
+                                size = null;
+                                break;
+                        }
+                        release.Size = size;
+
+                        release.Link = new Uri(DefaultUrl + "/" + qRow.Find("td.mainblockcontent b a").Attr("href"));
+                        release.Guid = release.Link;
+
+                        string[] dateSplit = qRow.Find("td.mainblockcontent").Get(5).InnerHTML.Split(',');
+                        string dateString = dateSplit[1].Substring(0, dateSplit[1].IndexOf('>'));
+                        release.PublishDate = DateTime.Parse(dateString, CultureInfo.InvariantCulture);
+
+                        release.Comments = new Uri(DefaultUrl + "/" + qRow.Find("td.mainblockcontent").Get(2).FirstChild.GetAttribute("href"));
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+
+
+            return releases.ToArray();
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            return await PerformQuery(query, BaseUrl);
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/Jackett/Indexers/IPTorrents.cs

@@ -2,6 +2,7 @@
 using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
@@ -11,181 +12,198 @@ using System.Web;
 
 namespace Jackett.Indexers
 {
-	public class IPTorrents : IndexerInterface
-	{
+    public class IPTorrents : IndexerInterface
+    {
 
-		public event Action<IndexerInterface, Newtonsoft.Json.Linq.JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
-		public string DisplayName { get { return "IPTorrents"; } }
+        public string DisplayName { get { return "IPTorrents"; } }
 
-		public string DisplayDescription { get { return "Always a step ahead"; } }
+        public string DisplayDescription { get { return "Always a step ahead"; } }
 
-		public Uri SiteLink { get { return new Uri (BaseUrl); } }
+        public Uri SiteLink { get { return new Uri(BaseUrl); } }
 
-		public bool IsConfigured { get; private set; }
+        public bool IsConfigured { get; private set; }
 
-		static string chromeUserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36";
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
+
+        static string BaseUrl = "https://iptorrents.com";
+
+        string SearchUrl = BaseUrl + "/t?q=";
 
 
-		static string BaseUrl = "https://iptorrents.com";
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
 
-		string SearchUrl = BaseUrl + "/t?q=";
+        public IPTorrents()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
 
+        public async Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            await client.GetAsync(new Uri(BaseUrl));
+            var config = new ConfigurationDataBasicLogin();
+            return (ConfigurationData)config;
+        }
 
-		CookieContainer cookies;
-		HttpClientHandler handler;
-		HttpClient client;
+        public async Task ApplyConfiguration(JToken configJson)
+        {
 
-		public IPTorrents ()
-		{
-			IsConfigured = false;
-			cookies = new CookieContainer ();
-			handler = new HttpClientHandler {
-				CookieContainer = cookies,
-				AllowAutoRedirect = true,
-				UseCookies = true,
-			};
-			client = new HttpClient (handler);
-		}
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
 
-		public async Task<ConfigurationData> GetConfigurationForSetup ()
-		{
-			await client.GetAsync (new Uri (BaseUrl));
-			var config = new ConfigurationDataBasicLogin ();
-			return (ConfigurationData)config;
-		}
-
-		public async Task ApplyConfiguration (JToken configJson)
-		{
-
-			var config = new ConfigurationDataBasicLogin ();
-			config.LoadValuesFromJson (configJson);
-
-			var pairs = new Dictionary<string, string> {
+            var pairs = new Dictionary<string, string> {
 				{ "username", config.Username.Value },
 				{ "password", config.Password.Value }
 			};
 
-			var content = new FormUrlEncodedContent (pairs);
-			var message = new HttpRequestMessage ();
-			message.Method = HttpMethod.Post;
-			message.Content = content;
-			message.RequestUri = new Uri (BaseUrl);
-			message.Headers.Referrer = new Uri (BaseUrl);
-			message.Headers.UserAgent.ParseAdd (chromeUserAgent);
+            var content = new FormUrlEncodedContent(pairs);
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Post;
+            message.Content = content;
+            message.RequestUri = new Uri(BaseUrl);
+            message.Headers.Referrer = new Uri(BaseUrl);
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
 
-			var response = await client.SendAsync (message);
-			var responseContent = await response.Content.ReadAsStringAsync ();
+            var response = await client.SendAsync(message);
+            var responseContent = await response.Content.ReadAsStringAsync();
 
-			if (!responseContent.Contains ("/my.php")) {
-				CQ dom = responseContent;
-				var messageEl = dom ["body > div"].First ();
-				var errorMessage = messageEl.Text ().Trim ();
-				throw new ExceptionWithConfigData (errorMessage, (ConfigurationData)config);
-			} else {
-				var configSaveData = new JObject ();
-				configSaveData ["cookies"] = cookies.ToJson (SiteLink);
+            if (!responseContent.Contains("/my.php"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom["body > div"].First();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                cookies.DumpToJson(SiteLink, configSaveData);
 
-				if (OnSaveConfigurationRequested != null)
-					OnSaveConfigurationRequested (this, configSaveData);
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
 
-				IsConfigured = true;
-			}
+                IsConfigured = true;
+            }
 
-		}
+        }
 
-		HttpRequestMessage CreateHttpRequest (Uri uri)
-		{
-			var message = new HttpRequestMessage ();
-			message.Method = HttpMethod.Get;
-			message.RequestUri = uri;
-			message.Headers.UserAgent.ParseAdd (chromeUserAgent);
-			return message;
-		}
+        HttpRequestMessage CreateHttpRequest(Uri uri)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Get;
+            message.RequestUri = uri;
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
+            return message;
+        }
 
-		public void LoadFromSavedConfiguration (Newtonsoft.Json.Linq.JToken jsonConfig)
-		{
-			cookies.FillFromJson (new Uri (BaseUrl), (JArray)jsonConfig ["cookies"]);
-			IsConfigured = true;
-		}
+        public void LoadFromSavedConfiguration(Newtonsoft.Json.Linq.JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            IsConfigured = true;
+        }
 
-		public async Task<ReleaseInfo[]> PerformQuery (TorznabQuery query)
-		{
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
 
-			List<ReleaseInfo> releases = new List<ReleaseInfo> ();
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
 
 
-			foreach (var title in query.ShowTitles ?? new string[] { string.Empty }) {
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
 
-				var searchString = title + " " + query.GetEpisodeSearchString ();
-				var episodeSearchUrl = SearchUrl + HttpUtility.UrlEncode (searchString);
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = SearchUrl + HttpUtility.UrlEncode(searchString);
 
-				var request = CreateHttpRequest (new Uri (episodeSearchUrl));
-				var response = await client.SendAsync (request);
-				var results = await response.Content.ReadAsStringAsync ();
+                var request = CreateHttpRequest(new Uri(episodeSearchUrl));
+                var response = await client.SendAsync(request);
+                var results = await response.Content.ReadAsStringAsync();
 
-				CQ dom = results;
+                try
+                {
+                    CQ dom = results;
 
-				var rows = dom ["table.torrents > tbody > tr"];
-				foreach (var row in rows.Skip(1)) {
-					var release = new ReleaseInfo ();
+                    var rows = dom["table.torrents > tbody > tr"];
+                    foreach (var row in rows.Skip(1))
+                    {
+                        var release = new ReleaseInfo();
 
-					var qRow = row.Cq ();
+                        var qRow = row.Cq();
 
-					var qTitleLink = qRow.Find ("a.t_title").First ();
-					release.Title = qTitleLink.Text ().Trim ();
-					release.Description = release.Title;
-					release.Guid = new Uri (BaseUrl + qTitleLink.Attr ("href"));
-					release.Comments = release.Guid;
+                        var qTitleLink = qRow.Find("a.t_title").First();
+                        release.Title = qTitleLink.Text().Trim();
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + qTitleLink.Attr("href"));
+                        release.Comments = release.Guid;
 
-					DateTime pubDate;
-					var descString = qRow.Find (".t_ctime").Text ();
-					var dateString = descString.Split ('|').Last ().Trim ();
-					dateString = dateString.Split (new string[] { " by " }, StringSplitOptions.None) [0];
-					var dateValue = float.Parse (dateString.Split (' ') [0]);
-					var dateUnit = dateString.Split (' ') [1];
-					if (dateUnit.Contains ("minute"))
-						pubDate = DateTime.Now - TimeSpan.FromMinutes (dateValue);
-					else if (dateUnit.Contains ("hour"))
-						pubDate = DateTime.Now - TimeSpan.FromHours (dateValue);
-					else if (dateUnit.Contains ("day"))
-						pubDate = DateTime.Now - TimeSpan.FromDays (dateValue);
-					else if (dateUnit.Contains ("week"))
-						pubDate = DateTime.Now - TimeSpan.FromDays (7 * dateValue);
-					else if (dateUnit.Contains ("month"))
-						pubDate = DateTime.Now - TimeSpan.FromDays (30 * dateValue);
-					else if (dateUnit.Contains ("year"))
-						pubDate = DateTime.Now - TimeSpan.FromDays (365 * dateValue);
-					else
-						pubDate = DateTime.MinValue;
-					release.PublishDate = pubDate;
+                        DateTime pubDate;
+                        var descString = qRow.Find(".t_ctime").Text();
+                        var dateString = descString.Split('|').Last().Trim();
+                        dateString = dateString.Split(new string[] { " by " }, StringSplitOptions.None)[0];
+                        var dateValue = ParseUtil.CoerceFloat(dateString.Split(' ')[0]);
+                        var dateUnit = dateString.Split(' ')[1];
+                        if (dateUnit.Contains("minute"))
+                            pubDate = DateTime.Now - TimeSpan.FromMinutes(dateValue);
+                        else if (dateUnit.Contains("hour"))
+                            pubDate = DateTime.Now - TimeSpan.FromHours(dateValue);
+                        else if (dateUnit.Contains("day"))
+                            pubDate = DateTime.Now - TimeSpan.FromDays(dateValue);
+                        else if (dateUnit.Contains("week"))
+                            pubDate = DateTime.Now - TimeSpan.FromDays(7 * dateValue);
+                        else if (dateUnit.Contains("month"))
+                            pubDate = DateTime.Now - TimeSpan.FromDays(30 * dateValue);
+                        else if (dateUnit.Contains("year"))
+                            pubDate = DateTime.Now - TimeSpan.FromDays(365 * dateValue);
+                        else
+                            pubDate = DateTime.MinValue;
+                        release.PublishDate = pubDate;
 
-					var qLink = row.ChildElements.ElementAt (3).Cq ().Children ("a");
-					release.Link = new Uri (BaseUrl + qLink.Attr ("href"));
+                        var qLink = row.ChildElements.ElementAt(3).Cq().Children("a");
+                        release.Link = new Uri(BaseUrl + qLink.Attr("href"));
 
-					var sizeStr = row.ChildElements.ElementAt (5).Cq ().Text ().Trim ();
-					var sizeVal = float.Parse (sizeStr.Split (' ') [0]);
-					var sizeUnit = sizeStr.Split (' ') [1];
-					release.Size = ReleaseInfo.GetBytes (sizeUnit, sizeVal);
+                        var sizeStr = row.ChildElements.ElementAt(5).Cq().Text().Trim();
+                        var sizeVal = ParseUtil.CoerceFloat(sizeStr.Split(' ')[0]);
+                        var sizeUnit = sizeStr.Split(' ')[1];
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
 
-					release.Seeders = int.Parse (qRow.Find (".t_seeders").Text ().Trim ());
-					release.Peers = int.Parse (qRow.Find (".t_leechers").Text ().Trim ()) + release.Seeders;
+                        release.Seeders = ParseUtil.CoerceInt(qRow.Find(".t_seeders").Text().Trim());
+                        release.Peers = ParseUtil.CoerceInt(qRow.Find(".t_leechers").Text().Trim()) + release.Seeders;
 
-					releases.Add (release);
-				}
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
 
-			}
+            }
 
-			return releases.ToArray ();
+            return releases.ToArray();
 
-		}
+        }
 
-		public async Task<byte[]> Download (Uri link)
-		{
-			var request = CreateHttpRequest (link);
-			var response = await client.SendAsync (request);
-			var bytes = await response.Content.ReadAsByteArrayAsync ();
-			return bytes;
-		}
-	}
+        public async Task<byte[]> Download(Uri link)
+        {
+            var request = CreateHttpRequest(link);
+            var response = await client.SendAsync(request);
+            var bytes = await response.Content.ReadAsByteArrayAsync();
+            return bytes;
+        }
+
+
+
+    }
 }

src/Jackett/Indexers/MoreThanTV.cs

@@ -2,6 +2,7 @@
 using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
@@ -30,6 +31,7 @@ namespace Jackett.Indexers
 
 
         public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         public bool IsConfigured { get; private set; }
 
@@ -48,6 +50,7 @@ namespace Jackett.Indexers
         HttpClient client;
 
         string cookieHeader;
+        int retries = 3;
 
         public MoreThanTV()
         {
@@ -83,14 +86,16 @@ namespace Jackett.Indexers
             var content = new FormUrlEncodedContent(pairs);
 
             string responseContent;
-            JArray cookieJArray;
+
+            var configSaveData = new JObject();
 
             if (Program.IsWindows)
             {
                 // If Windows use .net http
                 var response = await client.PostAsync(LoginUrl, content);
                 responseContent = await response.Content.ReadAsStringAsync();
-                cookieJArray = cookies.ToJson(SiteLink);
+                cookies.DumpToJson(SiteLink, configSaveData);
+
             }
             else
             {
@@ -98,7 +103,7 @@ namespace Jackett.Indexers
                 var response = await CurlHelper.PostAsync(LoginUrl, pairs);
                 responseContent = Encoding.UTF8.GetString(response.Content);
                 cookieHeader = response.CookieHeader;
-                cookieJArray = new JArray(response.CookiesFlat);
+                configSaveData["cookie_header"] = cookieHeader;
             }
 
             if (!responseContent.Contains("logout.php?"))
@@ -111,9 +116,6 @@ namespace Jackett.Indexers
             }
             else
             {
-
-                var configSaveData = new JObject();
-                configSaveData["cookies"] = cookieJArray;
                 if (OnSaveConfigurationRequested != null)
                     OnSaveConfigurationRequested(this, configSaveData);
 
@@ -123,12 +125,12 @@ namespace Jackett.Indexers
 
         public void LoadFromSavedConfiguration(JToken jsonConfig)
         {
-            cookies.FillFromJson(SiteLink, (JArray)jsonConfig["cookies"]);
+            cookies.FillFromJson(SiteLink, jsonConfig);
             cookieHeader = cookies.GetCookieHeader(SiteLink);
             IsConfigured = true;
         }
 
-        void FillReleaseInfoFromJson(ReleaseInfo release, JObject r)
+        static void FillReleaseInfoFromJson(ReleaseInfo release, JObject r)
         {
             var id = r["torrentId"];
             release.Size = (long)r["size"];
@@ -152,43 +154,57 @@ namespace Jackett.Indexers
                 string results;
                 if (Program.IsWindows)
                 {
-                    results = await client.GetStringAsync(episodeSearchUrl);
+                    results = await client.GetStringAsync(episodeSearchUrl, retries);
                 }
                 else
                 {
                     var response = await CurlHelper.GetAsync(episodeSearchUrl, cookieHeader);
                     results = Encoding.UTF8.GetString(response.Content);
                 }
-
-                var json = JObject.Parse(results);
-                foreach (JObject r in json["response"]["results"])
+                try
                 {
 
-                    var pubDate = UnixTimestampToDateTime(double.Parse((string)r["groupTime"]));
-                    var groupName = (string)r["groupName"];
-
-                    if (r["torrents"] is JArray)
+                    var json = JObject.Parse(results);
+                    foreach (JObject r in json["response"]["results"])
                     {
-                        foreach (JObject t in r["torrents"])
+                        DateTime pubDate = DateTime.MinValue;
+                        double dateNum;
+                        if (double.TryParse((string)r["groupTime"], out dateNum))
+                        {
+                            pubDate = UnixTimestampToDateTime(dateNum);
+                            pubDate = DateTime.SpecifyKind(pubDate, DateTimeKind.Utc).ToLocalTime();
+                        }
+
+                        var groupName = (string)r["groupName"];
+
+                        if (r["torrents"] is JArray)
+                        {
+                            foreach (JObject t in r["torrents"])
+                            {
+                                var release = new ReleaseInfo();
+                                release.PublishDate = pubDate;
+                                release.Title = groupName;
+                                release.Description = groupName;
+                                FillReleaseInfoFromJson(release, t);
+                                releases.Add(release);
+                            }
+                        }
+                        else
                         {
                             var release = new ReleaseInfo();
                             release.PublishDate = pubDate;
                             release.Title = groupName;
                             release.Description = groupName;
-                            FillReleaseInfoFromJson(release, t);
+                            FillReleaseInfoFromJson(release, r);
                             releases.Add(release);
                         }
-                    }
-                    else
-                    {
-                        var release = new ReleaseInfo();
-                        release.PublishDate = pubDate;
-                        release.Title = groupName;
-                        release.Description = groupName;
-                        FillReleaseInfoFromJson(release, r);
-                        releases.Add(release);
-                    }
 
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
             }
 

src/Jackett/Indexers/Rarbg.cs

@@ -0,0 +1,166 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett.Indexers
+{
+    public class Rarbg : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "RARBG"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return DisplayName; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri("https://rarbg.com"); }
+        }
+
+        public bool IsConfigured { get; private set; }
+
+        const string DefaultUrl = "http://torrentapi.org";
+
+        const string TokenUrl = "/pubapi.php?get_token=get_token&format=json";
+        const string SearchTVRageUrl = "/pubapi.php?mode=search&search_tvrage={0}&token={1}&format=json&min_seeders=1";
+        const string SearchQueryUrl = "/pubapi.php?mode=search&search_string={0}&token={1}&format=json&min_seeders=1";
+
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
+
+        string BaseUrl;
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public Rarbg()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            config.LoadValuesFromJson(configJson);
+
+            var formattedUrl = config.GetFormattedHostUrl();
+            var token = await GetToken(formattedUrl);
+            /*var releases = await PerformQuery(new TorznabQuery(), formattedUrl);
+            if (releases.Length == 0)
+                throw new Exception("Could not find releases from this URL");*/
+
+            BaseUrl = formattedUrl;
+
+            var configSaveData = new JObject();
+            configSaveData["base_url"] = BaseUrl;
+
+            if (OnSaveConfigurationRequested != null)
+                OnSaveConfigurationRequested(this, configSaveData);
+
+            IsConfigured = true;
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            BaseUrl = (string)jsonConfig["base_url"];
+            IsConfigured = true;
+        }
+
+        HttpRequestMessage CreateHttpRequest(string uri)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Get;
+            message.RequestUri = new Uri(uri);
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
+            return message;
+        }
+
+        async Task<string> GetToken(string url)
+        {
+            var request = CreateHttpRequest(url + TokenUrl);
+            var response = await client.SendAsync(request);
+            var result = await response.Content.ReadAsStringAsync();
+            JObject obj = JObject.Parse(result);
+            return (string)obj["token"];
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            return await PerformQuery(query, BaseUrl);
+        }
+
+        async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query, string baseUrl)
+        {
+
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            string token = await GetToken(baseUrl);
+            string searchUrl;
+            if (query.RageID != 0)
+                searchUrl = string.Format(baseUrl + SearchTVRageUrl, query.RageID, token);
+            else
+                searchUrl = string.Format(baseUrl + SearchQueryUrl, query.SearchTerm, token);
+
+            var request = CreateHttpRequest(searchUrl);
+            var response = await client.SendAsync(request);
+            var results = await response.Content.ReadAsStringAsync();
+            try
+            {
+                var jItems = JArray.Parse(results);
+                foreach (JObject item in jItems)
+                {
+                    var release = new ReleaseInfo();
+                    release.Title = (string)item["f"];
+                    release.MagnetUri = new Uri((string)item["d"]);
+                    release.Guid = release.MagnetUri;
+                    release.PublishDate = new DateTime(1970, 1, 1);
+                    release.Size = 0;
+                    release.Seeders = 1;
+                    release.Peers = 1;
+                    release.MinimumRatio = 1;
+                    release.MinimumSeedTime = 172800;
+                    releases.Add(release);
+                }
+            }
+            catch (Exception ex)
+            {
+                OnResultParsingError(this, results, ex);
+            }
+            return releases.ToArray();
+
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/Jackett/Indexers/SceneAccess.cs

@@ -0,0 +1,204 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett.Indexers
+{
+    class SceneAccess : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "SceneAccess"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "Your gateway to the scene"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        const string BaseUrl = "https://sceneaccess.eu";
+        const string LoginUrl = BaseUrl + "/login";
+        const string SearchUrl = BaseUrl + "/{0}?method=1&c{1}=1&search={2}";
+
+
+        public bool IsConfigured
+        {
+            get;
+            private set;
+        }
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+        string cookieHeader;
+
+        public SceneAccess()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+                { "username", config.Username.Value },
+                { "password", config.Password.Value },
+                { "submit", "come on in" }
+            };
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            string responseContent;
+            var configSaveData = new JObject();
+
+            if (Program.IsWindows)
+            {
+                // If Windows use .net http
+                var response = await client.PostAsync(LoginUrl, content);
+                responseContent = await response.Content.ReadAsStringAsync();
+                cookies.DumpToJson(SiteLink, configSaveData);
+            }
+            else
+            {
+                // If UNIX system use curl
+                var response = await CurlHelper.PostAsync(LoginUrl, pairs);
+                responseContent = Encoding.UTF8.GetString(response.Content);
+                cookieHeader = response.CookieHeader;
+                configSaveData["cookie_header"] = cookieHeader;
+            }
+
+            if (!responseContent.Contains("nav_profile"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom["#login_box_desc"];
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            cookieHeader = cookies.GetCookieHeader(SiteLink);
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var searchSection = string.IsNullOrEmpty(query.Episode) ? "archive" : "browse";
+                var searchCategory = string.IsNullOrEmpty(query.Episode) ? "26" : "27";
+
+                var searchUrl = string.Format(SearchUrl, searchSection, searchCategory, searchString);
+
+                string results;
+                if (Program.IsWindows)
+                {
+                    results = await client.GetStringAsync(searchUrl);
+                }
+                else
+                {
+                    var response = await CurlHelper.GetAsync(searchUrl, cookieHeader);
+                    results = Encoding.UTF8.GetString(response.Content);
+                }
+
+                try
+                {
+                    CQ dom = results;
+                    var rows = dom["#torrents-table > tbody > tr.tt_row"];
+                    foreach (var row in rows)
+                    {
+                        CQ qRow = row.Cq();
+                        var release = new ReleaseInfo();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 129600;
+                        release.Title = qRow.Find(".ttr_name > a").Text();
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + "/" + qRow.Find(".ttr_name > a").Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(BaseUrl + "/" + qRow.Find(".td_dl > a").Attr("href"));
+
+                        var sizeStr = qRow.Find(".ttr_size").Contents()[0].NodeValue;
+                        var sizeParts = sizeStr.Split(' ');
+                        release.Size = ReleaseInfo.GetBytes(sizeParts[1], ParseUtil.CoerceFloat(sizeParts[0]));
+
+                        var timeStr = qRow.Find(".ttr_added").Text();
+                        DateTime time;
+                        if (DateTime.TryParseExact(timeStr, "yyyy-MM-ddHH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out time))
+                        {
+                            release.PublishDate = time;
+                        }
+
+                        release.Seeders = ParseUtil.CoerceInt(qRow.Find(".ttr_seeders").Text());
+                        release.Peers = ParseUtil.CoerceInt(qRow.Find(".ttr_leechers").Text()) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+
+        public async Task<byte[]> Download(Uri link)
+        {
+            if (Program.IsWindows)
+            {
+                return await client.GetByteArrayAsync(link);
+            }
+            else
+            {
+                var response = await CurlHelper.GetAsync(link.ToString(), cookieHeader);
+                return response.Content;
+            }
+        }
+    }
+}

src/Jackett/Indexers/SceneTime.cs

@@ -0,0 +1,179 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class SceneTime : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "SceneTime"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "Always on time"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        public bool IsConfigured { get; private set; }
+
+        const string BaseUrl = "https://www.scenetime.com";
+        const string LoginUrl = BaseUrl + "/takelogin.php";
+        const string SearchUrl = BaseUrl + "/browse_API.php";
+        const string DownloadUrl = BaseUrl + "/download.php/{0}/download.torrent";
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+
+        public SceneTime()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            var response = await client.PostAsync(LoginUrl, content);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("logout.php"))
+            {
+                CQ dom = responseContent;
+                var errorMessage = dom["td.text"].Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                cookies.DumpToJson(SiteLink, configSaveData);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            IsConfigured = true;
+        }
+
+        FormUrlEncodedContent GetSearchFormData(string searchString)
+        {
+            var pairs = new Dictionary<string, string> {
+				{ "c2", "1" }, { "c43", "1" }, { "c9", "1" }, { "c63", "1" }, { "c77", "1" }, { "c100", "1" }, { "c101", "1" },
+                { "cata", "yes" }, { "sec", "jax" },
+                { "search", searchString}
+			};
+            var content = new FormUrlEncodedContent(pairs);
+            return content;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+
+                var searchContent = GetSearchFormData(searchString);
+                var response = await client.PostAsync(SearchUrl, searchContent);
+                var results = await response.Content.ReadAsStringAsync();
+
+                try
+                {
+                    CQ dom = results;
+                    var rows = dom["tr.browse"];
+                    foreach (var row in rows)
+                    {
+                        var release = new ReleaseInfo();
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+
+                        var descCol = row.ChildElements.ElementAt(1);
+                        var qDescCol = descCol.Cq();
+                        var qLink = qDescCol.Find("a");
+                        release.Title = qLink.Text();
+                        release.Description = release.Title;
+                        release.Comments = new Uri(BaseUrl + "/" + qLink.Attr("href"));
+                        release.Guid = release.Comments;
+                        var torrentId = qLink.Attr("href").Split('=')[1];
+                        release.Link = new Uri(string.Format(DownloadUrl, torrentId));
+
+                        var dateStr = descCol.ChildNodes.Last().NodeValue.Trim();
+                        var euDate = DateTime.ParseExact(dateStr, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
+                        var localDate = TimeZoneInfo.ConvertTimeToUtc(euDate, TimeZoneInfo.FindSystemTimeZoneById("Central European Standard Time")).ToLocalTime();
+                        release.PublishDate = localDate;
+
+                        var sizeNodes = row.ChildElements.ElementAt(3).ChildNodes;
+                        var sizeVal = sizeNodes.First().NodeValue;
+                        var sizeUnit = sizeNodes.Last().NodeValue;
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, ParseUtil.CoerceFloat(sizeVal));
+
+                        release.Seeders = ParseUtil.CoerceInt(row.ChildElements.ElementAt(4).Cq().Text().Trim());
+                        release.Peers = ParseUtil.CoerceInt(row.ChildElements.ElementAt(5).Cq().Text().Trim()) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+    }
+}

src/Jackett/Indexers/ShowRSS.cs

@@ -0,0 +1,175 @@
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+using System.Xml;
+
+namespace Jackett.Indexers
+{
+    public class ShowRSS : IndexerInterface
+    {
+        public event Action<IndexerInterface, Newtonsoft.Json.Linq.JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "ShowRSS"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "showRSS is a service that allows you to keep track of your favorite TV shows"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(DefaultUrl); }
+        }
+
+        const string DefaultUrl = "http://showrss.info";
+        const string searchAllUrl = DefaultUrl + "/feeds/all.rss";
+        string BaseUrl;
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public bool IsConfigured
+        {
+            get;
+            private set;
+        }
+
+        public ShowRSS()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(Newtonsoft.Json.Linq.JToken configJson)
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            config.LoadValuesFromJson(configJson);
+
+            var formattedUrl = config.GetFormattedHostUrl();
+            var releases = await PerformQuery(new TorznabQuery(), formattedUrl);
+            if (releases.Length == 0)
+                throw new Exception("Could not find releases from this URL");
+
+            BaseUrl = formattedUrl;
+
+            var configSaveData = new JObject();
+            configSaveData["base_url"] = BaseUrl;
+
+            if (OnSaveConfigurationRequested != null)
+                OnSaveConfigurationRequested(this, configSaveData);
+
+            IsConfigured = true;
+        }
+
+        public void LoadFromSavedConfiguration(Newtonsoft.Json.Linq.JToken jsonConfig)
+        {
+            BaseUrl = (string)jsonConfig["base_url"];
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            return await PerformQuery(query, BaseUrl);
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            throw new NotImplementedException();
+        }
+
+        private WebClient getWebClient()
+        {
+            WebClient wc = new WebClient();
+            WebHeaderCollection headers = new WebHeaderCollection();
+            headers.Add("User-Agent", chromeUserAgent);
+            wc.Headers = headers;
+            return wc;
+        }
+
+        async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query, string baseUrl)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = string.Format(searchAllUrl);
+
+                XmlDocument xmlDoc = new XmlDocument();
+                string xml = string.Empty;
+                WebClient wc = getWebClient();
+
+                try
+                {
+                    using (wc)
+                    {
+                        xml = wc.DownloadString(episodeSearchUrl);
+                        xmlDoc.LoadXml(xml);
+                    }
+
+                    ReleaseInfo release;
+                    string serie_title;
+
+                    foreach (XmlNode node in xmlDoc.GetElementsByTagName("item"))
+                    {
+                        release = new ReleaseInfo();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+
+                        serie_title = node.SelectSingleNode("title").InnerText;
+                        release.Title = serie_title;
+
+                        release.Comments = new Uri(node.SelectSingleNode("link").InnerText);
+                        release.Category = node.SelectSingleNode("title").InnerText;
+                        var test = node.SelectSingleNode("enclosure");
+                        release.Guid = new Uri(test.Attributes["url"].Value);
+                        release.PublishDate = DateTime.Parse(node.SelectSingleNode("pubDate").InnerText, CultureInfo.InvariantCulture);
+
+                        release.Description = node.SelectSingleNode("description").InnerText;
+                        release.InfoHash = node.SelectSingleNode("description").InnerText;
+                        release.Size = 0;
+                        release.Seeders = 1;
+                        release.Peers = 1;
+                        release.MagnetUri = new Uri(node.SelectSingleNode("link").InnerText);
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, xml, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+    }
+}

src/Jackett/Indexers/Strike.cs

@@ -14,23 +14,8 @@ namespace Jackett.Indexers
     public class Strike : IndexerInterface
     {
 
-        class StrikeConfig : ConfigurationData
-        {
-            public StringItem Url { get; private set; }
-
-            public StrikeConfig()
-            {
-                Url = new StringItem { Name = "Url", Value = DefaultUrl };
-            }
-
-            public override Item[] GetItems()
-            {
-                return new Item[] { Url };
-            }
-        }
-
-
         public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         public string DisplayName
         {
@@ -51,7 +36,10 @@ namespace Jackett.Indexers
 
         const string DefaultUrl = "https://getstrike.net";
 
-        const string DownloadUrl = "/api/v2/torrents/download/?hash={0}";
+
+        //const string DownloadUrl = "/api/v2/torrents/download/?hash={0}";
+        const string DownloadUrl = "/torrents/api/download/{0}.torrent";
+
         const string SearchUrl = "/api/v2/torrents/search/?category=TV&phrase={0}";
         string BaseUrl;
 
@@ -74,17 +62,16 @@ namespace Jackett.Indexers
 
         public Task<ConfigurationData> GetConfigurationForSetup()
         {
-            var config = new StrikeConfig();
+            var config = new ConfigurationDataUrl(DefaultUrl);
             return Task.FromResult<ConfigurationData>(config);
         }
 
         public async Task ApplyConfiguration(JToken configJson)
         {
-            var config = new StrikeConfig();
+            var config = new ConfigurationDataUrl(DefaultUrl);
             config.LoadValuesFromJson(configJson);
 
-            var uri = new Uri(config.Url.Value);
-            var formattedUrl = string.Format("{0}://{1}", uri.Scheme, uri.Host);
+            var formattedUrl = config.GetFormattedHostUrl();
             var releases = await PerformQuery(new TorznabQuery(), formattedUrl);
             if (releases.Length == 0)
                 throw new Exception("Could not find releases from this URL");
@@ -116,32 +103,40 @@ namespace Jackett.Indexers
                 var searchString = title + " " + query.GetEpisodeSearchString();
                 var episodeSearchUrl = baseUrl + string.Format(SearchUrl, HttpUtility.UrlEncode(searchString.Trim()));
                 var results = await client.GetStringAsync(episodeSearchUrl);
-                var jResults = JObject.Parse(results);
-                foreach (JObject result in (JArray)jResults["torrents"])
+                try
                 {
-                    var release = new ReleaseInfo();
+                    var jResults = JObject.Parse(results);
+                    foreach (JObject result in (JArray)jResults["torrents"])
+                    {
+                        var release = new ReleaseInfo();
 
-                    release.MinimumRatio = 1;
-                    release.MinimumSeedTime = 172800;
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
 
-                    release.Title = (string)result["torrent_title"];
-                    release.Description = release.Title;
-                    release.Seeders = (int)result["seeds"];
-                    release.Peers = (int)result["leeches"] + release.Seeders;
-                    release.Size = (long)result["size"];
+                        release.Title = (string)result["torrent_title"];
+                        release.Description = release.Title;
+                        release.Seeders = (int)result["seeds"];
+                        release.Peers = (int)result["leeches"] + release.Seeders;
+                        release.Size = (long)result["size"];
 
-                    // "Apr  2, 2015", "Apr 12, 2015" (note the spacing)
-                    var dateString = string.Join(" ", ((string)result["upload_date"]).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
-                    release.PublishDate = DateTime.ParseExact(dateString, "MMM d, yyyy", CultureInfo.InvariantCulture);
+                        // "Apr  2, 2015", "Apr 12, 2015" (note the spacing)
+                        var dateString = string.Join(" ", ((string)result["upload_date"]).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
+                        release.PublishDate = DateTime.ParseExact(dateString, "MMM d, yyyy", CultureInfo.InvariantCulture);
 
-                    release.Guid = new Uri((string)result["page"]);
-                    release.Comments = release.Guid;
+                        release.Guid = new Uri((string)result["page"]);
+                        release.Comments = release.Guid;
 
-                    release.InfoHash = (string)result["torrent_hash"];
-                    release.MagnetUri = new Uri((string)result["magnet_uri"]);
-                    release.Link = new Uri(string.Format("{0}{1}{2}", baseUrl, DownloadUrl, release.InfoHash));
+                        release.InfoHash = (string)result["torrent_hash"];
+                        release.MagnetUri = new Uri((string)result["magnet_uri"]);
+                        release.Link = new Uri(string.Format("{0}{1}", baseUrl, string.Format(DownloadUrl, release.InfoHash)));
 
-                    releases.Add(release);
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
             }
 
@@ -157,5 +152,7 @@ namespace Jackett.Indexers
         {
             throw new NotImplementedException();
         }
+
+
     }
 }

src/Jackett/Indexers/ThePirateBay.cs

@@ -16,22 +16,9 @@ namespace Jackett.Indexers
     public class ThePirateBay : IndexerInterface
     {
 
-        class ThePirateBayConfig : ConfigurationData
-        {
-            public StringItem Url { get; private set; }
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
 
-            public ThePirateBayConfig()
-            {
-                Url = new StringItem { Name = "Url", Value = DefaultUrl };
-            }
-
-            public override Item[] GetItems()
-            {
-                return new Item[] { Url };
-            }
-        }
-
-        public event Action<IndexerInterface, Newtonsoft.Json.Linq.JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         public string DisplayName { get { return "The Pirate Bay"; } }
 
@@ -41,9 +28,8 @@ namespace Jackett.Indexers
 
         public bool IsConfigured { get; private set; }
 
-        const string DefaultUrl = "https://thepiratebay.se";
-        const string SearchUrl = "/s/?q=\"{0}\"&category=205&page=0&orderby=99";
-        const string SwitchSingleViewUrl = "/switchview.php?view=s";
+        const string DefaultUrl = "https://thepiratebay.mn";
+        const string SearchUrl = "/search/{0}/0/99/208,205";
 
         string BaseUrl;
 
@@ -51,9 +37,9 @@ namespace Jackett.Indexers
         HttpClientHandler handler;
         HttpClient client;
 
-
         public ThePirateBay()
         {
+            BaseUrl = DefaultUrl;
             IsConfigured = false;
             cookies = new CookieContainer();
             handler = new HttpClientHandler
@@ -67,17 +53,16 @@ namespace Jackett.Indexers
 
         public Task<ConfigurationData> GetConfigurationForSetup()
         {
-            var config = new ThePirateBayConfig();
+            var config = new ConfigurationDataUrl(BaseUrl);
             return Task.FromResult<ConfigurationData>(config);
         }
 
         public async Task ApplyConfiguration(JToken configJson)
         {
-            var config = new ThePirateBayConfig();
+            var config = new ConfigurationDataUrl(DefaultUrl);
             config.LoadValuesFromJson(configJson);
 
-            var uri = new Uri(config.Url.Value);
-            var formattedUrl = string.Format("{0}://{1}", uri.Scheme, uri.Host);
+            var formattedUrl = config.GetFormattedHostUrl();
             var releases = await PerformQuery(new TorznabQuery(), formattedUrl);
             if (releases.Length == 0)
                 throw new Exception("Could not find releases from this URL");
@@ -91,7 +76,6 @@ namespace Jackett.Indexers
                 OnSaveConfigurationRequested(this, configSaveData);
 
             IsConfigured = true;
-
         }
 
         public void LoadFromSavedConfiguration(JToken jsonConfig)
@@ -109,78 +93,97 @@ namespace Jackett.Indexers
         {
             List<ReleaseInfo> releases = new List<ReleaseInfo>();
 
+            List<string> searchUrls = new List<string>();
+
             foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
             {
                 var searchString = title + " " + query.GetEpisodeSearchString();
-                var episodeSearchUrl = baseUrl + string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
+                var queryStr = HttpUtility.UrlEncode(searchString);
+                var episodeSearchUrl = baseUrl + string.Format(SearchUrl, queryStr);
+                searchUrls.Add(episodeSearchUrl);
+            }
 
-                var message = new HttpRequestMessage
-                {
-                    Method = HttpMethod.Get,
-                    RequestUri = new Uri(baseUrl + SwitchSingleViewUrl)
-                };
-                message.Headers.Referrer = new Uri(episodeSearchUrl);
+            foreach (var episodeSearchUrl in searchUrls)
+            {
 
                 string results;
 
                 if (Program.IsWindows)
                 {
-                    var response = await client.SendAsync(message);
-                    results = await response.Content.ReadAsStringAsync();
+                    results = await client.GetStringAsync(episodeSearchUrl);
                 }
                 else
                 {
-                    var response = await CurlHelper.GetAsync(baseUrl + SwitchSingleViewUrl, null, episodeSearchUrl);
+                    var response = await CurlHelper.GetAsync(episodeSearchUrl, null, episodeSearchUrl);
                     results = Encoding.UTF8.GetString(response.Content);
                 }
 
-                CQ dom = results;
-
-                var rows = dom["#searchResult > tbody > tr"];
-                foreach (var row in rows)
+                try
                 {
-                    var release = new ReleaseInfo();
+                    CQ dom = results;
 
-                    CQ qLink = row.ChildElements.ElementAt(1).Cq().Children("a").First();
-
-                    release.MinimumRatio = 1;
-                    release.MinimumSeedTime = 172800;
-                    release.Title = qLink.Text().Trim();
-                    release.Description = release.Title;
-                    release.Comments = new Uri(baseUrl + qLink.Attr("href").TrimStart('/'));
-                    release.Guid = release.Comments;
-
-                    var timeString = row.ChildElements.ElementAt(2).Cq().Text();
-                    if (timeString.Contains("mins ago"))
-                        release.PublishDate = (DateTime.Now - TimeSpan.FromMinutes(int.Parse(timeString.Split(' ')[0])));
-                    else if (timeString.Contains("Today"))
-                        release.PublishDate = (DateTime.UtcNow - TimeSpan.FromHours(2) - TimeSpan.Parse(timeString.Split(' ')[1])).ToLocalTime();
-                    else if (timeString.Contains("Y-day"))
-                        release.PublishDate = (DateTime.UtcNow - TimeSpan.FromHours(26) - TimeSpan.Parse(timeString.Split(' ')[1])).ToLocalTime();
-                    else if (timeString.Contains(':'))
+                    var rows = dom["#searchResult > tbody > tr"];
+                    foreach (var row in rows)
                     {
-                        var utc = DateTime.ParseExact(timeString, "MM-dd HH:mm", CultureInfo.InvariantCulture) - TimeSpan.FromHours(2);
-                        release.PublishDate = DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToLocalTime();
+                        var release = new ReleaseInfo();
+
+                        CQ qRow = row.Cq();
+                        CQ qLink = qRow.Find(".detName > .detLink").First();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qLink.Text().Trim();
+                        release.Description = release.Title;
+                        release.Comments = new Uri(baseUrl + "/" + qLink.Attr("href").TrimStart('/'));
+                        release.Guid = release.Comments;
+
+                        var downloadCol = row.ChildElements.ElementAt(1).Cq().Children("a");
+                        release.MagnetUri = new Uri(downloadCol.Attr("href"));
+                        release.InfoHash = release.MagnetUri.ToString().Split(':')[3].Split('&')[0];
+
+                        var descString = qRow.Find(".detDesc").Text().Trim();
+                        var descParts = descString.Split(',');
+
+                        var timeString = descParts[0].Split(' ')[1];
+
+                        if (timeString.Contains("mins ago"))
+                        {
+                            release.PublishDate = (DateTime.Now - TimeSpan.FromMinutes(ParseUtil.CoerceInt(timeString.Split(' ')[0])));
+                        }
+                        else if (timeString.Contains("Today"))
+                        {
+                            release.PublishDate = (DateTime.UtcNow - TimeSpan.FromHours(2) - TimeSpan.Parse(timeString.Split(' ')[1])).ToLocalTime();
+                        }
+                        else if (timeString.Contains("Y-day"))
+                        {
+                            release.PublishDate = (DateTime.UtcNow - TimeSpan.FromHours(26) - TimeSpan.Parse(timeString.Split(' ')[1])).ToLocalTime();
+                        }
+                        else if (timeString.Contains(':'))
+                        {
+                            var utc = DateTime.ParseExact(timeString, "MM-dd HH:mm", CultureInfo.InvariantCulture) - TimeSpan.FromHours(2);
+                            release.PublishDate = DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToLocalTime();
+                        }
+                        else
+                        {
+                            var utc = DateTime.ParseExact(timeString, "MM-dd yyyy", CultureInfo.InvariantCulture) - TimeSpan.FromHours(2);
+                            release.PublishDate = DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToLocalTime();
+                        }
+
+                        var sizeParts = descParts[1].Split(new char[] { ' ', ' ' }, StringSplitOptions.RemoveEmptyEntries);
+                        var sizeVal = ParseUtil.CoerceFloat(sizeParts[1]);
+                        var sizeUnit = sizeParts[2];
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+
+                        release.Seeders = ParseUtil.CoerceInt(row.ChildElements.ElementAt(2).Cq().Text());
+                        release.Peers = ParseUtil.CoerceInt(row.ChildElements.ElementAt(3).Cq().Text()) + release.Seeders;
+
+                        releases.Add(release);
                     }
-                    else
-                    {
-                        var utc = DateTime.ParseExact(timeString, "MM-dd yyyy", CultureInfo.InvariantCulture) - TimeSpan.FromHours(2);
-                        release.PublishDate = DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToLocalTime();
-                    }
-
-                    var downloadCol = row.ChildElements.ElementAt(3).Cq().Find("a");
-                    release.MagnetUri = new Uri(downloadCol.Attr("href"));
-                    release.InfoHash = release.MagnetUri.ToString().Split(':')[3].Split('&')[0];
-
-                    var sizeString = row.ChildElements.ElementAt(4).Cq().Text().Split(' ');
-                    var sizeVal = float.Parse(sizeString[0]);
-                    var sizeUnit = sizeString[1];
-                    release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
-
-                    release.Seeders = int.Parse(row.ChildElements.ElementAt(5).Cq().Text());
-                    release.Peers = int.Parse(row.ChildElements.ElementAt(6).Cq().Text()) + release.Seeders;
-
-                    releases.Add(release);
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
             }
             return releases.ToArray();
@@ -192,5 +195,7 @@ namespace Jackett.Indexers
         {
             throw new NotImplementedException();
         }
+
+
     }
 }

src/Jackett/Indexers/TorrentDay.cs

@@ -0,0 +1,195 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class TorrentDay : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "TorrentDay"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return DisplayName; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        public bool IsConfigured { get; private set; }
+
+        const string BaseUrl = "https://torrentday.eu";
+        const string StartPageUrl = BaseUrl + "/login.php";
+        const string LoginUrl = BaseUrl + "/tak3login.php";
+        const string SearchUrl = BaseUrl + "/browse.php?search={0}&cata=yes&c2=1&c7=1&c14=1&c24=1&c26=1&c31=1&c32=1&c33=1";
+
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public TorrentDay()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        HttpRequestMessage CreateHttpRequest(string uri)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Get;
+            message.RequestUri = new Uri(uri);
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
+            return message;
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var startMessage = CreateHttpRequest(StartPageUrl);
+            var results = await (await client.SendAsync(startMessage)).Content.ReadAsStringAsync();
+
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value }
+			};
+            var content = new FormUrlEncodedContent(pairs);
+            var loginRequest = CreateHttpRequest(LoginUrl);
+            loginRequest.Method = HttpMethod.Post;
+            loginRequest.Content = content;
+            loginRequest.Headers.Referrer = new Uri(StartPageUrl);
+
+            var response = await client.SendAsync(loginRequest);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("logout.php"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom["#login"];
+                messageEl.Children("form").Remove();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                cookies.DumpToJson(SiteLink, configSaveData);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
+                var results = await client.GetStringAsync(episodeSearchUrl);
+                try
+                {
+                    CQ dom = results;
+                    var rows = dom["#torrentTable > tbody > tr.browse"];
+                    foreach (var row in rows)
+                    {
+                        CQ qRow = row.Cq();
+                        var release = new ReleaseInfo();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qRow.Find(".torrentName").Text();
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + "/" + qRow.Find(".torrentName").Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(BaseUrl + "/" + qRow.Find(".dlLinksInfo > a").Attr("href"));
+
+                        var sizeStr = qRow.Find(".sizeInfo").Text().Trim();
+                        var sizeParts = sizeStr.Split(' ');
+                        release.Size = ReleaseInfo.GetBytes(sizeParts[1], ParseUtil.CoerceFloat(sizeParts[0]));
+
+                        var dateStr = qRow.Find(".ulInfo").Text().Split('|').Last().Trim();
+                        var dateParts = dateStr.Split(' ');
+                        var dateValue = ParseUtil.CoerceInt(dateParts[0]);
+                        TimeSpan ts = TimeSpan.Zero;
+                        if (dateStr.Contains("sec"))
+                            ts = TimeSpan.FromSeconds(dateValue);
+                        else if (dateStr.Contains("min"))
+                            ts = TimeSpan.FromMinutes(dateValue);
+                        else if (dateStr.Contains("hour"))
+                            ts = TimeSpan.FromHours(dateValue);
+                        else if (dateStr.Contains("day"))
+                            ts = TimeSpan.FromDays(dateValue);
+                        else if (dateStr.Contains("week"))
+                            ts = TimeSpan.FromDays(dateValue * 7);
+                        else if (dateStr.Contains("month"))
+                            ts = TimeSpan.FromDays(dateValue * 30);
+                        else if (dateStr.Contains("year"))
+                            ts = TimeSpan.FromDays(dateValue * 365);
+                        release.PublishDate = DateTime.Now - ts;
+
+                        release.Seeders = ParseUtil.CoerceInt(qRow.Find(".seedersInfo").Text());
+                        release.Peers = ParseUtil.CoerceInt(qRow.Find(".leechersInfo").Text()) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+    }
+}

src/Jackett/Indexers/TorrentLeech.cs

@@ -14,6 +14,7 @@ namespace Jackett.Indexers
 {
     public class TorrentLeech : IndexerInterface
     {
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
 
@@ -89,7 +90,7 @@ namespace Jackett.Indexers
             else
             {
                 var configSaveData = new JObject();
-                configSaveData["cookies"] = cookies.ToJson(SiteLink);
+                cookies.DumpToJson(SiteLink, configSaveData);
 
                 if (OnSaveConfigurationRequested != null)
                     OnSaveConfigurationRequested(this, configSaveData);
@@ -100,7 +101,7 @@ namespace Jackett.Indexers
 
         public void LoadFromSavedConfiguration(JToken jsonConfig)
         {
-            cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
             IsConfigured = true;
         }
 
@@ -114,51 +115,64 @@ namespace Jackett.Indexers
                 var searchString = title + " " + query.GetEpisodeSearchString();
                 var episodeSearchUrl = string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
                 var results = await client.GetStringAsync(episodeSearchUrl);
-                CQ dom = results;
-
-                CQ qRows = dom["#torrenttable > tbody > tr"];
-
-                foreach (var row in qRows)
+                try
                 {
-                    var release = new ReleaseInfo();
+                    CQ dom = results;
 
-                    var qRow = row.Cq();
+                    CQ qRows = dom["#torrenttable > tbody > tr"];
 
-                    var debug = qRow.Html();
+                    foreach (var row in qRows)
+                    {
+                        var release = new ReleaseInfo();
 
-                    release.MinimumRatio = 1;
-                    release.MinimumSeedTime = 172800;
+                        var qRow = row.Cq();
 
-                    CQ qLink = qRow.Find(".title > a").First();
-                    release.Guid = new Uri(BaseUrl + qLink.Attr("href"));
-                    release.Comments = release.Guid;
-                    release.Title = qLink.Text();
-                    release.Description = release.Title;
+                        var debug = qRow.Html();
 
-                    release.Link = new Uri(BaseUrl + qRow.Find(".quickdownload > a").Attr("href"));
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
 
-                    var dateString = qRow.Find(".name").First()[0].ChildNodes[4].NodeValue.Replace(" on", "").Trim();
-                    //"2015-04-25 23:38:12"
-                    //"yyyy-MMM-dd hh:mm:ss"
-                    release.PublishDate = DateTime.ParseExact(dateString, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
+                        CQ qLink = qRow.Find(".title > a").First();
+                        release.Guid = new Uri(BaseUrl + qLink.Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Title = qLink.Text();
+                        release.Description = release.Title;
 
-                    var sizeStringParts = qRow.Children().ElementAt(4).InnerText.Split(' ');
-                    release.Size = ReleaseInfo.GetBytes(sizeStringParts[1], float.Parse(sizeStringParts[0]));
+                        release.Link = new Uri(BaseUrl + qRow.Find(".quickdownload > a").Attr("href"));
 
-                    release.Seeders = int.Parse(qRow.Find(".seeders").Text());
-                    release.Peers = int.Parse(qRow.Find(".leechers").Text());
+                        var dateString = qRow.Find(".name").First()[0].ChildNodes[4].NodeValue.Replace(" on", "").Trim();
+                        //"2015-04-25 23:38:12"
+                        //"yyyy-MMM-dd hh:mm:ss"
+                        release.PublishDate = DateTime.ParseExact(dateString, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
 
-                    releases.Add(release);
+                        var sizeStringParts = qRow.Children().ElementAt(4).InnerText.Split(' ');
+                        release.Size = ReleaseInfo.GetBytes(sizeStringParts[1], ParseUtil.CoerceFloat(sizeStringParts[0]));
+
+                        release.Seeders = ParseUtil.CoerceInt(qRow.Find(".seeders").Text());
+                        release.Peers = release.Seeders + ParseUtil.CoerceInt(qRow.Find(".leechers").Text());
+
+                        releases.Add(release);
+                    }
+                }
+
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
 
             }
 
+
             return releases.ToArray();
         }
 
         public Task<byte[]> Download(Uri link)
         {
-            throw new NotImplementedException();
+            return client.GetByteArrayAsync(link);
         }
+
+
+
     }
 }

src/Jackett/Indexers/TorrentShack.cs

@@ -0,0 +1,186 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class TorrentShack : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "TorrentShack"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return DisplayName; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        const string BaseUrl = "http://torrentshack.me";
+        const string LoginUrl = BaseUrl + "/login.php";
+        const string SearchUrl = BaseUrl + "/torrents.php?searchstr={0}&release_type=both&searchtags=&tags_type=0&order_by=s3&order_way=desc&torrent_preset=all&filter_cat%5B600%5D=1&filter_cat%5B620%5D=1&filter_cat%5B700%5D=1&filter_cat%5B981%5D=1&filter_cat%5B980%5D=1";
+
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public bool IsConfigured { get; private set; }
+
+        public TorrentShack()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value },
+                { "keeplogged", "1" },
+                { "login", "Login" }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            var response = await client.PostAsync(LoginUrl, content);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("logout.php"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom["#loginform"];
+                messageEl.Children("table").Remove();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                cookies.DumpToJson(SiteLink, configSaveData);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), jsonConfig);
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
+                var results = await client.GetStringAsync(episodeSearchUrl);
+                try
+                {
+                    CQ dom = results;
+                    var rows = dom["#torrent_table > tbody > tr.torrent"];
+                    foreach (var row in rows)
+                    {
+                        CQ qRow = row.Cq();
+                        var release = new ReleaseInfo();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qRow.Find(".torrent_name_link").Text();
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + "/" + qRow.Find(".torrent_name_link").Parent().Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(BaseUrl + "/" + qRow.Find(".torrent_handle_links > a").First().Attr("href"));
+
+                        var dateStr = qRow.Find(".time").Text().Trim();
+                        if (dateStr.ToLower().Contains("just now"))
+                            release.PublishDate = DateTime.Now;
+                        else
+                        {
+                            var dateParts = dateStr.Split(' ');
+                            var dateValue = ParseUtil.CoerceInt(dateParts[0]);
+                            TimeSpan ts = TimeSpan.Zero;
+                            if (dateStr.Contains("Just now"))
+                                ts = TimeSpan.Zero;
+                            else if (dateStr.Contains("sec"))
+                                ts = TimeSpan.FromSeconds(dateValue);
+                            else if (dateStr.Contains("min"))
+                                ts = TimeSpan.FromMinutes(dateValue);
+                            else if (dateStr.Contains("hour"))
+                                ts = TimeSpan.FromHours(dateValue);
+                            else if (dateStr.Contains("day"))
+                                ts = TimeSpan.FromDays(dateValue);
+                            else if (dateStr.Contains("week"))
+                                ts = TimeSpan.FromDays(dateValue * 7);
+                            else if (dateStr.Contains("month"))
+                                ts = TimeSpan.FromDays(dateValue * 30);
+                            else if (dateStr.Contains("year"))
+                                ts = TimeSpan.FromDays(dateValue * 365);
+                            release.PublishDate = DateTime.Now - ts;
+                        }
+
+                        var sizeStr = qRow.Find(".size")[0].ChildNodes[0].NodeValue.Trim();
+                        var sizeParts = sizeStr.Split(' ');
+                        release.Size = ReleaseInfo.GetBytes(sizeParts[1], ParseUtil.CoerceFloat(sizeParts[0]));
+                        release.Seeders = ParseUtil.CoerceInt(qRow.Children().ElementAt(6).InnerText.Trim());
+                        release.Peers = ParseUtil.CoerceInt(qRow.Children().ElementAt(7).InnerText.Trim()) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+    }
+}

src/Jackett/Indexers/Torrentz.cs

@@ -0,0 +1,257 @@
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using System.Web;
+using System.Windows.Forms;
+using System.Xml;
+
+namespace Jackett.Indexers
+{
+    public class Torrentz : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "Torrentz"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "Torrentz is a meta-search engine and a Multisearch. This means we just search other search engines."; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(DefaultUrl); }
+        }
+
+        const string DefaultUrl = "https://torrentz.eu";
+        const string SearchUrl = DefaultUrl + "/feed_verifiedP?f={0}";
+        string BaseUrl;
+        static string chromeUserAgent = BrowserUtil.ChromeUserAgent;
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public bool IsConfigured
+        {
+            get;
+            private set;
+        }
+
+        public Torrentz()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            return Task.FromResult<ConfigurationData>(config);
+
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            config.LoadValuesFromJson(configJson);
+
+            var formattedUrl = config.GetFormattedHostUrl();
+            var releases = await PerformQuery(new TorznabQuery(), formattedUrl);
+            if (releases.Length == 0)
+                throw new Exception("Could not find releases from this URL");
+
+            BaseUrl = formattedUrl;
+
+            var configSaveData = new JObject();
+            configSaveData["base_url"] = BaseUrl;
+
+            if (OnSaveConfigurationRequested != null)
+                OnSaveConfigurationRequested(this, configSaveData);
+
+            IsConfigured = true;
+
+        }
+
+        private WebClient getWebClient()
+        {
+            WebClient wc = new WebClient();
+            WebHeaderCollection headers = new WebHeaderCollection();
+            headers.Add("User-Agent", chromeUserAgent);
+            wc.Headers = headers;
+            return wc;
+        }
+
+        async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query, string baseUrl)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = string.Format(SearchUrl, HttpUtility.UrlEncode(searchString.Trim()));
+
+                XmlDocument xmlDoc = new XmlDocument();
+                string xml = string.Empty;
+                WebClient wc = getWebClient();
+
+                try
+                {
+                    using (wc)
+                    {
+                        xml = wc.DownloadString(episodeSearchUrl);
+                        xmlDoc.LoadXml(xml);
+                    }
+
+                    ReleaseInfo release;
+                    TorrentzHelper td;
+                    string serie_title;
+
+                    foreach (XmlNode node in xmlDoc.GetElementsByTagName("item"))
+                    {
+                        release = new ReleaseInfo();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        serie_title = node.SelectSingleNode("title").InnerText;
+                        release.Title = serie_title;
+
+                        release.Comments = new Uri(node.SelectSingleNode("link").InnerText);
+                        release.Category = node.SelectSingleNode("category").InnerText;
+                        release.Guid = new Uri(node.SelectSingleNode("guid").InnerText);
+                        release.PublishDate = DateTime.Parse(node.SelectSingleNode("pubDate").InnerText, CultureInfo.InvariantCulture);
+
+                        td = new TorrentzHelper(node.SelectSingleNode("description").InnerText);
+                        release.Description = td.Description;
+                        release.InfoHash = td.hash;
+                        release.Size = td.Size;
+                        release.Seeders = td.Seeders;
+                        release.Peers = td.Peers + release.Seeders;
+                        release.MagnetUri = TorrentzHelper.createMagnetLink(td.hash, serie_title);
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, xml, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            BaseUrl = (string)jsonConfig["base_url"];
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            return await PerformQuery(query, BaseUrl);
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+
+    public class TorrentzHelper
+    {
+        public TorrentzHelper(string description)
+        {
+            this.Description = description;
+            if (null == description)
+            {
+                this.Description = "";
+                this.Size = 0;
+                this.Peers = 0;
+                this.Seeders = 0;
+                this.hash = "";
+            }
+            else
+                FillProperties();
+        }
+
+        public static Uri createMagnetLink(string hash, string title)
+        {
+            string MagnetLink = "magnet:?xt=urn:btih:{0}&dn={1}&tr={2}";
+            string Trackers = WebUtility.UrlEncode("udp://tracker.publicbt.com:80&tr=udp://tracker.openbittorrent.com:80&tr=udp://tracker.ccc.de:80&tr=udp://tracker.istole.it:80");
+            title = WebUtility.UrlEncode(title);
+
+            return new Uri(string.Format(MagnetLink, hash, title, Trackers));
+        }
+
+        private void FillProperties()
+        {
+            string description = this.Description;
+            int counter = 0;
+            while (description.Contains(" "))
+            {
+                int nextSpace = description.IndexOf(": ") + 1;
+                int secondSpace;
+                if (counter != 0)
+                    secondSpace = description.IndexOf(" ", nextSpace + 1);
+                else
+                    secondSpace = description.IndexOf(": ", nextSpace + 2) - description.IndexOf(" ", nextSpace);
+
+                string val;
+                if (secondSpace == -1)
+                {
+                    val = description.Substring(nextSpace).Trim();
+                    description = string.Empty;
+                }
+                else
+                {
+                    val = description.Substring(nextSpace, secondSpace - nextSpace).Trim();
+                    description = description.Substring(secondSpace);
+                }
+
+                switch (counter)
+                {
+                    case 0:
+                        this.Size = ReleaseInfo.BytesFromMB(ParseUtil.CoerceLong(val.Substring(0, val.IndexOf(" ") - 1)));
+                        break;
+                    case 1:
+                        this.Seeders = ParseUtil.CoerceInt(val.Contains(",") ? val.Remove(val.IndexOf(","), 1) : val);
+                        break;
+                    case 2:
+                        this.Peers = ParseUtil.CoerceInt(val.Contains(",") ? val.Remove(val.IndexOf(","), 1) : val);
+                        break;
+                    case 3:
+                        this.hash = val;
+                        break;
+                }
+                counter++;
+            }
+        }
+
+        public string Description { get; set; }
+        public long Size { get; set; }
+        public int Seeders { get; set; }
+        public int Peers { get; set; }
+        public string hash { get; set; }
+    }
+}

src/Jackett/Jackett.csproj

@@ -57,11 +57,9 @@
     <Reference Include="CsQuery">
       <HintPath>..\packages\CsQuery.1.3.4\lib\net40\CsQuery.dll</HintPath>
     </Reference>
-    <Reference Include="ModernHttpClient">
-      <HintPath>..\packages\modernhttpclient.2.3.0\lib\Portable-Net45+WinRT45+WP8+WPA81\ModernHttpClient.dll</HintPath>
-    </Reference>
-    <Reference Include="NLog">
-      <HintPath>..\packages\NLog.3.2.0.0\lib\net45\NLog.dll</HintPath>
+    <Reference Include="NLog.Windows.Forms, Version=2.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\NLog.Windows.Forms.2.0.0.0\lib\net35\NLog.Windows.Forms.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -76,33 +74,52 @@
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
     <Reference Include="Newtonsoft.Json">
-      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <HintPath>..\packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
+    <Reference Include="NLog">
+      <HintPath>..\packages\NLog.4.0.1\lib\net45\NLog.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="ApiKey.cs" />
+    <Compile Include="BrowserUtil.cs" />
+    <Compile Include="CachedResult.cs" />
     <Compile Include="ChannelInfo.cs" />
     <Compile Include="ConfigurationData.cs" />
     <Compile Include="ConfigurationDataBasicLogin.cs" />
+    <Compile Include="ConfigurationDataCookie.cs" />
+    <Compile Include="ConfigurationDataUrl.cs" />
     <Compile Include="CookieContainerExtensions.cs" />
     <Compile Include="DataUrl.cs" />
     <Compile Include="ExceptionWithConfigData.cs" />
+    <Compile Include="HttpClientExtensions.cs" />
     <Compile Include="IndexerInterface.cs" />
     <Compile Include="IndexerManager.cs" />
+    <Compile Include="Indexers\BeyondHD.cs" />
     <Compile Include="Indexers\BitHdtv.cs" />
     <Compile Include="Indexers\BitMeTV.cs" />
     <Compile Include="Indexers\Freshon.cs" />
+    <Compile Include="Indexers\HDTorrents.cs" />
     <Compile Include="Indexers\IPTorrents.cs" />
     <Compile Include="Indexers\MoreThanTV.cs" />
+    <Compile Include="Indexers\Rarbg.cs" />
+    <Compile Include="Indexers\SceneAccess.cs" />
+    <Compile Include="Indexers\SceneTime.cs" />
+    <Compile Include="Indexers\ShowRSS.cs" />
     <Compile Include="Indexers\Strike.cs" />
     <Compile Include="Indexers\ThePirateBay.cs" />
+    <Compile Include="Indexers\TorrentDay.cs" />
+    <Compile Include="Indexers\AnimeBytes.cs" />
     <Compile Include="Indexers\TorrentLeech.cs" />
+    <Compile Include="Indexers\TorrentShack.cs" />
+    <Compile Include="Indexers\Torrentz.cs" />
     <Compile Include="Main.cs">
       <SubType>Form</SubType>
     </Compile>
     <Compile Include="Main.Designer.cs">
       <DependentUpon>Main.cs</DependentUpon>
     </Compile>
+    <Compile Include="ParseUtil.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
@@ -118,6 +135,7 @@
     <Compile Include="TVRage.cs" />
     <Compile Include="WebApi.cs" />
     <Compile Include="CurlHelper.cs" />
+    <Compile Include="Indexers\AlphaRatio.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
@@ -139,6 +157,33 @@
     </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
+    <Content Include="WebContent\custom.css">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\custom.js">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\animebytes.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\beyondhd.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\hdtorrents.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\sceneaccess.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\scenetime.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\showrss.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\torrentday.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="WebContent\logos\torrentshack.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -209,10 +254,16 @@
     <Content Include="WebContent\logos\torrentleech.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="WebContent\logos\torrentz.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="WebContent\setup_indexer.html">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
     <Content Include="Resources\validator_reply.xml" />
+    <Content Include="WebContent\logos\alpharatio.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\CurlSharp\CurlSharp.csproj">
@@ -237,6 +288,17 @@
       <Install>false</Install>
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup>
+    <COMReference Include="IWshRuntimeLibrary">
+      <Guid>{F935DC20-1CF0-11D0-ADB9-00C04FD58A0B}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </COMReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
@@ -245,4 +307,14 @@
   <Target Name="AfterBuild">
   </Target>
   -->
+  <ProjectExtensions>
+    <MonoDevelop>
+      <Properties>
+        <Policies>
+          <TextStylePolicy inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" />
+          <CSharpFormattingPolicy IndentSwitchBody="True" IndentBlocksInsideExpressions="True" AnonymousMethodBraceStyle="NextLine" PropertyBraceStyle="NextLine" PropertyGetBraceStyle="NextLine" PropertySetBraceStyle="NextLine" EventBraceStyle="NextLine" EventAddBraceStyle="NextLine" EventRemoveBraceStyle="NextLine" StatementBraceStyle="NextLine" ElseNewLinePlacement="NewLine" CatchNewLinePlacement="NewLine" FinallyNewLinePlacement="NewLine" WhileNewLinePlacement="DoNotCare" ArrayInitializerWrapping="DoNotChange" ArrayInitializerBraceStyle="NextLine" BeforeMethodDeclarationParentheses="False" BeforeMethodCallParentheses="False" BeforeConstructorDeclarationParentheses="False" NewLineBeforeConstructorInitializerColon="NewLine" NewLineAfterConstructorInitializerColon="SameLine" BeforeDelegateDeclarationParentheses="False" NewParentheses="False" SpacesBeforeBrackets="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" />
+        </Policies>
+      </Properties>
+    </MonoDevelop>
+  </ProjectExtensions>
 </Project>

src/Jackett/Main.Designer.cs

@@ -1,4 +1,6 @@
-namespace Jackett
+#if !__MonoCS__
+
+namespace Jackett
 {
     partial class Main
     {
@@ -97,4 +99,5 @@
         private System.Windows.Forms.ToolStripMenuItem toolStripMenuItemShutdown;
 
     }
-}
+}
+#endif

src/Jackett/Main.cs

@@ -1,10 +1,12 @@
-using Microsoft.Win32;
+#if !__MonoCS__
+using Microsoft.Win32;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data;
 using System.Diagnostics;
 using System.Drawing;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -57,20 +59,38 @@ namespace Jackett
         {
             get
             {
-                RegistryKey rkApp = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
-                if (rkApp.GetValue(ProgramTitle) == null)
-                    return false;
-                else
-                    return true;
+                return File.Exists(ShortcutPath);
             }
             set
             {
-                RegistryKey rkApp = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                 if (value && !AutoStart)
-                    rkApp.SetValue(ProgramTitle, Application.ExecutablePath.ToString());
+                {
+                    CreateShortcut();
+                }
                 else if (!value && AutoStart)
-                    rkApp.DeleteValue(ProgramTitle, false);
+                {
+                    File.Delete(ShortcutPath);
+                }
             }
         }
+
+        public string ShortcutPath
+        {
+            get
+            {
+                return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Startup), "Jackett.lnk");
+            }
+        }
+
+        private void CreateShortcut()
+        {
+            var appPath = Assembly.GetExecutingAssembly().Location;
+            var shell = new IWshRuntimeLibrary.WshShell();
+            var shortcut = (IWshRuntimeLibrary.IWshShortcut)shell.CreateShortcut(ShortcutPath);
+            shortcut.Description = Assembly.GetExecutingAssembly().GetName().Name;
+            shortcut.TargetPath = appPath;
+            shortcut.Save();
+        }
     }
 }
+#endif

src/Jackett/ParseUtil.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+    public static class ParseUtil
+    {
+        public static float CoerceFloat(string str)
+        {
+            return float.Parse(str, NumberStyles.Any, CultureInfo.InvariantCulture);
+        }
+
+        public static int CoerceInt(string str)
+        {
+            return int.Parse(str, NumberStyles.Any, CultureInfo.InvariantCulture);
+        }
+
+        public static long CoerceLong(string str)
+        {
+            return long.Parse(str, NumberStyles.Any, CultureInfo.InvariantCulture);
+        }
+
+
+        public static bool TryCoerceFloat(string str, out float result)
+        {
+            return float.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture, out result);
+        }
+
+        public static bool TryCoerceInt(string str, out int result)
+        {
+            return int.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture, out result);
+        }
+
+        public static bool TryCoerceLong(string str, out long result)
+        {
+            return long.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture, out result);
+        }
+
+    }
+}

src/Jackett/Program.cs

@@ -1,6 +1,9 @@
-using NLog;
+using Jackett.Indexers;
+using Newtonsoft.Json.Linq;
+using NLog;
 using NLog.Config;
 using NLog.Targets;
+using NLog.Windows.Forms;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -16,7 +19,7 @@ namespace Jackett
 {
     class Program
     {
-        public static string AppConfigDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Jackett");
+        public static string AppConfigDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Jackett");
 
         public static Server ServerInstance { get; private set; }
 
@@ -28,10 +31,14 @@ namespace Jackett
 
         public static bool IsWindows { get { return Environment.OSVersion.Platform == PlatformID.Win32NT; } }
 
+
+
         static void Main(string[] args)
         {
             ExitEvent = new ManualResetEvent(false);
 
+            MigrateSettingsDirectory();
+
             try
             {
                 if (!Directory.Exists(AppConfigDirectory))
@@ -64,12 +71,14 @@ namespace Jackett
 
             if (Program.IsWindows)
             {
+#if !__MonoCS__
                 var logAlert = new MessageBoxTarget();
                 logConfig.AddTarget("alert", logAlert);
                 logAlert.Layout = "${message}";
                 logAlert.Caption = "Alert";
                 var logAlertRule = new LoggingRule("*", LogLevel.Fatal, logAlert);
                 logConfig.LoggingRules.Add(logAlertRule);
+#endif
             }
 
             var logConsole = new ConsoleTarget();
@@ -81,6 +90,8 @@ namespace Jackett
             LogManager.Configuration = logConfig;
             LoggerInstance = LogManager.GetCurrentClassLogger();
 
+            ReadSettingsFile();
+
             var serverTask = Task.Run(async () =>
             {
                 ServerInstance = new Server();
@@ -90,7 +101,11 @@ namespace Jackett
             try
             {
                 if (Program.IsWindows)
+                {
+#if !__MonoCS__
                     Application.Run(new Main());
+#endif
+                }
             }
             catch (Exception)
             {
@@ -99,10 +114,48 @@ namespace Jackett
 
             Console.WriteLine("Running in headless mode.");
 
+
+
             Task.WaitAll(serverTask);
             Console.WriteLine("Server thread exit");
         }
 
+        static void MigrateSettingsDirectory()
+        {
+            try
+            {
+                string oldDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Jackett");
+                if (Directory.Exists(oldDir) && !Directory.Exists(AppConfigDirectory))
+                {
+                    Directory.Move(oldDir, AppConfigDirectory);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("ERROR could not migrate settings directory " + ex);
+            }
+        }
+
+        static void ReadSettingsFile()
+        {
+            var path = Path.Combine(AppConfigDirectory, "config.json");
+            if (!File.Exists(path))
+            {
+                JObject f = new JObject();
+                f.Add("port", Server.DefaultPort);
+                f.Add("public", true);
+                File.WriteAllText(path, f.ToString());
+            }
+
+            var configJson = JObject.Parse(File.ReadAllText(path));
+            int port = (int)configJson.GetValue("port");
+            Server.Port = port;
+
+            Server.ListenPublic = (bool)configJson.GetValue("public");
+
+            Console.WriteLine("Config file path: " + path);
+        }
+
         static public void RestartAsAdmin()
         {
             var startInfo = new ProcessStartInfo(Application.ExecutablePath.ToString()) { Verb = "runas" };

src/Jackett/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyVersion("0.4.2.0")]
 [assembly: AssemblyFileVersion("1.0.0.0")]

src/Jackett/ReleaseInfo.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 namespace Jackett
 {
 
-    public class ReleaseInfo
+    public class ReleaseInfo: ICloneable
     {
         public string Title { get; set; }
         public Uri Guid { get; set; }
@@ -28,6 +28,30 @@ namespace Jackett
         public double? MinimumRatio { get; set; }
         public long? MinimumSeedTime { get; set; }
 
+        public object Clone()
+        {
+            return new ReleaseInfo()
+            {
+                Title = Title,
+                Guid = Guid,
+                Link = Link,
+                Comments = Comments,
+                PublishDate = PublishDate,
+                Category = Category,
+                Size = Size,
+                Description = Description,
+                RageID = RageID,
+                Imdb = Imdb,
+                Seeders = Seeders,
+                Peers = Peers,
+                ConverUrl = ConverUrl,
+                BannerUrl = BannerUrl,
+                InfoHash = InfoHash,
+                MagnetUri = MagnetUri,
+                MinimumRatio = MinimumRatio,
+                MinimumSeedTime = MinimumSeedTime
+            };
+        }
 
         public static long GetBytes(string unit, float value)
         {

src/Jackett/ResultPage.cs

@@ -69,16 +69,16 @@ namespace Jackett
                         select new XElement("item",
                             new XElement("title", r.Title),
                             new XElement("guid", r.Guid),
-                            new XElement("comments", r.Comments.ToString()),
-                            new XElement("pubDate", xmlDateFormat(r.PublishDate)),
-                            new XElement("size", r.Size),
+                            r.Comments == null ? null : new XElement("comments", r.Comments.ToString()),
+                            r.PublishDate == DateTime.MinValue ? null : new XElement("pubDate", xmlDateFormat(r.PublishDate)),
+                            r.Size == null ? null : new XElement("size", r.Size),
                             new XElement("description", r.Description),
                             new XElement("link", r.Link ?? r.MagnetUri),
                             r.Category == null ? null : new XElement("category", r.Category),
                             new XElement(
                                 "enclosure",
                                 new XAttribute("url", r.Link ?? r.MagnetUri),
-                                new XAttribute("length", r.Size),
+                                r.Size == null ? null : new XAttribute("length", r.Size),
                                 new XAttribute("type", "application/x-bittorrent")
                             ),
                             getTorznabElement("magneturl", r.MagnetUri),

src/Jackett/Server.cs

@@ -15,7 +15,9 @@ namespace Jackett
 {
     public class Server
     {
-        public const int Port = 9117;
+        public const int DefaultPort = 9117;
+        public static int Port = DefaultPort;
+        public static bool ListenPublic = true;
 
         HttpListener listener;
         IndexerManager indexerManager;
@@ -50,12 +52,21 @@ namespace Jackett
 
         public async Task Start()
         {
-            Program.LoggerInstance.Info("Starting HTTP server...");
+            Program.LoggerInstance.Info("Starting HTTP server on port " + Port + " listening " + (ListenPublic ? "publicly" : "privately"));
 
             try
             {
                 listener = new HttpListener();
-                listener.Prefixes.Add("http://*:9117/");
+
+                if (ListenPublic)
+                {
+                    listener.Prefixes.Add(string.Format("http://*:{0}/", Port));
+                }
+                else
+                {
+                    listener.Prefixes.Add(string.Format("http://127.0.0.1:{0}/", Port));
+                }
+
                 listener.Start();
             }
             catch (HttpListenerException ex)
@@ -79,7 +90,9 @@ namespace Jackett
                     }
                 }
                 else
+                {
                     Program.LoggerInstance.FatalException("Failed to start HTTP server. " + ex.Message, ex);
+                }
             }
             catch (Exception ex)
             {
@@ -88,6 +101,7 @@ namespace Jackett
             }
 
             Program.LoggerInstance.Info("Server started on port " + Port);
+            Program.LoggerInstance.Info("Accepting only requests from local system: " + (!ListenPublic));
 
             while (true)
             {
@@ -190,7 +204,7 @@ namespace Jackett
 
             if (torznabQuery.RageID != 0)
                 torznabQuery.ShowTitles = await sonarrApi.GetShowTitle(torznabQuery.RageID);
-            else
+            else if (!string.IsNullOrEmpty(torznabQuery.SearchTerm))
                 torznabQuery.ShowTitles = new string[] { torznabQuery.SearchTerm };
 
             var releases = await indexer.PerformQuery(torznabQuery);

src/Jackett/SonarApi.cs

@@ -86,7 +86,15 @@ namespace Jackett
 
         string SanitizeTitle(string title)
         {
-            return title.Replace("(", "").Replace(")", "");
+            char[] arr = title.ToCharArray();
+
+            arr = Array.FindAll<char>(arr, c => (char.IsLetterOrDigit(c)
+                                              || char.IsWhiteSpace(c)
+                                              || c == '-'
+                                              || c == '.'
+                                              ));
+            title = new string(arr);
+            return title;
         }
 
         void LoadSettings()
@@ -129,9 +137,9 @@ namespace Jackett
         {
             var config = new ConfigurationSonarr();
             config.LoadValuesFromJson(configJson);
-            await ReloadNameMappings(config.Host.Value, int.Parse(config.Port.Value), config.ApiKey.Value);
+            await ReloadNameMappings(config.Host.Value, ParseUtil.CoerceInt(config.Port.Value), config.ApiKey.Value);
             Host = "http://" + new Uri(config.Host.Value).Host;
-            Port = int.Parse(config.Port.Value);
+            Port = ParseUtil.CoerceInt(config.Port.Value);
             ApiKey = config.ApiKey.Value;
             SaveSettings();
         }

src/Jackett/TorznabQuery.cs

@@ -34,7 +34,7 @@ namespace Jackett
             else if (string.IsNullOrEmpty(Episode))
                 episodeString = string.Format("S{0:00}", Season);
             else
-                episodeString = string.Format("S{0:00}E{1:00}", Season, int.Parse(Episode));
+                episodeString = string.Format("S{0:00}E{1:00}", Season, ParseUtil.CoerceInt(Episode));
 
             return episodeString;
         }
@@ -46,11 +46,24 @@ namespace Jackett
             var q = new TorznabQuery();
             q.QueryType = query["t"];
             q.SearchTerm = query["q"];
-            q.Categories = query["cat"].Split(',');
-            q.Extended = int.Parse(query["extended"]);
+            if (query["cat"] != null)
+            {
+                q.Categories = query["cat"].Split(',');
+            }
+
+            if (query["extended"] != null)
+            {
+                q.Extended = ParseUtil.CoerceInt(query["extended"]);
+            }
             q.ApiKey = query["apikey"];
-            q.Limit = int.Parse(query["limit"]);
-            q.Offset = int.Parse(query["offset"]);
+            if (query["limit"] != null)
+            {
+                q.Limit = ParseUtil.CoerceInt(query["limit"]);
+            }
+            if (query["offset"] != null)
+            {
+                q.Offset = ParseUtil.CoerceInt(query["offset"]);
+            }
 
             int temp;
             if (int.TryParse(query["rid"], out temp))

src/Jackett/WebApi.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net;
+using System.Reflection;
 using System.Security.Cryptography;
 using System.Text;
 using System.Threading.Tasks;
@@ -257,6 +258,7 @@ namespace Jackett
             {
                 jsonReply["result"] = "success";
                 jsonReply["api_key"] = ApiKey.CurrentKey;
+                jsonReply["app_version"] = Assembly.GetExecutingAssembly().GetName().Version.ToString();
                 JArray items = new JArray();
                 foreach (var i in indexerManager.Indexers)
                 {

src/Jackett/WebContent/custom.css

@@ -0,0 +1,190 @@
+body {
+    background-image: url("binding_dark.png");
+    background-repeat: repeat;
+}
+
+#page {
+    border-radius: 6px;
+    background-color: white;
+    max-width: 900px;
+    margin: 0 auto;
+    margin-top: 30px;
+    padding: 20px;
+    margin-bottom: 100px;
+}
+
+.container-fluid {
+}
+
+#templates {
+    display: none;
+}
+
+.card {
+    background-color: #f9f9f9;
+    border-radius: 6px;
+    box-shadow: 1px 1px 5px 2px #cdcdcd;
+    padding: 10px;
+    width: 260px;
+    display: inline-block;
+    vertical-align: top;
+    margin: 10px;
+}
+
+.unconfigured-indexer {
+    height: 170px;
+}
+
+.indexer {
+    height: 230px;
+}
+
+.add-indexer {
+    border: 0;
+}
+
+.indexer-logo {
+    text-align: center;
+}
+
+    .indexer-logo > img {
+        border: 1px solid #828282;
+    }
+
+.indexer-name > h3 {
+    margin-top: 13px;
+    text-align: center;
+}
+
+.indexer-buttons {
+    text-align: center;
+}
+
+    .indexer-buttons > .btn {
+        margin-bottom: 10px;
+    }
+
+
+.indexer-button-test {
+    width: 60px;
+}
+
+.indexer-add-content {
+    color: gray;
+    text-align: center;
+}
+
+    .indexer-add-content > .glyphicon {
+        font-size: 50px;
+        vertical-align: bottom;
+    }
+
+    .indexer-add-content > .light-text {
+        margin-top: 11px;
+        font-size: 18px;
+        margin-left: -5px;
+    }
+
+
+.indexer-host > input {
+    font-size: 12px;
+    padding: 2px;
+}
+
+.setup-item-inputstring {
+    max-width: 260px;
+}
+
+.setup-item-inputbool input {
+    max-width: 100px;
+    height: 20px;
+}
+
+.spinner {
+    -webkit-animation: spin 2s infinite linear;
+    -moz-animation: spin 2s infinite linear;
+    -o-animation: spin 2s infinite linear;
+    animation: spin 2s infinite linear;
+}
+
+@-moz-keyframes spin {
+    from {
+        -moz-transform: rotate(0deg);
+    }
+
+    to {
+        -moz-transform: rotate(360deg);
+    }
+}
+
+@-webkit-keyframes spin {
+    from {
+        -webkit-transform: rotate(0deg);
+    }
+
+    to {
+        -webkit-transform: rotate(360deg);
+    }
+}
+
+@keyframes spin {
+    from {
+        transform: rotate(0deg);
+    }
+
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+#setup-indexer-go {
+    width: 70px;
+}
+
+hr {
+    border-top-color: #cdcdcd;
+}
+
+.input-area {
+}
+
+    .input-area > * {
+        vertical-align: middle;
+    }
+
+    .input-area > p {
+        margin-top: 10px;
+    }
+
+.input-header {
+    font-size: 18px;
+    width: 140px;
+    display: inline-block;
+}
+
+.input-right {
+    width: 300px;
+    display: inline-block;
+    font-family: monospace;
+}
+
+#sonarr-warning {
+    display: none;
+}
+
+#logo {
+    max-width: 50px;
+}
+
+#header-title {
+    font-size: 34px;
+    vertical-align: middle;
+    padding-left: 15px;
+}
+
+#footer {
+    color: #444444;
+    margin: 0 auto;
+    margin-top: 10px;
+    text-align: center;
+}

src/Jackett/WebContent/custom.js

@@ -0,0 +1,297 @@
+
+
+reloadIndexers();
+loadSonarrInfo();
+
+function loadSonarrInfo() {
+    getSonarrConfig(function (data) {
+        $("#sonarr-host").val("");
+        var host, port, apiKey;
+        for (var i = 0; i < data.config.length; i++) {
+            if (data.config[i].id == "host")
+                host = data.config[i].value;
+            if (data.config[i].id == "port")
+                port = data.config[i].value;
+            if (data.config[i].id == "apikey")
+                apiKey = data.config[i].value;
+        }
+        if (!apiKey)
+            $("#sonarr-warning").show();
+        else {
+            $("#sonarr-warning").hide();
+            $("#sonarr-host").val(host + ":" + port);
+        }
+    });
+}
+
+function getSonarrConfig(callback) {
+    var jqxhr = $.get("get_sonarr_config", function (data) {
+        callback(data);
+    }).fail(function () {
+        doNotify("Error loading Sonarr API configuration, request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
+    });
+}
+
+$("#sonarr-test").click(function () {
+    var jqxhr = $.get("get_indexers", function (data) {
+        if (data.result == "error")
+            doNotify("Test failed for Sonarr API\n" + data.error, "danger", "glyphicon glyphicon-alert");
+        else
+            doNotify("Test successful for Sonarr API", "success", "glyphicon glyphicon-ok");
+    }).fail(function () {
+        doNotify("Error testing Sonarr, request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
+    });
+});
+
+$("#sonarr-settings").click(function () {
+    getSonarrConfig(function (data) {
+        var config = data.config;
+
+        var configForm = newConfigModal("Sonarr API", config);
+
+        var $goButton = configForm.find(".setup-indexer-go");
+        $goButton.click(function () {
+            var data = getConfigModalJson(configForm);
+
+            var originalBtnText = $goButton.html();
+            $goButton.prop('disabled', true);
+            $goButton.html($('#templates > .spinner')[0].outerHTML);
+
+            var jqxhr = $.post("apply_sonarr_config", JSON.stringify(data), function (data) {
+                if (data.result == "error") {
+                    if (data.config) {
+                        populateSetupForm(data.indexer, data.name, data.config);
+                    }
+                    doNotify("Configuration failed: " + data.error, "danger", "glyphicon glyphicon-alert");
+                }
+                else {
+                    configForm.modal("hide");
+                    loadSonarrInfo();
+                    doNotify("Successfully configured Sonarr API", "success", "glyphicon glyphicon-ok");
+                }
+            }).fail(function () {
+                doNotify("Request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
+            }).always(function () {
+                $goButton.html(originalBtnText);
+                $goButton.prop('disabled', false);
+            });
+        });
+
+        configForm.modal("show");
+
+    });
+});
+
+
+function reloadIndexers() {
+    $('#indexers').hide();
+    $('#indexers > .indexer').remove();
+    $('#unconfigured-indexers').empty();
+    var jqxhr = $.get("get_indexers", function (data) {
+        $("#api-key-input").val(data.api_key);
+        $("#app-version").html(data.app_version);
+        displayIndexers(data.items);
+    }).fail(function () {
+        doNotify("Error loading indexers, request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
+    });
+}
+
+function displayIndexers(items) {
+    var indexerTemplate = Handlebars.compile($("#templates > .configured-indexer")[0].outerHTML);
+    var unconfiguredIndexerTemplate = Handlebars.compile($("#templates > .unconfigured-indexer")[0].outerHTML);
+    for (var i = 0; i < items.length; i++) {
+        var item = items[i];
+        item.torznab_host = resolveUrl("/api/" + item.id);
+        if (item.configured)
+            $('#indexers').append(indexerTemplate(item));
+        else
+            $('#unconfigured-indexers').append($(unconfiguredIndexerTemplate(item)));
+    }
+
+    var addIndexerButton = $("#templates > .add-indexer")[0].outerHTML;
+    $('#indexers').append(addIndexerButton);
+
+    $('#indexers').fadeIn();
+    prepareSetupButtons();
+    prepareTestButtons();
+    prepareDeleteButtons();
+}
+
+function prepareDeleteButtons() {
+    $(".indexer-button-delete").each(function (i, btn) {
+        var $btn = $(btn);
+        var id = $btn.data("id");
+        $btn.click(function () {
+            var jqxhr = $.post("delete_indexer", JSON.stringify({ indexer: id }), function (data) {
+                if (data.result == "error") {
+                    doNotify("Delete error for " + id + "\n" + data.error, "danger", "glyphicon glyphicon-alert");
+                }
+                else {
+                    doNotify("Deleted " + id, "success", "glyphicon glyphicon-ok");
+                }
+            }).fail(function () {
+                doNotify("Error deleting indexer, request to Jackett server error", "danger", "glyphicon glyphicon-alert");
+            }).always(function () {
+                reloadIndexers();
+            });
+        });
+    });
+}
+
+function prepareSetupButtons() {
+    $('.indexer-setup').each(function (i, btn) {
+        var $btn = $(btn);
+        var id = $btn.data("id");
+        $btn.click(function () {
+            displayIndexerSetup(id);
+        });
+    });
+}
+
+function prepareTestButtons() {
+    $(".indexer-button-test").each(function (i, btn) {
+        var $btn = $(btn);
+        var id = $btn.data("id");
+        $btn.click(function () {
+            doNotify("Test started for " + id, "info", "glyphicon glyphicon-transfer");
+            var jqxhr = $.post("test_indexer", JSON.stringify({ indexer: id }), function (data) {
+                if (data.result == "error") {
+                    doNotify("Test failed for " + data.name + "\n" + data.error, "danger", "glyphicon glyphicon-alert");
+                }
+                else {
+                    doNotify("Test successful for " + data.name, "success", "glyphicon glyphicon-ok");
+                }
+            }).fail(function () {
+                doNotify("Error testing indexer, request to Jackett server error", "danger", "glyphicon glyphicon-alert");
+            });
+        });
+    });
+}
+
+function displayIndexerSetup(id) {
+
+    var jqxhr = $.post("get_config_form", JSON.stringify({ indexer: id }), function (data) {
+        if (data.result == "error") {
+            doNotify("Error: " + data.error, "danger", "glyphicon glyphicon-alert");
+            return;
+        }
+        populateSetupForm(id, data.name, data.config);
+
+    }).fail(function () {
+        doNotify("Request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
+    });
+
+    $("#select-indexer-modal").modal("hide");
+}
+
+function populateConfigItems(configForm, config) {
+    var $formItemContainer = configForm.find(".config-setup-form");
+    $formItemContainer.empty();
+    var setupItemTemplate = Handlebars.compile($("#templates > .setup-item")[0].outerHTML);
+    for (var i = 0; i < config.length; i++) {
+        var item = config[i];
+        var setupValueTemplate = Handlebars.compile($("#templates > .setup-item-" + item.type)[0].outerHTML);
+        item.value_element = setupValueTemplate(item);
+        $formItemContainer.append(setupItemTemplate(item));
+    }
+}
+
+function newConfigModal(title, config) {
+    //config-setup-modal
+    var configTemplate = Handlebars.compile($("#templates > .config-setup-modal")[0].outerHTML);
+    var configForm = $(configTemplate({ title: title }));
+
+    $("#modals").append(configForm);
+
+    populateConfigItems(configForm, config);
+
+    return configForm;
+    //modal.remove();
+}
+
+function getConfigModalJson(configForm) {
+    var configJson = {};
+    configForm.find(".config-setup-form").children().each(function (i, el) {
+        $el = $(el);
+        var type = $el.data("type");
+        var id = $el.data("id");
+        switch (type) {
+            case "inputstring":
+                configJson[id] = $el.find(".setup-item-inputstring").val();
+                break;
+            case "inputbool":
+                configJson[id] = $el.find(".setup-item-inputbool input").is(":checked");
+                break;
+        }
+    });
+    return configJson;
+}
+
+function populateSetupForm(indexerId, name, config) {
+
+    var configForm = newConfigModal(name, config);
+
+    var $goButton = configForm.find(".setup-indexer-go");
+    $goButton.click(function () {
+        var data = { indexer: indexerId, name: name };
+        data.config = getConfigModalJson(configForm);
+
+        var originalBtnText = $goButton.html();
+        $goButton.prop('disabled', true);
+        $goButton.html($('#templates > .spinner')[0].outerHTML);
+
+        var jqxhr = $.post("configure_indexer", JSON.stringify(data), function (data) {
+            if (data.result == "error") {
+                if (data.config) {
+                    populateConfigItems(configForm, data.config);
+                }
+                doNotify("Configuration failed: " + data.error, "danger", "glyphicon glyphicon-alert");
+            }
+            else {
+                configForm.modal("hide");
+                reloadIndexers();
+                doNotify("Successfully configured " + data.name, "success", "glyphicon glyphicon-ok");
+            }
+        }).fail(function () {
+            doNotify("Request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
+        }).always(function () {
+            $goButton.html(originalBtnText);
+            $goButton.prop('disabled', false);
+        });
+    });
+
+    configForm.modal("show");
+}
+
+function resolveUrl(url) {
+    var a = document.createElement('a');
+    a.href = url;
+    url = a.href;
+    return url;
+}
+
+
+
+function doNotify(message, type, icon) {
+    $.notify({
+        message: message,
+        icon: icon
+    }, {
+        element: 'body',
+        type: type,
+        allow_dismiss: true,
+        z_index: 9000,
+        mouse_over: 'pause',
+        placement: {
+            from: "bottom",
+            align: "center"
+        }
+    });
+}
+
+function clearNotifications() {
+    $('[data-notify="container"]').remove();
+}
+
+$('#test').click(doNotify);
+

src/Jackett/WebContent/index.html

@@ -1,645 +1,177 @@
-<!DOCTYPE html>
-
-<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
-<head>
-    <meta charset="utf-8" />
-
-    <link rel='shortcut icon' type='image/x-icon' href='/favicon.ico' />
-
-    <script src="jquery-2.1.3.min.js"></script>
-    <script src="handlebars-v3.0.1.js"></script>
-    <script src="bootstrap/bootstrap.min.js"></script>
-    <script src="bootstrap-notify.js"></script>
-
-    <link href="bootstrap/bootstrap.min.css" rel="stylesheet">
-    <link href="animate.css" rel="stylesheet">
-
-    <title>Jackett</title>
-    <style>
-        body {
-            background-image: url("binding_dark.png");
-            background-repeat: repeat;
-        }
-
-        #page {
-            border-radius: 6px;
-            background-color: white;
-            max-width: 900px;
-            margin: 0 auto;
-            margin-top: 30px;
-            padding: 20px;
-            margin-bottom: 100px;
-        }
-
-        .container-fluid {
-        }
-
-        #templates {
-            display: none;
-        }
-
-        .card {
-            background-color: #f9f9f9;
-            border-radius: 6px;
-            box-shadow: 1px 1px 5px 2px #cdcdcd;
-            padding: 10px;
-            width: 260px;
-            display: inline-block;
-            vertical-align: top;
-            margin: 10px;
-        }
-
-        .unconfigured-indexer {
-            height: 170px;
-        }
-
-        .indexer {
-            height: 230px;
-        }
-
-        .add-indexer {
-            border: 0;
-        }
-
-        .indexer-logo {
-            text-align: center;
-        }
-
-            .indexer-logo > img {
-                border: 1px solid #828282;
-            }
-
-        .indexer-name > h3 {
-            margin-top: 13px;
-            text-align: center;
-        }
-
-        .indexer-buttons {
-            text-align: center;
-        }
-
-            .indexer-buttons > .btn {
-                margin-bottom: 10px;
-            }
-
-
-        .indexer-button-test {
-            width: 60px;
-        }
-
-        .indexer-add-content {
-            color: gray;
-            text-align: center;
-        }
-
-            .indexer-add-content > .glyphicon {
-                font-size: 50px;
-                vertical-align: bottom;
-            }
-
-            .indexer-add-content > .light-text {
-                margin-top: 11px;
-                font-size: 18px;
-                margin-left: -5px;
-            }
-
-
-        .indexer-host > input {
-            font-size: 12px;
-            padding: 2px;
-        }
-
-        .setup-item-inputstring {
-            max-width: 260px;
-        }
-
-        .spinner {
-            -webkit-animation: spin 2s infinite linear;
-            -moz-animation: spin 2s infinite linear;
-            -o-animation: spin 2s infinite linear;
-            animation: spin 2s infinite linear;
-        }
-
-        @-moz-keyframes spin {
-            from {
-                -moz-transform: rotate(0deg);
-            }
-
-            to {
-                -moz-transform: rotate(360deg);
-            }
-        }
-
-        @-webkit-keyframes spin {
-            from {
-                -webkit-transform: rotate(0deg);
-            }
-
-            to {
-                -webkit-transform: rotate(360deg);
-            }
-        }
-
-        @keyframes spin {
-            from {
-                transform: rotate(0deg);
-            }
-
-            to {
-                transform: rotate(360deg);
-            }
-        }
-
-        #setup-indexer-go {
-            width: 70px;
-        }
-
-        hr {
-            border-top-color: #cdcdcd;
-        }
-
-        .input-area {
-        }
-
-            .input-area > * {
-                vertical-align: middle;
-            }
-
-            .input-area > p {
-                margin-top: 10px;
-            }
-
-        .input-header {
-            font-size: 18px;
-            width: 140px;
-            display: inline-block;
-        }
-
-        .input-right {
-            width: 300px;
-            display: inline-block;
-            font-family: monospace;
-        }
-
-        #sonarr-warning {
-            display: none;
-        }
-
-        #logo {
-            max-width: 50px;
-        }
-
-        #header-title {
-            font-size: 34px;
-            vertical-align: middle;
-            padding-left: 15px;
-        }
-    </style>
-</head>
-<body>
-    <div id="page">
-
-        <img id="logo" src="jacket_medium.png" /><span id="header-title">Jackett</span>
-
-        <hr />
-
-        <div class="input-area">
-            <span class="input-header">Sonarr API Host: </span>
-            <input id="sonarr-host" class="form-control input-right" type="text" readonly />
-            <button id="sonarr-settings" class="btn btn-primary btn-sm">
-                Settings <span class="glyphicon glyphicon-wrench" aria-hidden="true"></span>
-            </button>
-            <button id="sonarr-test" class="btn btn-warning btn-sm">
-                Test <span class="glyphicon glyphicon-screenshot" aria-hidden="true"></span>
-            </button>
-            <p id="sonarr-warning" class="alert alert-danger" role="alert">
-                <span class="glyphicon glyphicon-exclamation-sign"></span>
-                Sonarr API must be configured
-            </p>
-        </div>
-
-        <hr />
-
-        <div class="input-area">
-            <span class="input-header">Jackett API Key: </span>
-            <input id="api-key-input" class="form-control input-right" type="text" value="" placeholder="API Key" readonly="">
-            <p>Use this key when adding indexers to Sonarr. This key works for all indexers.</p>
-        </div>
-
-        <hr />
-
-        <h3>Configured Indexers</h3>
-        <div id="indexers">
-
-
-
-        </div>
-
-    </div>
-
-    <div id="select-indexer-modal" class="modal fade" tabindex="-1" role="dialog" aria-hidden="true">
-        <div class="modal-dialog modal-lg">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                    <h4 class="modal-title">Select an indexer to setup</h4>
-                </div>
-                <div class="modal-body">
-                    <div id="unconfigured-indexers">
-                    </div>
-                    <hr />
-                    <p>
-                        To add a Jackett indexer in Sonarr go to <b>Settings > Indexers > Add > Torznab > Custom</b>
-                    </p>
-                </div>
-                <div class="modal-footer">
-                    <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <div id="modals"></div>
-
-    <div id="templates">
-
-        <div class="config-setup-modal modal fade" tabindex="-1" role="dialog" aria-hidden="true">
-            <div class="modal-dialog">
-                <div class="modal-content">
-                    <div class="modal-header">
-                        <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                        <h4 class="modal-title">{{title}}</h4>
-                    </div>
-                    <div class="modal-body">
-                        <form class="config-setup-form"></form>
-                    </div>
-                    <div class="modal-footer">
-                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
-                        <button type="button" class="btn btn-primary setup-indexer-go">Okay</button>
-                    </div>
-                </div>
-            </div>
-        </div>
-
-        <button class="indexer card add-indexer" data-toggle="modal" data-target="#select-indexer-modal">
-            <div class="indexer-add-content">
-                <span class="glyphicon glyphicon glyphicon-plus" aria-hidden="true"></span>
-                <div class="light-text">Add</div>
-            </div>
-        </button>
-
-        <div class="configured-indexer indexer card">
-            <div class="indexer-logo"><img src="logos/{{id}}.png" /></div>
-            <div class="indexer-name"><h3>{{name}}</h3></div>
-            <div class="indexer-buttons">
-                <button class="btn btn-primary btn-sm" data-id="{{id}}">
-                    <span class="glyphicon glyphicon-wrench" aria-hidden="true"></span>
-                </button>
-                <button class="btn btn-danger btn-sm indexer-button-delete" data-id="{{id}}">
-                    <span class="glyphicon glyphicon-trash" aria-hidden="true"></span>
-                </button>
-                <a class="btn btn-info btn-sm" target="_blank" href="{{site_link}}">
-                    <span class="glyphicon glyphicon-new-window" aria-hidden="true"></span>
-                </a>
-                <button class="btn btn-warning btn-sm indexer-button-test" data-id="{{id}}">
-                    Test <span class="glyphicon glyphicon-screenshot" aria-hidden="true"></span>
-                </button>
-            </div>
-            <div class="indexer-host">
-                <b>Torznab Host:</b>
-                <input class="form-control" type="text" value="{{torznab_host}}" placeholder="Torznab Host" readonly="">
-            </div>
-        </div>
-
-        <div class="unconfigured-indexer card">
-            <div class="indexer-logo"><img src="logos/{{id}}.png" /></div>
-            <div class="indexer-name"><h3>{{name}}</h3></div>
-            <div class="indexer-buttons">
-                <a class="btn btn-info" target="_blank" href="{{site_link}}">Visit <span class="glyphicon glyphicon-new-window" aria-hidden="true"></span></a>
-                <button class="indexer-setup btn btn-success" data-id="{{id}}">Setup <span class="glyphicon glyphicon-ok" aria-hidden="true"></span></button>
-            </div>
-        </div>
-
-
-        <div class="setup-item form-group" data-id="{{id}}" data-value="{{value}}" data-type="{{type}}">
-            <div class="setup-item-label">{{name}}</div>
-            <div class="setup-item-value">{{{value_element}}}</div>
-        </div>
-
-        <input class="setup-item-inputstring form-control" type="text" value="{{{value}}}" />
-        <div class="setup-item-checkbox">
-            {{#if value}}
-            <input type="checkbox" class="form-control" checked />
-            {{else}}
-            <input type="checkbox" class="form-control" />
-            {{/if}}
-        </div>
-        <img class="setup-item-displayimage" src="{{{value}}}" />
-        <div class="setup-item-displayinfo alert alert-info" role="alert">{{{value}}}</div>
-
-        <span class="spinner glyphicon glyphicon-refresh"></span>
-
-    </div>
-
-    <script>
-
-
-        reloadIndexers();
-        loadSonarrInfo();
-
-        function loadSonarrInfo() {
-            getSonarrConfig(function (data) {
-                $("#sonarr-host").val("");
-                var host, port, apiKey;
-                for (var i = 0; i < data.config.length; i++) {
-                    if (data.config[i].id == "host")
-                        host = data.config[i].value;
-                    if (data.config[i].id == "port")
-                        port = data.config[i].value;
-                    if (data.config[i].id == "apikey")
-                        apiKey = data.config[i].value;
-                }
-                if (!apiKey)
-                    $("#sonarr-warning").show();
-                else {
-                    $("#sonarr-warning").hide();
-                    $("#sonarr-host").val(host + ":" + port);
-                }
-            });
-        }
-
-        function getSonarrConfig(callback) {
-            var jqxhr = $.get("get_sonarr_config", function (data) {
-                callback(data);
-            }).fail(function () {
-                doNotify("Error loading Sonarr API configuration, request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
-            });
-        }
-
-        $("#sonarr-test").click(function () {
-            var jqxhr = $.get("get_indexers", function (data) {
-                if (data.result == "error")
-                    doNotify("Test failed for Sonarr API\n" + data.error, "danger", "glyphicon glyphicon-alert");
-                else
-                    doNotify("Test successful for Sonarr API", "success", "glyphicon glyphicon-ok");
-            }).fail(function () {
-                doNotify("Error testing Sonarr, request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
-            });
-        });
-
-        $("#sonarr-settings").click(function () {
-            getSonarrConfig(function (data) {
-                var config = data.config;
-
-                var configForm = newConfigModal("Sonarr API", config);
-
-                var $goButton = configForm.find(".setup-indexer-go");
-                $goButton.click(function () {
-                    var data = getConfigModalJson(configForm);
-
-                    var originalBtnText = $goButton.html();
-                    $goButton.prop('disabled', true);
-                    $goButton.html($('#templates > .spinner')[0].outerHTML);
-
-                    var jqxhr = $.post("apply_sonarr_config", JSON.stringify(data), function (data) {
-                        if (data.result == "error") {
-                            if (data.config) {
-                                populateSetupForm(data.indexer, data.name, data.config);
-                            }
-                            doNotify("Configuration failed: " + data.error, "danger", "glyphicon glyphicon-alert");
-                        }
-                        else {
-                            configForm.modal("hide");
-                            loadSonarrInfo();
-                            doNotify("Successfully configured Sonarr API", "success", "glyphicon glyphicon-ok");
-                        }
-                    }).fail(function () {
-                        doNotify("Request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
-                    }).always(function () {
-                        $goButton.html(originalBtnText);
-                        $goButton.prop('disabled', false);
-                    });
-                });
-
-                configForm.modal("show");
-
-            });
-        });
-
-
-        function reloadIndexers() {
-            $('#indexers').hide();
-            $('#indexers > .indexer').remove();
-            $('#unconfigured-indexers').empty();
-            var jqxhr = $.get("get_indexers", function (data) {
-                $("#api-key-input").val(data.api_key);
-                displayIndexers(data.items);
-            }).fail(function () {
-                doNotify("Error loading indexers, request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
-            });
-        }
-
-        function displayIndexers(items) {
-            var indexerTemplate = Handlebars.compile($("#templates > .configured-indexer")[0].outerHTML);
-            var unconfiguredIndexerTemplate = Handlebars.compile($("#templates > .unconfigured-indexer")[0].outerHTML);
-            for (var i = 0; i < items.length; i++) {
-                var item = items[i];
-                item.torznab_host = resolveUrl("/api/" + item.id);
-                if (item.configured)
-                    $('#indexers').append(indexerTemplate(item));
-                else
-                    $('#unconfigured-indexers').append($(unconfiguredIndexerTemplate(item)));
-            }
-
-            var addIndexerButton = $("#templates > .add-indexer")[0].outerHTML;
-            $('#indexers').append(addIndexerButton);
-
-            $('#indexers').fadeIn();
-            prepareSetupButtons();
-            prepareTestButtons();
-            prepareDeleteButtons();
-        }
-
-        function prepareDeleteButtons() {
-            $(".indexer-button-delete").each(function (i, btn) {
-                var $btn = $(btn);
-                var id = $btn.data("id");
-                $btn.click(function () {
-                    var jqxhr = $.post("delete_indexer", JSON.stringify({ indexer: id }), function (data) {
-                        if (data.result == "error") {
-                            doNotify("Delete error for " + id + "\n" + data.error, "danger", "glyphicon glyphicon-alert");
-                        }
-                        else {
-                            doNotify("Deleted " + id, "success", "glyphicon glyphicon-ok");
-                        }
-                    }).fail(function () {
-                        doNotify("Error deleting indexer, request to Jackett server error", "danger", "glyphicon glyphicon-alert");
-                    }).always(function () {
-                        reloadIndexers();
-                    });
-                });
-            });
-        }
-
-        function prepareSetupButtons() {
-            $('.indexer-setup').each(function (i, btn) {
-                var $btn = $(btn);
-                var id = $btn.data("id");
-                $btn.click(function () {
-                    displayIndexerSetup(id);
-                });
-            });
-        }
-
-        function prepareTestButtons() {
-            $(".indexer-button-test").each(function (i, btn) {
-                var $btn = $(btn);
-                var id = $btn.data("id");
-                $btn.click(function () {
-                    doNotify("Test started for " + id, "info", "glyphicon glyphicon-transfer");
-                    var jqxhr = $.post("test_indexer", JSON.stringify({ indexer: id }), function (data) {
-                        if (data.result == "error") {
-                            doNotify("Test failed for " + data.name + "\n" + data.error, "danger", "glyphicon glyphicon-alert");
-                        }
-                        else {
-                            doNotify("Test successful for " + data.name, "success", "glyphicon glyphicon-ok");
-                        }
-                    }).fail(function () {
-                        doNotify("Error testing indexer, request to Jackett server error", "danger", "glyphicon glyphicon-alert");
-                    });
-                });
-            });
-        }
-
-        function displayIndexerSetup(id) {
-
-            var jqxhr = $.post("get_config_form", JSON.stringify({ indexer: id }), function (data) {
-                if (data.result == "error") {
-                    doNotify("Error: " + data.error, "danger", "glyphicon glyphicon-alert");
-                    return;
-                }
-                populateSetupForm(id, data.name, data.config);
-
-            }).fail(function () {
-                doNotify("Request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
-            });
-
-            $("#select-indexer-modal").modal("hide");
-        }
-
-        function populateConfigItems(configForm, config) {
-            var $formItemContainer = configForm.find(".config-setup-form");
-            $formItemContainer.empty();
-            var setupItemTemplate = Handlebars.compile($("#templates > .setup-item")[0].outerHTML);
-            for (var i = 0; i < config.length; i++) {
-                var item = config[i];
-                var setupValueTemplate = Handlebars.compile($("#templates > .setup-item-" + item.type)[0].outerHTML);
-                item.value_element = setupValueTemplate(item);
-                $formItemContainer.append(setupItemTemplate(item));
-            }
-        }
-
-        function newConfigModal(title, config) {
-            //config-setup-modal
-            var configTemplate = Handlebars.compile($("#templates > .config-setup-modal")[0].outerHTML);
-            var configForm = $(configTemplate({ title: title }));
-
-            $("#modals").append(configForm);
-
-            populateConfigItems(configForm, config);
-
-            return configForm;
-            //modal.remove();
-        }
-
-        function getConfigModalJson(configForm) {
-            var configJson = {};
-            configForm.find(".config-setup-form").children().each(function (i, el) {
-                $el = $(el);
-                var type = $el.data("type");
-                var id = $el.data("id");
-                switch (type) {
-                    case "inputstring":
-                        configJson[id] = $el.find(".setup-item-inputstring").val();
-                        break;
-                    case "inputbool":
-                        configJson[id] = $el.find(".setup-item-checkbox").val();
-                        break;
-                }
-            });
-            return configJson;
-        }
-
-        function populateSetupForm(indexerId, name, config) {
-
-            var configForm = newConfigModal(name, config);
-
-            var $goButton = configForm.find(".setup-indexer-go");
-            $goButton.click(function () {
-                var data = { indexer: indexerId, name: name };
-                data.config = getConfigModalJson(configForm);
-
-                var originalBtnText = $goButton.html();
-                $goButton.prop('disabled', true);
-                $goButton.html($('#templates > .spinner')[0].outerHTML);
-
-                var jqxhr = $.post("configure_indexer", JSON.stringify(data), function (data) {
-                    if (data.result == "error") {
-                        if (data.config) {
-                            populateConfigItems(configForm, data.config);
-                        }
-                        doNotify("Configuration failed: " + data.error, "danger", "glyphicon glyphicon-alert");
-                    }
-                    else {
-                        configForm.modal("hide");
-                        reloadIndexers();
-                        doNotify("Successfully configured " + data.name, "success", "glyphicon glyphicon-ok");
-                    }
-                }).fail(function () {
-                    doNotify("Request to Jackett server failed", "danger", "glyphicon glyphicon-alert");
-                }).always(function () {
-                    $goButton.html(originalBtnText);
-                    $goButton.prop('disabled', false);
-                });
-            });
-
-            configForm.modal("show");
-        }
-
-        function resolveUrl(url) {
-            var a = document.createElement('a');
-            a.href = url;
-            url = a.href;
-            return url;
-        }
-
-
-
-        function doNotify(message, type, icon) {
-            $.notify({
-                message: message,
-                icon: icon
-            }, {
-                element: 'body',
-                type: type,
-                allow_dismiss: true,
-                z_index: 9000,
-                mouse_over: 'pause',
-                placement: {
-                    from: "bottom",
-                    align: "center"
-                }
-            });
-        }
-
-        function clearNotifications() {
-            $('[data-notify="container"]').remove();
-        }
-
-        $('#test').click(doNotify);
-
-
-    </script>
-
-</body>
+<!DOCTYPE html>
+
+<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
+<head>
+    <meta charset="utf-8" />
+
+    <link rel='shortcut icon' type='image/x-icon' href='/favicon.ico' />
+
+    <script src="jquery-2.1.3.min.js"></script>
+    <script src="handlebars-v3.0.1.js"></script>
+    <script src="bootstrap/bootstrap.min.js"></script>
+    <script src="bootstrap-notify.js"></script>
+
+    <link href="bootstrap/bootstrap.min.css" rel="stylesheet">
+    <link href="animate.css" rel="stylesheet">
+    <link href="custom.css" rel="stylesheet">
+
+    <title>Jackett</title>
+</head>
+<body>
+    <div id="page">
+
+        <img id="logo" src="jacket_medium.png" /><span id="header-title">Jackett</span>
+
+        <hr />
+
+        <div class="input-area">
+            <span class="input-header">Sonarr API Host: </span>
+            <input id="sonarr-host" class="form-control input-right" type="text" readonly />
+            <button id="sonarr-settings" class="btn btn-primary btn-sm">
+                Settings <span class="glyphicon glyphicon-wrench" aria-hidden="true"></span>
+            </button>
+            <button id="sonarr-test" class="btn btn-warning btn-sm">
+                Test <span class="glyphicon glyphicon-screenshot" aria-hidden="true"></span>
+            </button>
+            <p id="sonarr-warning" class="alert alert-danger" role="alert">
+                <span class="glyphicon glyphicon-exclamation-sign"></span>
+                Sonarr API must be configured
+            </p>
+        </div>
+
+        <hr />
+
+        <div class="input-area">
+            <span class="input-header">Jackett API Key: </span>
+            <input id="api-key-input" class="form-control input-right" type="text" value="" placeholder="API Key" readonly="">
+            <p>Use this key when adding indexers to Sonarr. This key works for all indexers.</p>
+        </div>
+
+        <hr />
+
+        <h3>Configured Indexers</h3>
+        <div id="indexers">
+
+
+
+        </div>
+
+        <hr />
+
+        <div id="footer">
+            Jackett Version <span id="app-version"></span>
+        </div>
+
+
+    </div>
+
+    <div id="select-indexer-modal" class="modal fade" tabindex="-1" role="dialog" aria-hidden="true">
+        <div class="modal-dialog modal-lg">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
+                    <h4 class="modal-title">Select an indexer to setup</h4>
+                </div>
+                <div class="modal-body">
+                    <div id="unconfigured-indexers">
+                    </div>
+                    <hr />
+                    <p>
+                        To add a Jackett indexer in Sonarr go to <b>Settings > Indexers > Add > Torznab > Custom</b>
+                    </p>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div id="modals"></div>
+
+    <div id="templates">
+
+        <div class="config-setup-modal modal fade" tabindex="-1" role="dialog" aria-hidden="true">
+            <div class="modal-dialog">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
+                        <h4 class="modal-title">{{title}}</h4>
+                    </div>
+                    <div class="modal-body">
+                        <form class="config-setup-form"></form>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
+                        <button type="button" class="btn btn-primary setup-indexer-go">Okay</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <button class="indexer card add-indexer" data-toggle="modal" data-target="#select-indexer-modal">
+            <div class="indexer-add-content">
+                <span class="glyphicon glyphicon glyphicon-plus" aria-hidden="true"></span>
+                <div class="light-text">Add</div>
+            </div>
+        </button>
+
+        <div class="configured-indexer indexer card">
+            <div class="indexer-logo"><img src="logos/{{id}}.png" /></div>
+            <div class="indexer-name"><h3>{{name}}</h3></div>
+            <div class="indexer-buttons">
+                <button class="btn btn-primary btn-sm indexer-setup" data-id="{{id}}">
+                    <span class="glyphicon glyphicon-wrench" aria-hidden="true"></span>
+                </button>
+                <button class="btn btn-danger btn-sm indexer-button-delete" data-id="{{id}}">
+                    <span class="glyphicon glyphicon-trash" aria-hidden="true"></span>
+                </button>
+                <a class="btn btn-info btn-sm" target="_blank" href="{{site_link}}">
+                    <span class="glyphicon glyphicon-new-window" aria-hidden="true"></span>
+                </a>
+                <button class="btn btn-warning btn-sm indexer-button-test" data-id="{{id}}">
+                    Test <span class="glyphicon glyphicon-screenshot" aria-hidden="true"></span>
+                </button>
+            </div>
+            <div class="indexer-host">
+                <b>Torznab Host:</b>
+                <input class="form-control" type="text" value="{{torznab_host}}" placeholder="Torznab Host" readonly="">
+            </div>
+        </div>
+
+        <div class="unconfigured-indexer card">
+            <div class="indexer-logo"><img src="logos/{{id}}.png" /></div>
+            <div class="indexer-name"><h3>{{name}}</h3></div>
+            <div class="indexer-buttons">
+                <a class="btn btn-info" target="_blank" href="{{site_link}}">Visit <span class="glyphicon glyphicon-new-window" aria-hidden="true"></span></a>
+                <button class="indexer-setup btn btn-success" data-id="{{id}}">Setup <span class="glyphicon glyphicon-ok" aria-hidden="true"></span></button>
+            </div>
+        </div>
+
+
+        <div class="setup-item form-group" data-id="{{id}}" data-value="{{value}}" data-type="{{type}}">
+            <div class="setup-item-label">{{name}}</div>
+            <div class="setup-item-value">{{{value_element}}}</div>
+        </div>
+
+        <input class="setup-item-inputstring form-control" type="text" value="{{{value}}}" />
+        <div class="setup-item-inputbool">
+            {{#if value}}
+            <input type="checkbox" data-id="{{id}}" class="form-control" checked />
+            {{else}}
+            <input type="checkbox" data-id="{{id}}" class="form-control" />
+            {{/if}}
+        </div>
+        <img class="setup-item-displayimage" src="{{{value}}}" />
+        <div class="setup-item-displayinfo alert alert-info" role="alert">{{{value}}}</div>
+
+        <span class="spinner glyphicon glyphicon-refresh"></span>
+
+
+    </div>
+
+
+    <script src="custom.js"></script>
+
+</body>
 </html>

src/Jackett/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="CsQuery" version="1.3.4" targetFramework="net451" />
-  <package id="modernhttpclient" version="2.3.0" targetFramework="net451" />
-  <package id="Newtonsoft.Json" version="6.0.8" targetFramework="net451" />
-  <package id="NLog" version="3.2.0.0" targetFramework="net451" />
+  <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net451" />
+  <package id="NLog" version="4.0.1" targetFramework="net451" />
+  <package id="NLog.Windows.Forms" version="2.0.0.0" targetFramework="net451" />
 </packages>