Added SceneFZ tracker (#319)

* Added SceneFZ tracker
* SceneFZ tracker new logo size and updated README

README.md

@@ -29,21 +29,25 @@ Developer note: The software implements the [Torznab](https://github.com/Sonarr/
  * Demonoid
  * EuTorrents
  * FileList
- * Fnt
  * French-ADN
  * Freshon
+ * Fuzer
  * HD-Space
  * HD-Torrents
  * Hounddawgs
+ * ILoveTorrents
  * Immortalseed
  * IPTorrents
  * MoreThanTV
+ * MyAnonamouse
  * NCore
  * NextGen
+ * PhxBit
  * Pretome
  * PrivateHD
  * RevolutionTT
  * SceneAccess
+ * SceneFZ
  * SceneTime
  * Shazbat
  * SpeedCD
@@ -55,6 +59,7 @@ Developer note: The software implements the [Torznab](https://github.com/Sonarr/
  * TV Chaos UK
  * World-In-HD
  * XSpeeds
+ * Xthor
 
 #### Installation on Windows
 

src/Jackett/Controllers/PotatoController.cs

@@ -99,7 +99,8 @@ namespace Jackett.Controllers
             {
                 ApiKey =  request.passkey,
                 Categories = MOVIE_CATS,
-                SearchTerm = request.search
+                SearchTerm = request.search,
+                ImdbID = request.imdbid
             };
 
             IEnumerable<ReleaseInfo> releases = new List<ReleaseInfo>();

src/Jackett/Indexers/BaseIndexer.cs

@@ -436,43 +436,23 @@ namespace Jackett.Indexers
             }
         }
 
-        protected void AddCategoryMapping(string trackerCategory, int newznabCategory)
+        protected void AddCategoryMapping(string trackerCategory, TorznabCategory newznabCategory)
         {
-            categoryMapping.Add(new CategoryMapping(trackerCategory, newznabCategory));
+            categoryMapping.Add(new CategoryMapping(trackerCategory, newznabCategory.ID));
+            if (!TorznabCaps.Categories.Contains(newznabCategory))
+                TorznabCaps.Categories.Add(newznabCategory);
         }
 
         protected void AddCategoryMapping(int trackerCategory, TorznabCategory newznabCategory)
         {
-            categoryMapping.Add(new CategoryMapping(trackerCategory.ToString(), newznabCategory.ID));
-            if (!TorznabCaps.Categories.Contains(newznabCategory))
-                TorznabCaps.Categories.Add(newznabCategory);
-        }
-
-        protected void AddCategoryMapping(string trackerCategory, TorznabCategory newznabCategory)
-        {
-            categoryMapping.Add(new CategoryMapping(trackerCategory.ToString(), newznabCategory.ID));
-            if (!TorznabCaps.Categories.Contains(newznabCategory))
-                TorznabCaps.Categories.Add(newznabCategory);
-        }
-
-        protected void AddCategoryMapping(int trackerCategory, int newznabCategory)
-        {
-            categoryMapping.Add(new CategoryMapping(trackerCategory.ToString(), newznabCategory));
+            AddCategoryMapping(trackerCategory.ToString(), newznabCategory);
         }
 
         protected void AddMultiCategoryMapping(TorznabCategory newznabCategory, params int[] trackerCategories)
         {
             foreach (var trackerCat in trackerCategories)
             {
-                categoryMapping.Add(new CategoryMapping(trackerCat.ToString(), newznabCategory.ID));
-            }
-        }
-
-        protected void AddMultiCategoryMapping(int trackerCategory, params TorznabCategory[] newznabCategories)
-        {
-            foreach (var newznabCat in newznabCategories)
-            {
-                categoryMapping.Add(new CategoryMapping(trackerCategory.ToString(), newznabCat.ID));
+                AddCategoryMapping(trackerCat, newznabCategory);
             }
         }
 

src/Jackett/Indexers/BitMeTV.cs

@@ -42,7 +42,7 @@ namespace Jackett.Indexers
                 client: c,
                 logger: l,
                 p: ps,
-                configData: new ConfigurationDataCaptchaLogin())
+                configData: new ConfigurationDataCaptchaLogin("Ensure that you have the 'Force SSL' option set to 'yes' in your profile on the BitMeTv webpage."))
         {
         }
 

src/Jackett/Indexers/BitSoup.cs

@@ -25,12 +25,12 @@ namespace Jackett.Indexers
         private string UseLink { get { return (this.configData.AlternateLink.Value != null && this.configData.AlternateLink.Value != "" ? this.configData.AlternateLink.Value : SiteLink); } }
         private string BrowseUrl { get { return UseLink + "browse.php"; } }
         private string LoginUrl { get { return UseLink + "takelogin.php"; } }
-        private string LoginReferer {  get { return UseLink + "login.php";  } }
-        private List<String> KnownURLs = new List<String>{ "https://www.bitsoup.me/","https://www.bitsoup.org/"};
+        private string LoginReferer { get { return UseLink + "login.php"; } }
+        private List<String> KnownURLs = new List<String> { "https://www.bitsoup.me/", "https://www.bitsoup.org/" };
 
-        new NxtGnConfigurationData configData
+        new ConfigurationDataBasicLoginWithAlternateLink configData
         {
-            get { return (NxtGnConfigurationData)base.configData; }
+            get { return (ConfigurationDataBasicLoginWithAlternateLink)base.configData; }
             set { base.configData = value; }
         }
 
@@ -43,11 +43,11 @@ namespace Jackett.Indexers
                 client: wc,
                 logger: l,
                 p: ps,
-                configData: new NxtGnConfigurationData())
+                configData: new ConfigurationDataBasicLoginWithAlternateLink())
         {
-            this.configData.DisplayText.Value = this.DisplayName + " has multiple URLs.  The default (" + this.SiteLink + ") can be changed by entering a new value in the box below.";
-            this.configData.DisplayText.Value += "The following are some known URLs for " + this.DisplayName;
-            this.configData.DisplayText.Value += "<ul><li>" + String.Join("</li><li>", this.KnownURLs.ToArray()) + "</li></ul>";
+            this.configData.Instructions.Value = this.DisplayName + " has multiple URLs.  The default (" + this.SiteLink + ") can be changed by entering a new value in the box below.";
+            this.configData.Instructions.Value += "The following are some known URLs for " + this.DisplayName;
+            this.configData.Instructions.Value += "<ul><li>" + String.Join("</li><li>", this.KnownURLs.ToArray()) + "</li></ul>";
 
             //AddCategoryMapping("624", TorznabCatType.Console);
             //AddCategoryMapping("307", TorznabCatType.ConsoleNDS);
@@ -158,12 +158,12 @@ namespace Jackett.Indexers
                 {
                     configData.AlternateLink.Value = null;
                     throw new Exception("AlternateLink must be a valid url.");
-                }              
+                }
             }
             var pairs = new Dictionary<string, string> {
                 { "username", configData.Username.Value },
                 { "password", configData.Password.Value },
-                
+
             };
 
             var loginPage = await RequestStringWithCookies(UseLink, string.Empty);
@@ -188,11 +188,12 @@ namespace Jackett.Indexers
             var queryCollection = new NameValueCollection();
 
 
-            queryCollection.Add("search", string.IsNullOrWhiteSpace(searchString)? "" : searchString);
+            queryCollection.Add("search", string.IsNullOrWhiteSpace(searchString) ? "" : searchString);
             if (trackerCats.Count > 1)
             {
-               for (var ct = 0; ct < trackerCats.Count; ct++) queryCollection.Add("cat" + (ct+1), trackerCats.ElementAt(ct));
-            } else
+                for (var ct = 0; ct < trackerCats.Count; ct++) queryCollection.Add("cat" + (ct + 1), trackerCats.ElementAt(ct));
+            }
+            else
             {
                 queryCollection.Add("cat", (trackerCats.Count == 1 ? trackerCats.ElementAt(0) : "0"));
             }
@@ -242,23 +243,5 @@ namespace Jackett.Indexers
                 OnParseError(results, ex);
             }
         }
-
-        public class NxtGnConfigurationData : ConfigurationData
-        {
-            public StringItem Username { get; private set; }
-            public StringItem Password { get; private set; }
-            public DisplayItem DisplayText { get; private set; }
-            public StringItem AlternateLink { get; set; }
-           
-
-            public NxtGnConfigurationData()
-            {
-                Username = new StringItem { Name = "Username" };
-                Password = new StringItem { Name = "Password" };
-                DisplayText = new DisplayItem("") { Name = "" };
-                AlternateLink = new StringItem { Name = "AlternateLinks" };
-            }
-            
-        }
     }
-}
+}

src/Jackett/Indexers/DanishBits.cs

@@ -1,8 +1,6 @@
 using CsQuery;
-using Jackett.Indexers;
 using Jackett.Models;
 using Jackett.Services;
-using Jackett.Utils;
 using Jackett.Utils.Clients;
 using Newtonsoft.Json.Linq;
 using NLog;
@@ -10,14 +8,9 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Net.Http.Headers;
-using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using System.Web;
-using System.Web.UI.WebControls;
 using CsQuery.ExtensionMethods;
 using Jackett.Models.IndexerConfig;
 
@@ -38,7 +31,7 @@ namespace Jackett.Indexers
             : base(name: "DanishBits",
                 description: "A danish closed torrent tracker",
                 link: "https://danishbits.org/",
-                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
+                caps: new TorznabCapabilities(),
                 manager: i,
                 client: c,
                 logger: l,
@@ -151,6 +144,13 @@ namespace Jackett.Indexers
 
         public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
         {
+            TimeZoneInfo.TransitionTime startTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 2, 0, 0), 3, 5, DayOfWeek.Sunday);
+            TimeZoneInfo.TransitionTime endTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 3, 0, 0), 10, 5, DayOfWeek.Sunday);
+            TimeSpan delta = new TimeSpan(1, 0, 0);
+            TimeZoneInfo.AdjustmentRule adjustment = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(1999, 10, 1), DateTime.MaxValue.Date, delta, startTransition, endTransition);
+            TimeZoneInfo.AdjustmentRule[] adjustments = { adjustment };
+            TimeZoneInfo denmarkTz = TimeZoneInfo.CreateCustomTimeZone("Denmark Time", new TimeSpan(1, 0, 0), "(GMT+01:00) Denmark Time", "Denmark Time", "Denmark DST", adjustments);
+
             var releasesPerPage = 100;
             var releases = new List<ReleaseInfo>();
 
@@ -244,9 +244,8 @@ namespace Jackett.Indexers
 
                     var addedElement = qRow.Find("span.time").FirstElement();
                     var addedStr = addedElement.GetAttribute("title");
-                    release.PublishDate = DateTime.ParseExact(addedStr, "MMM dd yyyy, HH:mm",
-                        CultureInfo.InvariantCulture);
-
+                    release.PublishDate = TimeZoneInfo.ConvertTimeToUtc(DateTime.ParseExact(addedStr, "MMM dd yyyy, HH:mm", CultureInfo.InvariantCulture), denmarkTz).ToLocalTime();
+                    
                     var columns = qRow.Children();
                     var seedersElement = columns.Reverse().Skip(1).First();
                     release.Seeders = int.Parse(seedersElement.InnerText);

src/Jackett/Indexers/Fuzer.cs

@@ -0,0 +1,295 @@
+using CsQuery;
+using Jackett.Models;
+using Jackett.Services;
+using Jackett.Utils;
+using Jackett.Utils.Clients;
+using Newtonsoft.Json.Linq;
+using NLog;
+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 Jackett.Models.IndexerConfig;
+using System.Collections.Specialized;
+using System.Threading;
+
+namespace Jackett.Indexers
+{
+    public class Fuzer : BaseIndexer, IIndexer
+    {
+        private string SearchUrl { get { return SiteLink + "index.php?name=torrents&"; } }
+        private string LoginUrl { get { return SiteLink + "login.php"; } }
+        private const int MAXPAGES = 3;
+
+        new ConfigurationDataBasicLogin configData
+        {
+            get { return (ConfigurationDataBasicLogin)base.configData; }
+            set { base.configData = value; }
+        }
+
+        public Fuzer(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
+            : base(name: "Fuzer",
+                description: "Fuzer is a private torrent website with israeli torrents.",
+                link: "https://fuzer.me/",
+                manager: i,
+                client: w,
+                logger: l,
+                p: ps,
+                configData: new ConfigurationDataBasicLogin())
+        {
+            TorznabCaps.Categories.Clear();
+
+            AddMultiCategoryMapping(TorznabCatType.Movies, 7, 9, 58, 59, 60, 61, 83);
+            AddMultiCategoryMapping(TorznabCatType.MoviesSD, 7, 58);
+            AddMultiCategoryMapping(TorznabCatType.MoviesHD, 9, 59, 61);
+            AddMultiCategoryMapping(TorznabCatType.MoviesBluRay, 59);
+            AddMultiCategoryMapping(TorznabCatType.MoviesForeign, 83);
+            AddMultiCategoryMapping(TorznabCatType.MoviesDVD, 58);
+            AddMultiCategoryMapping(TorznabCatType.Movies3D, 9);
+            AddMultiCategoryMapping(TorznabCatType.MoviesWEBDL, 9);
+            AddMultiCategoryMapping(TorznabCatType.TV, 8, 10, 62, 63, 84);
+            AddMultiCategoryMapping(TorznabCatType.TVHD, 10, 63);
+            AddMultiCategoryMapping(TorznabCatType.TVFOREIGN, 62, 84);
+            AddMultiCategoryMapping(TorznabCatType.TVSport, 64);
+            AddMultiCategoryMapping(TorznabCatType.TVAnime, 65);
+            AddMultiCategoryMapping(TorznabCatType.TVWEBDL, 10, 63);
+            AddMultiCategoryMapping(TorznabCatType.TVSD, 8, 62, 84);
+            AddMultiCategoryMapping(TorznabCatType.TVDocumentary, 8, 10, 62, 63);
+            AddMultiCategoryMapping(TorznabCatType.Console, 12, 55, 56, 57);
+            AddMultiCategoryMapping(TorznabCatType.ConsoleXbox, 55);
+            AddMultiCategoryMapping(TorznabCatType.ConsoleXbox360, 55);
+            AddMultiCategoryMapping(TorznabCatType.ConsoleXBOX360DLC, 55);
+            AddMultiCategoryMapping(TorznabCatType.ConsolePS3, 12);
+            AddMultiCategoryMapping(TorznabCatType.ConsolePS4, 12);
+            AddMultiCategoryMapping(TorznabCatType.ConsoleXboxOne, 55);
+            AddMultiCategoryMapping(TorznabCatType.ConsolePS4, 12);
+            AddMultiCategoryMapping(TorznabCatType.ConsoleWii, 56);
+            AddMultiCategoryMapping(TorznabCatType.ConsoleWiiwareVC, 56);
+            AddMultiCategoryMapping(TorznabCatType.ConsolePSP, 57);
+            AddMultiCategoryMapping(TorznabCatType.ConsoleNDS, 57);
+            AddMultiCategoryMapping(TorznabCatType.MoviesOther, 57);
+            AddMultiCategoryMapping(TorznabCatType.PC, 11, 15);
+            AddMultiCategoryMapping(TorznabCatType.PCGames, 11);
+            AddMultiCategoryMapping(TorznabCatType.PCMac, 71);
+            AddMultiCategoryMapping(TorznabCatType.PCPhoneAndroid, 13);
+            AddMultiCategoryMapping(TorznabCatType.PCPhoneIOS, 70);
+            AddMultiCategoryMapping(TorznabCatType.Audio, 14, 66, 67, 68);
+            AddMultiCategoryMapping(TorznabCatType.AudioForeign, 14);
+            AddMultiCategoryMapping(TorznabCatType.AudioLossless, 67);
+            AddMultiCategoryMapping(TorznabCatType.AudioAudiobook, 69);
+            AddMultiCategoryMapping(TorznabCatType.AudioOther, 68);
+            AddMultiCategoryMapping(TorznabCatType.Other, 17);
+            AddMultiCategoryMapping(TorznabCatType.XXX, 16);
+        }
+
+        public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
+        {
+            configData.LoadValuesFromJson(configJson);
+            var loginPage = await RequestStringWithCookies(LoginUrl, string.Empty);
+
+            var pairs = new Dictionary<string, string> {
+                { "vb_login_username", configData.Username.Value },
+                { "vb_login_password", "" },
+                { "securitytoken", "guest" },
+                { "do","login"},
+                { "vb_login_md5password", StringUtil.Hash(configData.Password.Value).ToLower()},
+                { "vb_login_md5password_utf", StringUtil.Hash(configData.Password.Value).ToLower()},
+                { "cookieuser", "1" }
+            };
+
+            var result = await RequestLoginAndFollowRedirect(LoginUrl, pairs, loginPage.Cookies, true, null, LoginUrl);
+
+            await ConfigureIfOK(result.Cookies, result.Content != null && result.Content.Contains("images/loading.gif"), () =>
+            {
+                var errorMessage = "Couldn't login";
+                throw new ExceptionWithConfigData(errorMessage, configData);
+            });
+            Thread.Sleep(2);
+            return IndexerConfigurationStatus.RequiresTesting;
+        }
+
+        public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
+        {
+            var results = await performRegularQuery(query);
+            if (results.Count() == 0)
+            {
+                return await performHebrewQuery(query);
+            }
+
+            return results;
+        }
+
+        private async Task<IEnumerable<ReleaseInfo>> performHebrewQuery(TorznabQuery query)
+        {
+            var name = await getHebName(query.SearchTerm);
+
+            if (string.IsNullOrEmpty(name))
+            {
+                return new List<ReleaseInfo>();
+            }
+            else
+            {
+                return await performRegularQuery(query, name);
+            }
+        }
+
+        private async Task<IEnumerable<ReleaseInfo>> performRegularQuery(TorznabQuery query, string hebName = null)
+        {
+            var releases = new List<ReleaseInfo>();
+            var searchurls = new List<string>();
+            var searchUrl = SearchUrl;
+            var queryCollection = new NameValueCollection();
+            var searchString = query.GetQueryString();
+
+            if (hebName != null)
+            {
+                searchString = hebName + " - עונה " + query.Season + " פרק " + query.Episode;
+            }
+
+            int categoryCounter = 1;
+            foreach (var cat in MapTorznabCapsToTrackers(query))
+            {
+                searchUrl += "c" + categoryCounter.ToString() + "=" + cat + "&";
+                categoryCounter++;
+            }
+
+
+            if (string.IsNullOrWhiteSpace(searchString))
+            {
+                searchUrl = SiteLink + "index.php?name=torrents";
+            }
+            else
+            {
+                var strEncoded = HttpUtility.UrlEncode(searchString, Encoding.GetEncoding("Windows-1255"));
+                searchUrl += "text=" + strEncoded + "&category=0&search=1";
+            }
+
+            var data = await RequestBytesWithCookiesAndRetry(searchUrl);
+            var results = Encoding.GetEncoding("Windows-1255").GetString(data.Content);
+            try
+            {
+                CQ dom = results;
+                ReleaseInfo release;
+
+                int rowCount = 0;
+                var rows = dom["#collapseobj_module_17 > tr"];
+                foreach (var row in rows)
+                {
+                    CQ qRow = row.Cq();
+                    if (rowCount < 1 || qRow.Children().Count() != 9) //skip 1 row because there's an empty row 
+                    {
+                        rowCount++;
+                        continue;
+                    }
+
+                    release = new ReleaseInfo();
+                    release.Description = qRow.Find("td:nth-child(2) > a").Text(); ;
+
+                    if (hebName != null)
+                    {
+                        release.Title = query.SearchTerm + " " + release.Description.Substring(release.Description.IndexOf(string.Format("S{0:D2}E{1:D2}", query.Season, int.Parse(query.Episode))));
+                    }
+                    else
+                    {
+                        const string DELIMITER = " | ";
+                        release.Title = release.Description.Substring(release.Description.IndexOf(DELIMITER) + DELIMITER.Length);
+                    }
+
+                    release.MinimumRatio = 1;
+                    release.MinimumSeedTime = 172800;
+
+                    int seeders, peers;
+                    if (ParseUtil.TryCoerceInt(qRow.Find("td:nth-child(7) > div").Text(), out seeders))
+                    {
+                        release.Seeders = seeders;
+                        if (ParseUtil.TryCoerceInt(qRow.Find("td:nth-child(8) > div").Text(), out peers))
+                        {
+                            release.Peers = peers + release.Seeders;
+                        }
+                    }
+
+                    string fullSize = qRow.Find("td:nth-child(5) > div").Text();
+                    release.Size = ReleaseInfo.GetBytes(fullSize);
+
+                    release.Guid = new Uri(qRow.Find("td:nth-child(2) > a").Attr("href"));
+                    release.Link = new Uri(SiteLink + qRow.Find("td:nth-child(3) > a").Attr("href"));
+                    release.Comments = release.Guid;
+
+                    string[] dateSplit = qRow.Find("td:nth-child(2) > span.torrentstime").Text().Split(' ');
+                    string dateString = dateSplit[1] + " " + dateSplit[3];
+                    release.PublishDate = DateTime.ParseExact(dateString, "dd-MM-yy HH:mm", CultureInfo.InvariantCulture);
+
+                    string category = qRow.Find("script:nth-child(1)").Text();
+                    int index = category.IndexOf("category=");
+                    if (index == -1)
+                    {
+                        /// Other type
+                        category = "17";
+                    }
+                    else
+                    {
+                        category = category.Substring(index + "category=".Length, 2);
+                        if (category[1] == '\\')
+                        {
+                            category = category[0].ToString();
+                        }
+                    }
+
+                    release.Category = MapTrackerCatToNewznab(category);
+                    releases.Add(release);
+                }
+            }
+            catch (Exception ex)
+            {
+                OnParseError(results, ex);
+            }
+
+            return releases;
+        }
+
+        private async Task<string> getHebName(string searchTerm)
+        {
+            const string site = "http://thetvdb.com";
+            var url = site + "/index.php?searchseriesid=&tab=listseries&function=Search&";
+            url += "string=" + searchTerm; // eretz + nehedert
+
+
+            var results = await RequestStringWithCookies(url);
+
+            CQ dom = results.Content;
+
+            int rowCount = 0;
+            var rows = dom["#listtable > tbody > tr"];
+
+            foreach (var row in rows)
+            {
+                if (rowCount < 1)
+                {
+                    rowCount++;
+                    continue;
+                }
+
+                CQ qRow = row.Cq();
+                CQ link = qRow.Find("td:nth-child(1) > a");
+                if (link.Text().Trim().ToLower() == searchTerm.Trim().ToLower())
+                {
+                    var address = link.Attr("href");
+                    if (string.IsNullOrEmpty(address)) { continue; }
+
+                    var realAddress = site + address.Replace("lid=7", "lid=24");
+                    var realData = await RequestStringWithCookies(realAddress);
+
+                    CQ realDom = realData.Content;
+                    return realDom["#content:nth-child(1) > h1"].Text();
+                }
+            }
+
+            return string.Empty;
+        }
+    }
+}

src/Jackett/Indexers/ILoveTorrents.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using CsQuery;
+using CsQuery.ExtensionMethods.Internal;
+using Jackett.Models;
+using Jackett.Models.IndexerConfig;
+using Jackett.Services;
+using Jackett.Utils;
+using Jackett.Utils.Clients;
+using Newtonsoft.Json.Linq;
+using NLog;
+
+namespace Jackett.Indexers
+{
+    // ReSharper disable once InconsistentNaming
+    public class ILoveTorrents : BaseIndexer, IIndexer
+    {
+        private string BrowseUrl => SiteLink + "browse.php";
+        private string LoginUrl => SiteLink + "takelogin.php";
+
+        new ConfigurationDataBasicLogin configData
+        {
+            get { return (ConfigurationDataBasicLogin)base.configData; }
+            set { base.configData = value; }
+        }
+
+        public ILoveTorrents(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
+            : base(name: "ILoveTorrents",
+                description: "ILT",
+                link: "https://www.ilovetorrents.me/",
+                caps: new TorznabCapabilities(),
+                manager: i,
+                client: wc,
+                logger: l,
+                p: ps,
+                configData: new ConfigurationDataBasicLogin())
+        {
+
+            AddCategoryMapping(85, TorznabCatType.Movies3D);
+            AddCategoryMapping(23, TorznabCatType.TVAnime);
+            AddCategoryMapping(24, TorznabCatType.BooksEbook);
+            AddCategoryMapping(4, TorznabCatType.PCGames);
+            AddCategoryMapping(38, TorznabCatType.ConsolePS3);
+            AddCategoryMapping(38, TorznabCatType.ConsolePS4);
+            AddCategoryMapping(38, TorznabCatType.ConsolePSP);
+            AddCategoryMapping(43, TorznabCatType.ConsoleWii);
+            AddCategoryMapping(43, TorznabCatType.ConsoleWiiU);
+            AddCategoryMapping(12, TorznabCatType.ConsoleXBOX360DLC);
+            AddCategoryMapping(12, TorznabCatType.ConsoleXbox);
+            AddCategoryMapping(12, TorznabCatType.ConsoleXbox360);
+            AddCategoryMapping(12, TorznabCatType.ConsoleXboxOne);
+            AddCategoryMapping(6, TorznabCatType.Audio);
+
+            AddCategoryMapping(7, TorznabCatType.TV);
+            AddCategoryMapping(40, TorznabCatType.TVSD);
+            AddCategoryMapping(8, TorznabCatType.TVHD);
+
+            AddCategoryMapping(9, TorznabCatType.XXX);
+            AddCategoryMapping(11, TorznabCatType.XXXDVD);
+            AddCategoryMapping(10, TorznabCatType.XXXx264);
+
+            AddCategoryMapping(80, TorznabCatType.MoviesBluRay);
+            AddCategoryMapping(20, TorznabCatType.MoviesDVD);
+            AddCategoryMapping(41, TorznabCatType.MoviesHD);
+            AddCategoryMapping(19, TorznabCatType.Movies);
+        }
+
+        public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
+        {
+            configData.LoadValuesFromJson(configJson);
+            var pairs = new Dictionary<string, string> {
+                { "username", configData.Username.Value },
+                { "password", configData.Password.Value },
+                { "returnto", "/" },
+                { "login", "Log in!" }
+            };
+
+            var loginPage = await RequestStringWithCookies(SiteLink, string.Empty);
+
+            var result = await RequestLoginAndFollowRedirect(LoginUrl, pairs, loginPage.Cookies, true, SiteLink, SiteLink);
+            await ConfigureIfOK(result.Cookies, result.Content != null && result.Content.Contains("logout.php"), () =>
+            {
+                CQ dom = result.Content;
+                var messageEl = dom["body > div"].First();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, configData);
+            });
+            return IndexerConfigurationStatus.RequiresTesting;
+        }
+
+        public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
+        {
+            var releases = new List<ReleaseInfo>();
+            var searchString = query.GetQueryString();
+            var searchUrl = BrowseUrl;
+            var trackerCats = MapTorznabCapsToTrackers(query);
+            var queryCollection = new NameValueCollection();
+
+            // Tracker can only search OR return things in categories
+            if (!string.IsNullOrWhiteSpace(searchString))
+            {
+                queryCollection.Add("search", searchString);
+                queryCollection.Add("cat", "0");
+            }
+            else
+            {
+                foreach (var cat in MapTorznabCapsToTrackers(query))
+                {
+                    queryCollection.Add("c" + cat, "1");
+                }
+
+                queryCollection.Add("incldead", "0");
+            }
+
+            searchUrl += "?" + queryCollection.GetQueryString();
+
+            await ProcessPage(releases, searchUrl);
+            return releases;
+        }
+
+        private async Task ProcessPage(List<ReleaseInfo> releases, string searchUrl)
+        {
+            var response = await RequestStringWithCookiesAndRetry(searchUrl, null, BrowseUrl);
+            var results = response.Content;
+            try
+            {
+                CQ dom = results;
+
+                var rows = dom[".koptekst tr"];
+                foreach (var row in rows.Skip(1))
+                {
+                    var release = new ReleaseInfo();
+
+                    var link = row.Cq().Find("td:eq(1) a:eq(0)").First();
+                    release.Guid = new Uri(SiteLink + link.Attr("href"));
+                    release.Comments = release.Guid;
+                    release.Title = link.Text().Trim(); 
+                    release.Description = release.Title;
+
+                    // If we search an get no results, we still get a table just with no info.
+                    if (string.IsNullOrWhiteSpace(release.Title))
+                    {
+                        break;
+                    }
+
+                    // Check if the release has been assigned a category
+                    if (row.Cq().Find("td:eq(0) a").Length > 0)
+                    {
+                        var cat = row.Cq().Find("td:eq(0) a").First().Attr("href").Substring(15);
+                        release.Category = MapTrackerCatToNewznab(cat);
+                    }
+
+                    var qLink = row.Cq().Find("td:eq(2) a").First();
+                    release.Link = new Uri(SiteLink + qLink.Attr("href"));
+
+                    var added = row.Cq().Find("td:eq(7)").First().Text().Trim();
+                    var date = added.Substring(0, 10);
+                    var time = added.Substring(12, 8);
+                    var dateTime = date + time;
+                    release.PublishDate = DateTime.ParseExact(dateTime, "yyyy-MM-ddHH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal).ToLocalTime();
+
+                    var sizeStr = row.Cq().Find("td:eq(8)").First().Text().Trim();
+                    release.Size = ReleaseInfo.GetBytes(sizeStr);
+
+                    release.Seeders = ParseUtil.CoerceInt(row.Cq().Find("td:eq(10)").First().Text().Trim());
+                    release.Peers = ParseUtil.CoerceInt(row.Cq().Find("td:eq(11)").First().Text().Trim()) + release.Seeders;
+
+                    releases.Add(release);
+                }
+            }
+            catch (Exception ex)
+            {
+                OnParseError(results, ex);
+            }
+        }
+    }
+}

src/Jackett/Indexers/IPTorrents.cs

@@ -21,11 +21,13 @@ namespace Jackett.Indexers
 {
     public class IPTorrents : BaseIndexer, IIndexer
     {
-        private string BrowseUrl { get { return SiteLink + "t"; } }
+        private string UseLink { get { return (!String.IsNullOrEmpty(this.configData.AlternateLink.Value) ? this.configData.AlternateLink.Value : SiteLink); } }
+        private string BrowseUrl { get { return UseLink + "t"; } }
+        private List<String> KnownURLs = new List<String> { "https://nemo.iptorrents.com/", "https://ipt.rocks/" };
 
-        new ConfigurationDataBasicLogin configData
+        new ConfigurationDataBasicLoginWithAlternateLink configData
         {
-            get { return (ConfigurationDataBasicLogin)base.configData; }
+            get { return (ConfigurationDataBasicLoginWithAlternateLink)base.configData; }
             set { base.configData = value; }
         }
 
@@ -38,8 +40,12 @@ namespace Jackett.Indexers
                 client: wc,
                 logger: l,
                 p: ps,
-                configData: new ConfigurationDataBasicLogin())
+                configData: new ConfigurationDataBasicLoginWithAlternateLink())
         {
+            this.configData.Instructions.Value = this.DisplayName + " has multiple URLs.  The default (" + this.SiteLink + ") can be changed by entering a new value in the box below.";
+            this.configData.Instructions.Value += "The following are some known URLs for " + this.DisplayName;
+            this.configData.Instructions.Value += "<ul><li>" + String.Join("</li><li>", this.KnownURLs.ToArray()) + "</li></ul>";
+
             AddCategoryMapping(72, TorznabCatType.Movies);
             AddCategoryMapping(77, TorznabCatType.MoviesSD);
             AddCategoryMapping(89, TorznabCatType.MoviesSD);
@@ -92,9 +98,9 @@ namespace Jackett.Indexers
             };
             var request = new Utils.Clients.WebRequest()
             {
-                Url = SiteLink,
+                Url = UseLink,
                 Type = RequestType.POST,
-                Referer = SiteLink,
+                Referer = UseLink,
                 PostData = pairs
             };
             var response = await webclient.GetString(request);
@@ -156,7 +162,7 @@ namespace Jackett.Indexers
                     }
 
                     release.Description = release.Title;
-                    release.Guid = new Uri(SiteLink + qTitleLink.Attr("href").Substring(1));
+                    release.Guid = new Uri(UseLink + qTitleLink.Attr("href").Substring(1));
                     release.Comments = release.Guid;
 
                     var descString = qRow.Find(".t_ctime").Text();
@@ -165,7 +171,7 @@ namespace Jackett.Indexers
                     release.PublishDate = DateTimeUtil.FromTimeAgo(dateString);
 
                     var qLink = row.ChildElements.ElementAt(3).Cq().Children("a");
-                    release.Link = new Uri(SiteLink + qLink.Attr("href").TrimStart('/'));
+                    release.Link = new Uri(UseLink + HttpUtility.UrlEncode(qLink.Attr("href").TrimStart('/')));
 
                     var sizeStr = row.ChildElements.ElementAt(5).Cq().Text();
                     release.Size = ReleaseInfo.GetBytes(sizeStr);

src/Jackett/Indexers/MyAnonamouse.cs

@@ -0,0 +1,242 @@
+using CsQuery;
+using Jackett.Models;
+using Jackett.Services;
+using Jackett.Utils;
+using Jackett.Utils.Clients;
+using Newtonsoft.Json.Linq;
+using NLog;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Web;
+using Jackett.Models.IndexerConfig;
+using System.Collections.Specialized;
+using System.Globalization;
+
+namespace Jackett.Indexers
+{
+    public class Myanonamouse : BaseIndexer, IIndexer
+    {
+        private string LoginUrl { get { return SiteLink + "takelogin.php"; } }
+        private string SearchUrl { get { return SiteLink + "tor/js/loadSearch2.php"; } }
+
+        new ConfigurationDataBasicLogin configData
+        {
+            get { return (ConfigurationDataBasicLogin)base.configData; }
+            set { base.configData = value; }
+        }
+
+        public Myanonamouse(IIndexerManagerService i, IWebClient c, Logger l, IProtectionService ps)
+            : base(name: "Myanonamouse",
+                description: "Friendliness, Warmth and Sharing",
+                link: "https://www.myanonamouse.net/",
+                caps: new TorznabCapabilities(TorznabCatType.Books,
+                                              TorznabCatType.AudioAudiobook,
+                                              TorznabCatType.BooksComics,
+                                              TorznabCatType.BooksEbook,
+                                              TorznabCatType.BooksMagazines,
+                                              TorznabCatType.BooksTechnical),
+                manager: i,
+                client: c,
+                logger: l,
+                p: ps,
+                configData: new ConfigurationDataBasicLogin())
+        {
+            AddCategoryMapping("61", TorznabCatType.BooksComics);
+            AddCategoryMapping("91", TorznabCatType.BooksTechnical);
+            AddCategoryMapping("80", TorznabCatType.BooksTechnical);
+            AddCategoryMapping("79", TorznabCatType.BooksMagazines);
+            AddCategoryMapping("39", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("49", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("50", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("83", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("51", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("97", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("40", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("41", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("106", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("42", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("52", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("98", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("54", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("55", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("43", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("99", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("84", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("44", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("56", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("137", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("45", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("57", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("85", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("87", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("119", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("88", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("58", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("59", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("46", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("47", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("53", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("89", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("100", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("108", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("48", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("111", TorznabCatType.AudioAudiobook);
+            AddCategoryMapping("60", TorznabCatType.BooksEbook);
+            AddCategoryMapping("71", TorznabCatType.BooksEbook);
+            AddCategoryMapping("72", TorznabCatType.BooksEbook);
+            AddCategoryMapping("90", TorznabCatType.BooksEbook);
+            AddCategoryMapping("73", TorznabCatType.BooksEbook);
+            AddCategoryMapping("101", TorznabCatType.BooksEbook);
+            AddCategoryMapping("62", TorznabCatType.BooksEbook);
+            AddCategoryMapping("63", TorznabCatType.BooksEbook);
+            AddCategoryMapping("107", TorznabCatType.BooksEbook);
+            AddCategoryMapping("64", TorznabCatType.BooksEbook);
+            AddCategoryMapping("74", TorznabCatType.BooksEbook);
+            AddCategoryMapping("102", TorznabCatType.BooksEbook);
+            AddCategoryMapping("76", TorznabCatType.BooksEbook);
+            AddCategoryMapping("77", TorznabCatType.BooksEbook);
+            AddCategoryMapping("65", TorznabCatType.BooksEbook);
+            AddCategoryMapping("103", TorznabCatType.BooksEbook);
+            AddCategoryMapping("115", TorznabCatType.BooksEbook);
+            AddCategoryMapping("66", TorznabCatType.BooksEbook);
+            AddCategoryMapping("78", TorznabCatType.BooksEbook);
+            AddCategoryMapping("138", TorznabCatType.BooksEbook);
+            AddCategoryMapping("67", TorznabCatType.BooksEbook);
+            AddCategoryMapping("92", TorznabCatType.BooksEbook);
+            AddCategoryMapping("118", TorznabCatType.BooksEbook);
+            AddCategoryMapping("94", TorznabCatType.BooksEbook);
+            AddCategoryMapping("120", TorznabCatType.BooksEbook);
+            AddCategoryMapping("95", TorznabCatType.BooksEbook);
+            AddCategoryMapping("81", TorznabCatType.BooksEbook);
+            AddCategoryMapping("82", TorznabCatType.BooksEbook);
+            AddCategoryMapping("68", TorznabCatType.BooksEbook);
+            AddCategoryMapping("69", TorznabCatType.BooksEbook);
+            AddCategoryMapping("75", TorznabCatType.BooksEbook);
+            AddCategoryMapping("96", TorznabCatType.BooksEbook);
+            AddCategoryMapping("104", TorznabCatType.BooksEbook);
+            AddCategoryMapping("109", TorznabCatType.BooksEbook);
+            AddCategoryMapping("70", TorznabCatType.BooksEbook);
+            AddCategoryMapping("112", TorznabCatType.BooksEbook);
+
+        }
+
+        public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
+        {
+            configData.LoadValuesFromJson(configJson);
+            var pairs = new Dictionary<string, string> {
+                { "email", configData.Username.Value },
+                { "password", configData.Password.Value },
+                { "returnto", "/" }
+            };
+
+            var preRequest = await RequestStringWithCookiesAndRetry(LoginUrl, string.Empty);
+
+            var result = await RequestLoginAndFollowRedirect(LoginUrl, pairs, preRequest.Cookies, true, SearchUrl, SiteLink);
+            await ConfigureIfOK(result.Cookies, result.Content != null && result.Content.Contains("Search Results"), () =>
+            {
+                CQ dom = result.Content;
+                var errorMessage = dom["table.main table td.text"].Text().Trim().Replace("\n\t", " ");
+                throw new ExceptionWithConfigData(errorMessage, configData);
+            });
+
+            return IndexerConfigurationStatus.RequiresTesting;
+        }
+
+        public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
+        {
+            var releases = new List<ReleaseInfo>();
+
+            NameValueCollection qParams = new NameValueCollection();
+            qParams.Add("tor[text]", query.GetQueryString());
+            qParams.Add("tor[srchIn][title]", "true");
+            qParams.Add("tor[srchIn][author]", "true");
+            qParams.Add("tor[searchType]", "all");
+            qParams.Add("tor[searchIn]", "torrents");
+            qParams.Add("tor[hash]", "");
+            qParams.Add("tor[sortType]", "default");
+            qParams.Add("tor[startNumber]", "0");
+
+            List<string> catList = MapTorznabCapsToTrackers(query);
+            if (catList.Any())
+            {
+                foreach (string cat in catList)
+                {
+                    qParams.Add("tor[cat][]", cat);
+                }
+            }
+            else
+            {
+                qParams.Add("tor[cat][]", "0");
+            }
+
+            string urlSearch = SearchUrl;
+            if (qParams.Count > 0)
+            {
+                urlSearch += $"?{qParams.GetQueryString()}";
+            }
+
+            var response = await RequestStringWithCookiesAndRetry(urlSearch);
+
+            try
+            {
+                CQ dom = response.Content;
+                var rows = dom["table[class='newTorTable'] > tbody > tr"];
+
+                foreach (IDomObject row in rows)
+                {
+                    CQ torrentData = row.OuterHTML;
+                    CQ cells = row.Cq().Find("td");
+
+                    if (cells.Any() && torrentData.Find("a[class='directDownload']").Any())
+                    {
+                        string title = torrentData.Find("a[class='title']").First().Text().Trim();
+                        string author = torrentData.Find("a[class='author']").First().Text().Trim();
+                        Uri link = new Uri(SiteLink + torrentData.Find("a[class='directDownload']").First().Attr("href").Trim().TrimStart('/'));
+                        Uri guid = new Uri(SiteLink + torrentData.Find("a[class='directDownload']").First().Attr("href").Trim().TrimStart('/'));
+                        long size = ReleaseInfo.GetBytes(cells.Elements.ElementAt(4).Cq().Text().Split('[')[1].TrimEnd(']'));
+                        int seeders = ParseUtil.CoerceInt(cells.Elements.ElementAt(6).Cq().Find("p").ElementAt(0).Cq().Text());
+                        int leechers = ParseUtil.CoerceInt(cells.Elements.ElementAt(6).Cq().Find("p").ElementAt(1).Cq().Text());
+
+                        string pubDateStr = cells.Elements.ElementAt(5).Cq().Text().Split('[')[0];
+                        DateTime publishDate = DateTime.Parse(pubDateStr).ToLocalTime();
+
+                        long category = 0;
+                        string cat = torrentData.Find("a[class='newCatLink']").First().Attr("href").Remove(0, "/tor/browse.php?tor[cat][]]=".Length);
+                        long.TryParse(cat, out category);
+
+
+                        var release = new ReleaseInfo();
+
+                        release.Title = String.IsNullOrEmpty(author) ? title : String.Format("{0} by {1}", title, author);
+                        release.Guid = guid;
+                        release.Link = link;
+                        release.PublishDate = publishDate;
+                        release.Size = size;
+                        release.Description = release.Title;
+                        release.Seeders = seeders;
+                        release.Peers = seeders + leechers;
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Category = MapTrackerCatToNewznab(category.ToString());
+                        release.Comments = guid;
+
+                        releases.Add(release);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                OnParseError(response.Content, ex);
+            }
+
+            return releases;
+        }
+    }
+}

src/Jackett/Indexers/PhxBit.cs

@@ -0,0 +1,802 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using CsQuery;
+using Jackett.Models;
+using Jackett.Models.IndexerConfig.Bespoke;
+using Jackett.Services;
+using Jackett.Utils;
+using Jackett.Utils.Clients;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using NLog;
+
+namespace Jackett.Indexers
+{
+    /// <summary>
+    /// Provider for PhxBit Private French Tracker
+    /// </summary>
+    public class PhxBit : BaseIndexer, IIndexer
+    {
+        private string LoginUrl { get { return SiteLink + "connect.php"; } }
+        private string SearchUrl { get { return SiteLink + "sphinx.php"; } }
+        private string TorrentCommentUrl { get { return TorrentDescriptionUrl; } }
+        private string TorrentDescriptionUrl { get { return SiteLink + "torrent.php?id="; } }
+        private string TorrentDownloadUrl { get { return SiteLink + "get.php?action=private&id={id}&passkey={passkey}"; } }
+        private bool Latency { get { return ConfigData.Latency.Value; } }
+        private bool DevMode { get { return ConfigData.DevMode.Value; } }
+        private bool CacheMode { get { return ConfigData.HardDriveCache.Value; } }
+        private string directory { get { return System.IO.Path.GetTempPath() + "Jackett\\" + MethodBase.GetCurrentMethod().DeclaringType.Name + "\\"; } }
+
+        private Dictionary<string, string> emulatedBrowserHeaders = new Dictionary<string, string>();
+        private CQ fDom = null;
+
+        private ConfigurationDataPhxBit ConfigData
+        {
+            get { return (ConfigurationDataPhxBit)configData; }
+            set { base.configData = value; }
+        }
+
+        public PhxBit(IIndexerManagerService i, IWebClient w, Logger l, IProtectionService ps)
+            : base(
+                name: "PhxBit",
+                description: "General French Private Tracker",
+                link: "https://phxbit.com/",
+                caps: new TorznabCapabilities(),
+                manager: i,
+                client: w,
+                logger: l,
+                p: ps,
+                downloadBase: "https://phxbit.com/get.php?action=private",
+                configData: new ConfigurationDataPhxBit())
+        {
+            // Clean capabilities
+            TorznabCaps.Categories.Clear();
+
+            // Movies
+            AddCategoryMapping(3, TorznabCatType.MoviesSD);             // DVDRIP
+            AddCategoryMapping(33, TorznabCatType.MoviesSD);            // WEBRIP
+            AddCategoryMapping(4, TorznabCatType.MoviesSD);             // BRRIP/BDRIP
+            AddCategoryMapping(6, TorznabCatType.MoviesHD);             // HD 720P
+            AddCategoryMapping(2, TorznabCatType.MoviesHD);             // HD 1080P
+            AddCategoryMapping(5, TorznabCatType.MoviesBluRay);         // FULL BLURAY
+            AddCategoryMapping(32, TorznabCatType.MoviesBluRay);        // FULL BLURAY 3D
+            AddCategoryMapping(7, TorznabCatType.MoviesDVD);            // FULL DVD
+
+            // Series
+            AddCategoryMapping(14, TorznabCatType.TVSD);                // SD VOSTFR
+            AddCategoryMapping(16, TorznabCatType.TVHD);                // HD VOSTFR
+            AddCategoryMapping(13, TorznabCatType.TVSD);                // SD VF
+            AddCategoryMapping(15, TorznabCatType.TVHD);                // HD VF
+            AddCategoryMapping(12, TorznabCatType.TVOTHER);             // PACK
+            AddCategoryMapping(26, TorznabCatType.TVOTHER);             // PACK VOSTFR
+            AddCategoryMapping(24, TorznabCatType.TVOTHER);             // EMISSIONS
+            AddCategoryMapping(34, TorznabCatType.TVOTHER);             // EMISSIONS
+            AddCategoryMapping(29, TorznabCatType.TVOTHER);             // BDRIP VOSTFR
+
+            // Anime
+            AddCategoryMapping(1, TorznabCatType.TVAnime);              // ANIME
+            AddCategoryMapping(28, TorznabCatType.TVAnime);             // MANGA ANIME
+
+            // Documentaries
+            AddCategoryMapping(17, TorznabCatType.TVDocumentary);       // DOCS
+
+            // Music
+            AddCategoryMapping(10, TorznabCatType.AudioLossless);       // FLAC
+            AddCategoryMapping(9, TorznabCatType.AudioMP3);             // MP3
+            AddCategoryMapping(25, TorznabCatType.AudioVideo);          // CONCERT
+
+            // Other
+            AddCategoryMapping(27, TorznabCatType.PC);                  // PC
+            AddCategoryMapping(20, TorznabCatType.PCMac);               // PC
+            AddCategoryMapping(19, TorznabCatType.PCGames);             // GAMES
+            AddCategoryMapping(21, TorznabCatType.ConsoleXbox360);      // GAMES
+            AddCategoryMapping(22, TorznabCatType.ConsoleWii);          // GAMES
+            AddCategoryMapping(22, TorznabCatType.ConsolePS3);          // GAMES
+            AddCategoryMapping(30, TorznabCatType.ConsolePSP);          // GAMES
+            AddCategoryMapping(31, TorznabCatType.ConsoleNDS);          // GAMES
+            AddCategoryMapping(8, TorznabCatType.BooksEbook);           // EBOOKS
+            AddCategoryMapping(11, TorznabCatType.BooksEbook);          // EBOOKS AUDIO
+            AddCategoryMapping(35, TorznabCatType.PCPhoneAndroid);      // ANDROID
+        }
+
+        /// <summary>
+        /// Configure our Provider
+        /// </summary>
+        /// <param name="configJson">Our params in Json</param>
+        /// <returns>Configuration state</returns>
+        public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
+        {
+            // Retrieve config values set by Jackett's user
+            ConfigData.LoadValuesFromJson(configJson);
+
+            // Check & Validate Config
+            validateConfig();
+
+            // Setting our data for a better emulated browser (maximum security)
+            // TODO: Encoded Content not supported by Jackett at this time
+            // emulatedBrowserHeaders.Add("Accept-Encoding", "gzip, deflate");
+
+            // If we want to simulate a browser
+            if (ConfigData.Browser.Value) {
+
+                // Clean headers
+                emulatedBrowserHeaders.Clear();
+
+                // Inject headers
+                emulatedBrowserHeaders.Add("Accept", ConfigData.HeaderAccept.Value);
+                emulatedBrowserHeaders.Add("Accept-Language", ConfigData.HeaderAcceptLang.Value);
+                emulatedBrowserHeaders.Add("DNT", Convert.ToInt32(ConfigData.HeaderDNT.Value).ToString());
+                emulatedBrowserHeaders.Add("Upgrade-Insecure-Requests", Convert.ToInt32(ConfigData.HeaderUpgradeInsecure.Value).ToString());
+                emulatedBrowserHeaders.Add("User-Agent", ConfigData.HeaderUserAgent.Value);
+            }
+
+
+            // Getting login form to retrieve CSRF token
+            /*var myRequest = new Utils.Clients.WebRequest()
+            {
+                Url = LoginUrl
+            };*/
+
+            // Add our headers to request
+            //myRequest.Headers = emulatedBrowserHeaders;
+
+            // Building login form data
+            var pairs = new Dictionary<string, string> {
+                { "username", ConfigData.Username.Value },
+                { "password", ConfigData.Password.Value }
+            };
+
+            // Do the login
+            var request = new Utils.Clients.WebRequest(){
+                PostData = pairs,
+                Referer = LoginUrl,
+                Type = RequestType.POST,
+                Url = LoginUrl,
+                Headers = emulatedBrowserHeaders
+            };
+
+            // Perform loggin
+            latencyNow();
+            output("\nPerform loggin.. with " + LoginUrl);
+            var response = await webclient.GetString(request);
+
+            // Test if we are logged in
+            await ConfigureIfOK(response.Cookies, !response.Cookies.Contains("deleted"), () =>
+            {
+                // Parse error page
+                CQ dom = response.Content;
+                string message = dom[".error"].Text().Trim().Replace("X\n\t\t", "").Replace("\n\t\tX", "");
+
+                // Oops, unable to login
+                output("-> Login failed: \"" + message + "\".", "error");
+                throw new ExceptionWithConfigData("Login failed: << " + message + " >>", configData);
+            });
+
+            output("-> Login Success");
+
+            return IndexerConfigurationStatus.RequiresTesting;
+        }
+
+        /// <summary>
+        /// Execute our search query
+        /// </summary>
+        /// <param name="query">Query</param>
+        /// <returns>Releases</returns>
+        public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
+        {
+            var releases = new List<ReleaseInfo>();
+            var torrentRowList = new List<CQ>();
+            var searchTerm = query.GetQueryString();
+            var searchUrl = SearchUrl;
+            int nbResults = 0;
+            int pageLinkCount = 0;
+
+            // Check cache first so we don't query the server (if search term used or not in dev mode)
+            if(!DevMode && !string.IsNullOrEmpty(searchTerm))
+            {
+                lock (cache)
+                {
+                    // Remove old cache items
+                    CleanCache();
+
+                    // Search in cache
+                    var cachedResult = cache.Where(i => i.Query == searchTerm).FirstOrDefault();
+                    if (cachedResult != null)
+                        return cachedResult.Results.Select(s => (ReleaseInfo)s.Clone()).ToArray();
+                }
+            }
+
+            // Build our query
+            var request = buildQuery(searchTerm, query, searchUrl);
+
+            // Getting results & Store content
+            WebClientStringResult results = await queryExec(request);
+            fDom = results.Content;
+
+            try
+            {
+                // Find torrent rows
+                var firstPageRows = findTorrentRows();
+
+                // Add them to torrents list
+                torrentRowList.AddRange(firstPageRows.Select(fRow => fRow.Cq()));
+
+                // Check if there are pagination links at bottom
+                Boolean pagination = (fDom[".pager_align > a"].Length != 0);
+
+                // If pagination available
+                if (pagination) {
+                    // Calculate numbers of pages available for this search query (Based on number results and number of torrents on first page)
+                    pageLinkCount = ParseUtil.CoerceInt(Regex.Match(fDom[".pager_align > a:not(:last-child)"].Last().Attr("href").ToString(), @"\d+").Value) + 1;
+
+                    // Calculate average number of results (based on torrents rows lenght on first page)
+                    nbResults = firstPageRows.Count() * pageLinkCount;
+                }
+                else {
+                    // Check if we have a minimum of one result
+                    if (firstPageRows.Length >= 1)
+                    {
+                        // Retrieve total count on our alone page
+                        nbResults = firstPageRows.Count();
+                        pageLinkCount = 1;
+                    }
+                    else
+                    {
+                        output("\nNo result found for your query, please try another search term ...\n", "info");
+                        // No result found for this query
+                        return releases;
+                    }
+                }
+                output("\nFound " + nbResults + " result(s) (+/- " + firstPageRows.Length + ") in " + pageLinkCount + " page(s) for this query !");
+                output("\nThere are " + firstPageRows.Length + " results on the first page !");
+
+                // If we have a term used for search and pagination result superior to one
+                if (!string.IsNullOrWhiteSpace(query.GetQueryString()) && pageLinkCount > 1)
+                {
+                    // Starting with page #2
+                    for (int i = 2; i <= Math.Min(Int32.Parse(ConfigData.Pages.Value), pageLinkCount); i++)
+                    {
+                        output("\nProcessing page #" + i);
+
+                        // Request our page
+                        latencyNow();
+
+                        // Build our query
+                        var pageRequest = buildQuery(searchTerm, query, searchUrl, (i - 1));
+
+                        // Getting results & Store content
+                        WebClientStringResult pageResults = await queryExec(pageRequest);
+
+                        // Assign response
+                        fDom = pageResults.Content;
+
+                        // Process page results
+                        var additionalPageRows = findTorrentRows();
+
+                        // Add them to torrents list
+                        torrentRowList.AddRange(additionalPageRows.Select(fRow => fRow.Cq()));
+                    }
+                }
+                else
+                {
+                    // No search term, maybe testing... so registring passkey for future uses
+                    string infosData = firstPageRows.First().Find("td:eq(2) > a").Attr("href");
+                    IList<string> infosList = infosData.Split('&').Select(s => s.Trim()).Where(s => s != String.Empty).ToList();
+                    IList<string> infosTracker = infosList.Select(s => s.Split(new[] { '=' }, 2)[1].Trim()).ToList();
+
+                    output("\nStoring Passkey for future uses... \"" + infosTracker[2] + "\"");
+                    ConfigData.PassKey.Value = infosTracker[2];
+
+                }
+
+                // Loop on results
+                foreach (CQ tRow in torrentRowList)
+                {
+                    output("\n=>> Torrent #" + (releases.Count + 1));
+
+                    // ID
+                    string row = tRow.Html().ToString();
+                    int id = ParseUtil.CoerceInt(Regex.Match(tRow.Find("td:eq(1) > a").Attr("href").ToString(), @"\d+").Value);
+                    output("ID: " + id);
+
+                    // Release Name
+                    string name = tRow.Find("td:eq(1) > a").Attr("title").ToString();
+                    output("Release: " + name);
+
+                    // Category
+                    string infosDataCategory = firstPageRows.First().Find("td:eq(0) > a").Attr("href");
+                    IList<string> infosListCategory = infosDataCategory.Split('&').Select(s => s.Trim()).Where(s => s != String.Empty).ToList();
+                    IList<string> infosCategory = infosListCategory.Select(s => s.Split(new[] { '=' }, 2)[0].Trim()).ToList();
+                    string categoryID = infosCategory.Last().TrimStart('c');
+                    output("Category: " + MapTrackerCatToNewznab(categoryID) + " (" + categoryID + ")");
+
+                    // Seeders
+                    int seeders = ParseUtil.CoerceInt(Regex.Match(tRow.Find("td:eq(6)").Text(), @"\d+").Value);
+                    output("Seeders: " + seeders);
+
+                    // Leechers
+                    int leechers = ParseUtil.CoerceInt(Regex.Match(tRow.Find("td:eq(7)").Text(), @"\d+").Value);
+                    output("Leechers: " + leechers);
+
+                    // Completed
+                    int completed = ParseUtil.CoerceInt(Regex.Match(tRow.Find("td:eq(5)").Text(), @"\d+").Value);
+                    output("Completed: " + completed);
+
+                    // Size
+                    string sizeStr = tRow.Find("td:eq(4)").Text().Trim().Replace("Go", "gb").Replace("Mo", "mb").Replace("Ko", "kb");
+                    long size = ReleaseInfo.GetBytes(sizeStr);
+                    output("Size: " + sizeStr + " (" + size + " bytes)");
+
+                    // Health
+                    int percent = ParseUtil.CoerceInt(Regex.Match(tRow.Find("td:eq(8) > img").Attr("alt").ToString(), @"\d+").Value);
+                    output("Health: " + percent + "%");
+
+                    // Publish DateToString
+                    //var date = agoToDate(null);
+                    int timestamp = ParseUtil.CoerceInt(Regex.Match(tRow.Find("td:eq(1)").Attr("data-added").ToString(), @"\d+").Value);
+                    DateTime date = unixTimeStampToDateTime(timestamp);
+                    output("Released on: " + date.ToLocalTime() + " (TS >> " + timestamp + ")");
+
+                    // Torrent Details URL
+                    Uri detailsLink = new Uri(TorrentDescriptionUrl + id);
+                    output("Details: " + detailsLink.AbsoluteUri);
+
+                    // Torrent Comments URL
+                    Uri commentsLink = new Uri(TorrentCommentUrl + id);
+                    output("Comments Link: " + commentsLink.AbsoluteUri);
+
+                    // Torrent Download URL
+                    Uri downloadLink = new Uri(TorrentDownloadUrl.Replace("{id}", id.ToString()).Replace("{passkey}", ConfigData.PassKey.Value));
+                    output("Download Link: " + downloadLink.AbsoluteUri);
+
+                    // Building release infos
+                    var release = new ReleaseInfo();
+                    release.Category = MapTrackerCatToNewznab(categoryID.ToString());
+                    release.Title = name;
+                    release.Seeders = seeders;
+                    release.Peers = seeders + leechers;
+                    release.MinimumRatio = 1;
+                    release.MinimumSeedTime = 345600;
+                    release.PublishDate = date;
+                    release.Size = size;
+                    release.Guid = detailsLink;
+                    release.Comments = commentsLink;
+                    release.Link = downloadLink;
+                    releases.Add(release);
+                }
+
+            }
+            catch (Exception ex)
+            {
+                OnParseError("Error, unable to parse result \n" + ex.StackTrace, ex);
+            }
+
+            // Return found releases
+            return releases;
+        }
+
+        /// <summary>
+        /// Build query to process
+        /// </summary>
+        /// <param name="term">Term to search</param>
+        /// <param name="query">Torznab Query for categories mapping</param>
+        /// <param name="url">Search url for provider</param>
+        /// <param name="page">Page number to request</param>
+        /// <returns>URL to query for parsing and processing results</returns>
+        private string buildQuery(string term, TorznabQuery query, string url, int page = 0)
+        {
+            var parameters = new NameValueCollection();
+            List<string> categoriesList = MapTorznabCapsToTrackers(query);
+
+            // If search term provided
+            if (!string.IsNullOrWhiteSpace(term))
+            {
+                // Add search term
+                parameters.Add("q", term);
+            }
+            else
+            {
+                parameters.Add("q", string.Empty);
+                // Showing all torrents (just for output function)
+                term = "all";
+            }
+
+            // Default parameters
+            parameters.Add("exact", "0");
+            parameters.Add("sort", "normal");
+            parameters.Add("order", "desc");
+
+            // Check if we are processing a new page
+            if (page > 0)
+            {
+                // Adding page number to query
+                parameters.Add("page", page.ToString());
+            }
+
+            // Loop on Categories needed
+            foreach (string category in categoriesList)
+            {
+                // Add categories
+                parameters.Add("c" + category, "1");
+            }
+
+            // Building our query 
+            url += "?" + parameters.GetQueryString();
+
+            output("\nBuilded query for \"" + term + "\"... " + url);
+
+            // Return our search url
+            return url;
+        }
+
+        /// <summary>
+        /// Switch Method for Querying
+        /// </summary>
+        /// <param name="request">URL created by Query Builder</param>
+        /// <returns>Results from query</returns>
+        private async Task<WebClientStringResult> queryExec(string request)
+        {
+            WebClientStringResult results = null;
+
+            // Switch in we are in DEV mode with Hard Drive Cache or not
+            if (DevMode && CacheMode)
+            {
+                // Check Cache before querying and load previous results if available
+                results = await queryCache(request);
+            }
+            else
+            {
+                // Querying tracker directly
+                results = await queryTracker(request);
+            }
+            return results;
+        }
+
+        /// <summary>
+        /// Get Torrents Page from Cache by Query Provided
+        /// </summary>
+        /// <param name="request">URL created by Query Builder</param>
+        /// <returns>Results from query</returns>
+        private async Task<WebClientStringResult> queryCache(string request)
+        {
+            WebClientStringResult results = null;
+
+            // Create Directory if not exist
+            System.IO.Directory.CreateDirectory(directory);
+
+            // Clean Storage Provider Directory from outdated cached queries
+            cleanCacheStorage();
+
+            // Create fingerprint for request
+            string file = directory + request.GetHashCode() + ".json";
+
+            // Checking modes states
+            if (System.IO.File.Exists(file))
+            {
+                // File exist... loading it right now !
+                output("Loading results from hard drive cache ..." + request.GetHashCode() + ".json");
+                results = JsonConvert.DeserializeObject<WebClientStringResult>(System.IO.File.ReadAllText(file));
+            }
+            else
+            {
+                // No cached file found, querying tracker directly
+                results = await queryTracker(request);
+
+                // Cached file didn't exist for our query, writing it right now !
+                output("Writing results to hard drive cache ..." + request.GetHashCode() + ".json");
+                System.IO.File.WriteAllText(file, JsonConvert.SerializeObject(results));
+            }
+            return results;
+        }
+
+        /// <summary>
+        /// Get Torrents Page from Tracker by Query Provided
+        /// </summary>
+        /// <param name="request">URL created by Query Builder</param>
+        /// <returns>Results from query</returns>
+        private async Task<WebClientStringResult> queryTracker(string request)
+        {
+            WebClientStringResult results = null;
+
+            // Cache mode not enabled or cached file didn't exist for our query
+            output("\nQuerying tracker for results....");
+
+            // Request our first page
+            latencyNow();
+            results = await RequestStringWithCookiesAndRetry(request, null, null, emulatedBrowserHeaders);
+
+            // Return results from tracker
+            return results;
+        }
+
+        /// <summary>
+        /// Clean Hard Drive Cache Storage
+        /// </summary>
+        /// <param name="force">Force Provider Folder deletion</param>
+        private void cleanCacheStorage(Boolean force = false)
+        {
+            // Check cleaning method
+            if(force)
+            {
+                // Deleting Provider Storage folder and all files recursively
+                output("\nDeleting Provider Storage folder and all files recursively ...");
+                
+                // Check if directory exist
+                if(System.IO.Directory.Exists(directory))
+                {
+                    // Delete storage directory of provider
+                    System.IO.Directory.Delete(directory, true);
+                    output("-> Storage folder deleted successfully.");
+                }
+                else
+                {
+                    // No directory, so nothing to do
+                    output("-> No Storage folder found for this provider !");
+                }
+            }
+            else
+            {
+                int i = 0;
+                // Check if there is file older than ... and delete them
+                output("\nCleaning Provider Storage folder... in progress.");
+                System.IO.Directory.GetFiles(directory)
+                .Select(f => new System.IO.FileInfo(f))
+                .Where(f => f.LastAccessTime < DateTime.Now.AddMilliseconds(-Convert.ToInt32(ConfigData.HardDriveCacheKeepTime.Value)))
+                .ToList()
+                .ForEach(f => {
+                    output("Deleting cached file << " + f.Name + " >> ... done.");
+                    f.Delete();
+                    i++;
+                    });
+
+                // Inform on what was cleaned during process
+                if(i > 0) {
+                    output("-> Deleted " + i + " cached files during cleaning.");
+                }
+                else {
+                    output("-> Nothing deleted during cleaning.");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Generate a random fake latency to avoid detection on tracker side
+        /// </summary>
+        private void latencyNow()
+        {
+            // Need latency ?
+            if(Latency)
+            {
+                // Generate a random value in our range
+                var random = new Random(DateTime.Now.Millisecond);
+                int waiting = random.Next(Convert.ToInt32(ConfigData.LatencyStart.Value), Convert.ToInt32(ConfigData.LatencyEnd.Value));
+                output("\nLatency Faker => Sleeping for " + waiting + " ms...");
+
+                // Sleep now...
+                System.Threading.Thread.Sleep(waiting);
+            }
+        }
+
+        /// <summary>
+        /// Find torrent rows in search pages
+        /// </summary>
+        /// <returns>JQuery Object</returns>
+        private CQ findTorrentRows()
+        {
+            // Return all occurencis of torrents found
+            return fDom["#torrent_list > tbody > tr"].Not(".head_torrent").Filter("#torrent_");
+
+            // Dispatch Torrent Row and Torrent Infos
+        }
+
+        /// <summary>
+        /// Convert Unix TimeStamp to DateTime
+        /// </summary>
+        /// <param name="unixTimeStamp"></param>
+        /// <returns>A DateTime</returns>
+        private DateTime unixTimeStampToDateTime(double unixTimeStamp)
+        {
+            // Unix timestamp is seconds past epoch
+            System.DateTime dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
+            dtDateTime = dtDateTime.AddSeconds(unixTimeStamp).ToLocalTime();
+            return dtDateTime;
+        }
+
+        /// <summary>
+        /// Output message for logging or developpment (console)
+        /// </summary>
+        /// <param name="message">Message to output</param>
+        /// <param name="level">Level for Logger</param>
+        private void output(string message, string level = "debug")
+        {
+            // Check if we are in dev mode
+            if(DevMode)
+            {
+                // Output message to console
+                Console.WriteLine(message);
+            }
+            else
+            {
+                // Send message to logger with level
+                switch (level)
+                {
+                    default:
+                        goto case "debug";
+                    case "debug":
+                        // Only if Debug Level Enabled on Jackett
+                        if (Engine.Logger.IsDebugEnabled)
+                        {
+                            logger.Debug(message);
+                        }
+                        break;
+                    case "info":
+                        logger.Info(message);
+                        break;
+                    case "error":
+                        logger.Error(message);
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Validate Config entered by user on Jackett
+        /// </summary>
+        private void validateConfig()
+        {
+            output("\nValidating Settings ... \n");
+
+            // Check Username Setting
+            if (string.IsNullOrEmpty(ConfigData.Username.Value))
+            {
+                throw new ExceptionWithConfigData("You must provide a username for this tracker to login !", ConfigData);
+            }
+            else
+            {
+                output("Validated Setting -- Username (auth) => " + ConfigData.Username.Value.ToString());
+            }
+
+            // Check Password Setting
+            if (string.IsNullOrEmpty(ConfigData.Password.Value))
+            {
+                throw new ExceptionWithConfigData("You must provide a password with your username for this tracker to login !", ConfigData);
+            }
+            else
+            {
+                output("Validated Setting -- Password (auth) => " + ConfigData.Password.Value.ToString());
+            }
+
+            // Check Max Page Setting
+            if (!string.IsNullOrEmpty(ConfigData.Pages.Value))
+            {
+                try
+                {
+                    output("Validated Setting -- Max Pages => " + Convert.ToInt32(ConfigData.Pages.Value));
+                }
+                catch (Exception)
+                {
+                    throw new ExceptionWithConfigData("Please enter a numeric maximum number of pages to crawl !", ConfigData);
+                }
+            }
+            else
+            {
+                throw new ExceptionWithConfigData("Please enter a maximum number of pages to crawl !", ConfigData);
+            }
+
+            // Check Latency Setting
+            if (ConfigData.Latency.Value)
+            {
+                output("\nValidated Setting -- Latency Simulation enabled");
+
+                // Check Latency Start Setting
+                if (!string.IsNullOrEmpty(ConfigData.LatencyStart.Value))
+                {
+                    try
+                    {
+                        output("Validated Setting -- Latency Start => " + Convert.ToInt32(ConfigData.LatencyStart.Value));
+                    }
+                    catch (Exception)
+                    {
+                        throw new ExceptionWithConfigData("Please enter a numeric latency start in ms !", ConfigData);
+                    }
+                }
+                else
+                {
+                    throw new ExceptionWithConfigData("Latency Simulation enabled, Please enter a start latency !", ConfigData);
+                }
+
+                // Check Latency End Setting
+                if (!string.IsNullOrEmpty(ConfigData.LatencyEnd.Value))
+                {
+                    try
+                    {
+                        output("Validated Setting -- Latency End => " + Convert.ToInt32(ConfigData.LatencyEnd.Value));
+                    }
+                    catch (Exception)
+                    {
+                        throw new ExceptionWithConfigData("Please enter a numeric latency end in ms !", ConfigData);
+                    }
+                }
+                else
+                {
+                    throw new ExceptionWithConfigData("Latency Simulation enabled, Please enter a end latency !", ConfigData);
+                }
+            }
+
+            // Check Browser Setting
+            if (ConfigData.Browser.Value)
+            {
+                output("\nValidated Setting -- Browser Simulation enabled");
+
+                // Check ACCEPT header Setting
+                if (string.IsNullOrEmpty(ConfigData.HeaderAccept.Value))
+                {
+                    throw new ExceptionWithConfigData("Browser Simulation enabled, Please enter an ACCEPT header !", ConfigData);
+                }
+                else
+                {
+                    output("Validated Setting -- ACCEPT (header) => " + ConfigData.HeaderAccept.Value.ToString());
+                }
+
+                // Check ACCEPT-LANG header Setting
+                if (string.IsNullOrEmpty(ConfigData.HeaderAcceptLang.Value))
+                {
+                    throw new ExceptionWithConfigData("Browser Simulation enabled, Please enter an ACCEPT-LANG header !", ConfigData);
+                }
+                else
+                {
+                    output("Validated Setting -- ACCEPT-LANG (header) => " + ConfigData.HeaderAcceptLang.Value.ToString());
+                }
+
+                // Check USER-AGENT header Setting
+                if (string.IsNullOrEmpty(ConfigData.HeaderUserAgent.Value))
+                {
+                    throw new ExceptionWithConfigData("Browser Simulation enabled, Please enter an USER-AGENT header !", ConfigData);
+                }
+                else
+                {
+                    output("Validated Setting -- USER-AGENT (header) => " + ConfigData.HeaderUserAgent.Value.ToString());
+                }
+            }
+
+            // Check Dev Cache Settings
+            if (ConfigData.HardDriveCache.Value == true)
+            {
+                output("\nValidated Setting -- DEV Hard Drive Cache enabled");
+
+                // Check if Dev Mode enabled !
+                if (!ConfigData.DevMode.Value)
+                {
+                    throw new ExceptionWithConfigData("Hard Drive is enabled but not in DEV MODE, Please enable DEV MODE !", ConfigData);
+                }
+
+                // Check Cache Keep Time Setting
+                if (!string.IsNullOrEmpty(ConfigData.HardDriveCacheKeepTime.Value))
+                {
+                    try
+                    {
+                        output("Validated Setting -- Cache Keep Time (ms) => " + Convert.ToInt32(ConfigData.HardDriveCacheKeepTime.Value));
+                    }
+                    catch (Exception)
+                    {
+                        throw new ExceptionWithConfigData("Please enter a numeric hard drive keep time in ms !", ConfigData);
+                    }
+                }
+                else
+                {
+                    throw new ExceptionWithConfigData("Hard Drive Cache enabled, Please enter a maximum keep time for cache !", ConfigData);
+                }
+            }
+            else
+            {
+                // Delete cache if previously existed
+                cleanCacheStorage(true);
+            }
+        }
+    }
+}

src/Jackett/Indexers/SceneFZ.cs

@@ -0,0 +1,125 @@
+using Jackett.Utils.Clients;
+using NLog;
+using Jackett.Services;
+using Jackett.Utils;
+using Jackett.Models;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using CsQuery;
+using System.Web;
+using System;
+using System.Globalization;
+using Jackett.Models.IndexerConfig;
+
+namespace Jackett.Indexers
+{
+    public class SceneFZ : BaseIndexer, IIndexer
+    {
+        string LoginUrl { get { return SiteLink + "takelogin.php"; } }
+
+        string BrowseUrl { get { return SiteLink + "ajax_browse.php"; } }
+
+        new ConfigurationDataBasicLogin configData
+        {
+            get { return (ConfigurationDataBasicLogin)base.configData; }
+            set { base.configData = value; }
+        }
+
+        public SceneFZ(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
+            : base(name: "SceneFZ",
+                   description: "Torrent tracker. Tracking over 50.000 torrent files.",
+                   link: "http://scenefz.net/",
+                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
+                   manager: i,
+                   client: wc,
+                   logger: l,
+                   p: ps,
+                   configData: new ConfigurationDataBasicLogin())
+        {
+            AddCategoryMapping(32, TorznabCatType.Movies);
+            AddCategoryMapping(33, TorznabCatType.TV);
+        }
+
+        public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
+        {
+            configData.LoadValuesFromJson(configJson);
+            var pairs = new Dictionary<string, string>
+            {
+                { "username", configData.Username.Value },
+                { "password", configData.Password.Value }
+            };
+
+            var result = await RequestLoginAndFollowRedirect(LoginUrl, pairs, null, true, null, LoginUrl);
+            await ConfigureIfOK(result.Cookies, result.Content != null && result.Content.Contains("Please wait..."), () =>
+                {
+                    CQ dom = result.Content;
+                    var errorMessage = dom[".tableinborder:eq(1) td"].Text().Trim();
+                    throw new ExceptionWithConfigData(errorMessage, configData);
+                });
+            return IndexerConfigurationStatus.RequiresTesting;
+        }
+
+        public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
+        {
+            var releases = new List<ReleaseInfo>();
+            var searchUrl = BrowseUrl;
+            var searchString = query.GetQueryString();
+
+            var cats = MapTorznabCapsToTrackers(query);
+            string cat = "0";
+
+            if (cats.Count == 1)
+            {
+                cat = cats[0];
+            }
+
+            if (!string.IsNullOrWhiteSpace(searchString) || cat != "0")
+                searchUrl += string.Format("?search={0}&param_val=0&complex_search=0&incldead=mc{1}&orderby=added&sort=desc", HttpUtility.UrlEncode(searchString), cat);
+
+            var response = await RequestStringWithCookiesAndRetry(searchUrl, null, BrowseUrl);
+            var results = response.Content;
+            try
+            {
+                CQ dom = results;
+                var rows = dom["td#browse-middle-td"];
+
+                foreach (var row in rows)
+                {
+                    var release = new ReleaseInfo();
+                    var qRow = row.Cq();
+                    var qTitleLink = qRow.Find("table tbody tr:eq(0) td a").First();
+                    release.Title = qRow.Find("table tbody tr:eq(0) td a b").Text().Trim();
+                    release.Description = release.Title;
+                    release.Guid = new Uri(SiteLink + qTitleLink.Attr("href"));
+                    release.Comments = release.Guid;
+
+                    //24.04.2016 16:44:57
+                    var dateStr = qRow.Find("table tbody tr:eq(1) td:eq(4)").Html().Replace("&nbsp;", " ").Trim();
+                    release.PublishDate = DateTime.ParseExact(dateStr, "dd.MM.yyyy HH:mm:ss", CultureInfo.InvariantCulture).AddHours(-2);
+
+                    var qLink = qRow.First().Next().Find("a");
+                    release.Link = new Uri(SiteLink + qLink.Attr("href"));
+
+                    var sizeStr = qRow.Find("table tbody tr:eq(1) td b").Text().Trim();
+                    release.Size = ReleaseInfo.GetBytes(sizeStr.Replace(",", "."));
+
+                    release.Seeders = ParseUtil.CoerceInt(qRow.Find("table tbody tr:eq(1) td:eq(1) b:eq(0) font").Text().Trim());
+                    release.Peers = ParseUtil.CoerceInt(qRow.Find("table tbody tr:eq(1) td:eq(1) b:eq(1) font").Text().Trim()) + release.Seeders;
+
+                    var catId = qRow.First().Prev().Find("a").Attr("onclick").Substring(21, 2);
+                    release.Category = MapTrackerCatToNewznab(catId);
+
+                    releases.Add(release);
+                }
+            }
+            catch (Exception ex)
+            {
+                OnParseError(results, ex);
+            }
+
+            return releases;
+        }
+    }
+}
+

src/Jackett/Indexers/SceneTime.cs

@@ -7,14 +7,10 @@ using Newtonsoft.Json.Linq;
 using NLog;
 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 Jackett.Models.IndexerConfig;
+using System.Text.RegularExpressions;
 
 namespace Jackett.Indexers
 {
@@ -34,13 +30,52 @@ namespace Jackett.Indexers
             : base(name: "SceneTime",
                 description: "Always on time",
                 link: "https://www.scenetime.com/",
-                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
+                caps: new TorznabCapabilities(),
                 manager: i,
                 client: w,
                 logger: l,
                 p: ps,
-                configData: new ConfigurationDataBasicLogin())
+                configData: new ConfigurationDataBasicLogin("For best results, change the 'Torrents per page' setting to the maximum in your profile on the SceneTime webpage."))
         {
+            AddCategoryMapping(1, TorznabCatType.MoviesSD);
+            AddCategoryMapping(3, TorznabCatType.MoviesDVD);
+            AddCategoryMapping(47, TorznabCatType.MoviesSD);
+            AddCategoryMapping(57, TorznabCatType.MoviesSD);
+            AddCategoryMapping(59, TorznabCatType.MoviesHD);
+            AddCategoryMapping(61, TorznabCatType.MoviesSD);
+            AddCategoryMapping(64, TorznabCatType.Movies3D);
+            AddCategoryMapping(80, TorznabCatType.MoviesForeign);
+            AddCategoryMapping(81, TorznabCatType.MoviesBluRay);
+            AddCategoryMapping(82, TorznabCatType.MoviesOther);
+            AddCategoryMapping(102, TorznabCatType.MoviesOther);
+            AddCategoryMapping(103, TorznabCatType.MoviesWEBDL);
+            AddCategoryMapping(105, TorznabCatType.Movies);
+
+            AddCategoryMapping(6, TorznabCatType.PCGames);
+            AddCategoryMapping(48, TorznabCatType.ConsoleXbox);
+            AddCategoryMapping(49, TorznabCatType.ConsolePSP);
+            AddCategoryMapping(50, TorznabCatType.ConsolePS3);
+            AddCategoryMapping(51, TorznabCatType.ConsoleWii);
+            AddCategoryMapping(55, TorznabCatType.ConsoleNDS);
+            AddCategoryMapping(107, TorznabCatType.ConsolePS4);
+
+            AddCategoryMapping(2, TorznabCatType.TVSD);
+            AddCategoryMapping(43, TorznabCatType.TV);
+            AddCategoryMapping(9, TorznabCatType.TVHD);
+            AddCategoryMapping(63, TorznabCatType.TV);
+            AddCategoryMapping(77, TorznabCatType.TVSD);
+            AddCategoryMapping(79, TorznabCatType.TVSport);
+            AddCategoryMapping(100, TorznabCatType.TVFOREIGN);
+            AddCategoryMapping(83, TorznabCatType.TVWEBDL);
+
+            AddCategoryMapping(5, TorznabCatType.PC0day);
+            AddCategoryMapping(7, TorznabCatType.Books);
+            AddCategoryMapping(52, TorznabCatType.PCMac);
+            AddCategoryMapping(65, TorznabCatType.BooksComics);
+            AddCategoryMapping(53, TorznabCatType.PC);
+
+            AddCategoryMapping(4, TorznabCatType.Audio);
+            AddCategoryMapping(11, TorznabCatType.AudioVideo);
         }
 
         public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
@@ -62,23 +97,45 @@ namespace Jackett.Indexers
             return IndexerConfigurationStatus.RequiresTesting;
         }
 
-        private Dictionary<string, string> GetSearchFormData(string searchString)
-        {
-            return new Dictionary<string, string> {
-                { "c2", "1" }, { "c43", "1" }, { "c9", "1" }, { "c63", "1" }, { "c77", "1" }, { "c100", "1" }, { "c101", "1" },
-                { "cata", "yes" }, { "sec", "jax" },
-                { "search", searchString}
-            };
-        }
 
         public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
         {
-            var releases = new List<ReleaseInfo>();
-            var results = await PostDataWithCookiesAndRetry(SearchUrl, GetSearchFormData(query.GetQueryString()));
+            Dictionary<string, string> qParams = new Dictionary<string, string>();
+            qParams.Add("cata", "yes");
+            qParams.Add("sec", "jax");
+            
+            List<string> catList = MapTorznabCapsToTrackers(query);
+            foreach (string cat in catList)
+            {
+                qParams.Add("c" + cat, "1");
+            }
+
+            if (!string.IsNullOrEmpty(query.SanitizedSearchTerm))
+            {
+                qParams.Add("search", query.GetQueryString());
+            }
+
+            var results = await PostDataWithCookiesAndRetry(SearchUrl, qParams);
+            List<ReleaseInfo> releases = ParseResponse(results.Content);
+            
+            return releases;
+        }
+
+        public List<ReleaseInfo> ParseResponse(string htmlResponse)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
 
             try
             {
-                CQ dom = results.Content;
+                CQ dom = htmlResponse;
+
+                List<string> headerColumns = dom["table[class*='movehere']"].First().Find("tbody > tr > td[class='cat_Head']").Select(x => x.Cq().Text()).ToList();
+                int categoryIndex = headerColumns.FindIndex(x => x.Equals("Type"));
+                int nameIndex = headerColumns.FindIndex(x => x.Equals("Name"));
+                int sizeIndex = headerColumns.FindIndex(x => x.Equals("Size"));
+                int seedersIndex = headerColumns.FindIndex(x => x.Equals("Seeders"));
+                int leechersIndex = headerColumns.FindIndex(x => x.Equals("Leechers"));
+
                 var rows = dom["tr.browse"];
                 foreach (var row in rows)
                 {
@@ -86,7 +143,12 @@ namespace Jackett.Indexers
                     release.MinimumRatio = 1;
                     release.MinimumSeedTime = 172800;
 
-                    var descCol = row.ChildElements.ElementAt(1);
+                    var categoryCol = row.ChildElements.ElementAt(categoryIndex);
+                    string catLink = categoryCol.Cq().Find("a").Attr("href");
+                    string catId = new Regex(@"\?cat=(\d*)").Match(catLink).Groups[1].ToString().Trim();
+                    release.Category = MapTrackerCatToNewznab(catId);
+
+                    var descCol = row.ChildElements.ElementAt(nameIndex);
                     var qDescCol = descCol.Cq();
                     var qLink = qDescCol.Find("a");
                     release.Title = qLink.Text();
@@ -98,19 +160,20 @@ namespace Jackett.Indexers
 
                     release.PublishDate = DateTimeUtil.FromTimeAgo(descCol.ChildNodes.Last().InnerText);
 
-                    var sizeStr = row.ChildElements.ElementAt(5).Cq().Text();
+                    var sizeStr = row.ChildElements.ElementAt(sizeIndex).Cq().Text();
                     release.Size = ReleaseInfo.GetBytes(sizeStr);
 
-                    release.Seeders = ParseUtil.CoerceInt(row.ChildElements.ElementAt(6).Cq().Text().Trim());
-                    release.Peers = ParseUtil.CoerceInt(row.ChildElements.ElementAt(7).Cq().Text().Trim()) + release.Seeders;
+                    release.Seeders = ParseUtil.CoerceInt(row.ChildElements.ElementAt(seedersIndex).Cq().Text().Trim());
+                    release.Peers = ParseUtil.CoerceInt(row.ChildElements.ElementAt(leechersIndex).Cq().Text().Trim()) + release.Seeders;
 
                     releases.Add(release);
                 }
             }
             catch (Exception ex)
             {
-                OnParseError(results.Content, ex);
+                OnParseError(htmlResponse, ex);
             }
+
             return releases;
         }
     }

src/Jackett/Indexers/TehConnection.cs

@@ -1,5 +1,4 @@
 using CsQuery;
-using Jackett.Indexers;
 using Jackett.Models;
 using Jackett.Services;
 using Jackett.Utils;
@@ -41,27 +40,35 @@ namespace Jackett.Indexers
                                                                         Separate options with a space if using more than one option.<br>Filter options available:
                                                                         <br><code>QualityEncodeOnly</code><br><code>FreeLeechOnly</code>"))
         {
-            AddCategoryMapping(7, TorznabCatType.Movies);
-            AddCategoryMapping(7, TorznabCatType.MoviesForeign);
-            AddCategoryMapping(7, TorznabCatType.MoviesOther);
-            AddCategoryMapping(7, TorznabCatType.MoviesSD);
-            AddCategoryMapping(7, TorznabCatType.MoviesHD);
-            AddCategoryMapping(7, TorznabCatType.Movies3D);
-            AddCategoryMapping(7, TorznabCatType.MoviesBluRay);
-            AddCategoryMapping(7, TorznabCatType.MoviesDVD);
-            AddCategoryMapping(7, TorznabCatType.MoviesWEBDL);
+            AddCategoryMapping(1, TorznabCatType.Movies);
+            AddCategoryMapping(1, TorznabCatType.MoviesForeign);
+            AddCategoryMapping(1, TorznabCatType.MoviesOther);
+            AddCategoryMapping(1, TorznabCatType.MoviesSD);
+            AddCategoryMapping(1, TorznabCatType.MoviesHD);
+            AddCategoryMapping(1, TorznabCatType.Movies3D);
+            AddCategoryMapping(1, TorznabCatType.MoviesBluRay);
+            AddCategoryMapping(1, TorznabCatType.MoviesDVD);
+            AddCategoryMapping(1, TorznabCatType.MoviesWEBDL);
         }
 
         public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
         {
             configData.LoadValuesFromJson(configJson);
+
+            await DoLogin();
+
+            return IndexerConfigurationStatus.RequiresTesting;
+        }
+
+        private async Task DoLogin()
+        {
             var pairs = new Dictionary<string, string> {
                 { "username", configData.Username.Value },
                 { "password", configData.Password.Value },
                 { "keeplogged", "1" },
                 { "login", "Log In!" }
             };
-         
+
             var response = await RequestLoginAndFollowRedirect(LoginUrl, pairs, null, true, indexUrl, SiteLink);
 
             await ConfigureIfOK(response.Cookies, response.Content != null && response.Content.Contains("/logout.php"), () =>
@@ -70,11 +77,24 @@ namespace Jackett.Indexers
                 string errorMessage = "Unable to login to TehConnection";
                 throw new ExceptionWithConfigData(errorMessage, configData);
             });
-            return IndexerConfigurationStatus.RequiresTesting;
         }
 
         public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
         {
+            var loggedInCheck = await RequestStringWithCookies(SearchUrl);
+            if (!loggedInCheck.Content.Contains("/logout.php"))
+            {
+                //Cookie appears to expire after a period of time or logging in to the site via browser
+                DateTime lastLoggedInCheck;
+                DateTime.TryParse(configData.LastLoggedInCheck.Value, out lastLoggedInCheck);
+                if (lastLoggedInCheck < DateTime.Now.AddMinutes(-15))
+                {
+                    await DoLogin();
+                    configData.LastLoggedInCheck.Value = DateTime.Now.ToString("o");
+                    SaveConfig();
+                }
+            }
+
             var releases = new List<ReleaseInfo>();
             bool configFreeLeechOnly = configData.FilterString.Value.ToLowerInvariant().Contains("freeleechonly");
             bool configQualityEncodeOnly = configData.FilterString.Value.ToLowerInvariant().Contains("qualityencodeonly");
@@ -84,7 +104,14 @@ namespace Jackett.Indexers
                 movieListSearchUrl = SearchUrl;
             else
             {
-                movieListSearchUrl = string.Format("{0}?action=basic&searchstr={1}", SearchUrl, HttpUtility.UrlEncode(query.GetQueryString()));
+                if (!string.IsNullOrEmpty(query.ImdbID))
+                {
+                    movieListSearchUrl = string.Format("{0}?action=basic&searchstr={1}", SearchUrl, HttpUtility.UrlEncode(query.ImdbID));
+                }
+                else
+                {
+                    movieListSearchUrl = string.Format("{0}?action=basic&searchstr={1}", SearchUrl, HttpUtility.UrlEncode(query.GetQueryString()));
+                } 
             }
 
             var results = await RequestStringWithCookiesAndRetry(movieListSearchUrl);

src/Jackett/Indexers/TransmitheNet.cs

@@ -0,0 +1,133 @@
+using Jackett.Models;
+using Jackett.Services;
+using Jackett.Utils;
+using Jackett.Utils.Clients;
+using Newtonsoft.Json.Linq;
+using NLog;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Threading.Tasks;
+using System.Web;
+using Jackett.Models.IndexerConfig;
+using AngleSharp.Parser.Html;
+using System.Text.RegularExpressions;
+
+namespace Jackett.Indexers
+{
+    public class TransmitheNet : BaseIndexer, IIndexer
+    {
+        private string LoginUrl { get { return SiteLink + "login.php"; } }
+        private string SearchUrl { get { return SiteLink + "torrents.php?action=basic&order_by=time&order_way=desc&search_type=0&taglist=&tags_type=0"; } }
+
+        new ConfigurationDataBasicLogin configData
+        {
+            get { return (ConfigurationDataBasicLogin)base.configData; }
+            set { base.configData = value; }
+        }
+
+        public TransmitheNet(IIndexerManagerService i, Logger l, IWebClient c, IProtectionService ps)
+            : base(name: "TransmitTheNet",
+                description: " At Transmithe.net we will change the way you think about TV",
+                link: "https://transmithe.net/",
+                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
+                manager: i,
+                client: c,
+                logger: l,
+                p: ps,
+                configData: new ConfigurationDataBasicLogin("For best results, change the 'Torrents per page' setting to 100 in your profile on the TTN webpage."))
+        {
+        }
+
+        public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
+        {
+            configData.LoadValuesFromJson(configJson);
+            var pairs = new Dictionary<string, string> {
+                { "username", configData.Username.Value },
+                { "password", configData.Password.Value },
+                { "keeplogged", "on" },
+                { "login", "Login" }
+            };
+
+            CookieHeader = string.Empty;
+            var response = await RequestLoginAndFollowRedirect(LoginUrl, pairs, CookieHeader, true, null, LoginUrl);
+
+            await ConfigureIfOK(response.Cookies, response.Content != null && response.Content.Contains("logout.php"), () =>
+            {
+                var parser = new HtmlParser();
+                var document = parser.Parse(response.Content);
+                var messageEl = document.QuerySelector("form > span[class='warning']");
+                var errorMessage = messageEl.TextContent.Trim();
+                throw new ExceptionWithConfigData(errorMessage, configData);
+            });
+            return IndexerConfigurationStatus.RequiresTesting;
+        }
+
+        public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
+        {
+            string Url;
+            if (string.IsNullOrEmpty(query.GetQueryString()))
+                Url = SearchUrl;
+            else
+            {
+                Url = $"{SearchUrl}&searchtext={HttpUtility.UrlEncode(query.GetQueryString())}";
+            }
+
+            var response = await RequestStringWithCookiesAndRetry(Url);
+            List<ReleaseInfo> releases = ParseResponse(response.Content);
+
+            return releases;
+        }
+
+        public List<ReleaseInfo> ParseResponse(string htmlResponse)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            try
+            {
+                var parser = new HtmlParser();
+                var document = parser.Parse(htmlResponse);
+                var rows = document.QuerySelectorAll(".torrent_table > tbody > tr:not(:First-child)");
+
+                foreach (var row in rows)
+                {
+                    var release = new ReleaseInfo();
+
+                    string title = row.QuerySelector("a[data-src]").GetAttribute("data-src");
+                    if (string.IsNullOrEmpty(title) || title == "0")
+                    {
+                        title = row.QuerySelector("a[data-src]").TextContent;
+                        title = Regex.Replace(title, @"[\[\]\/]", "");
+                    }
+                    else
+                    {
+                        title = title.Remove(title.LastIndexOf("."));
+                    }
+
+                    release.Title = title;
+                    release.Description = release.Title;
+                    release.Guid = new Uri(SiteLink + row.QuerySelector("a[data-src]").GetAttribute("href"));
+                    release.Comments = release.Guid;
+                    release.Link = new Uri(SiteLink + row.QuerySelector("a[href*='action=download']").GetAttribute("href"));
+                    release.Category = TvCategoryParser.ParseTvShowQuality(release.Title);
+
+                    var timeAnchor = row.QuerySelector("span[class='time']");
+                    release.PublishDate = DateTime.ParseExact(timeAnchor.GetAttribute("title"), "MMM dd yyyy, HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal);
+                    release.Seeders = ParseUtil.CoerceInt(timeAnchor.ParentElement.NextElementSibling.NextElementSibling.TextContent.Trim());
+                    release.Peers = ParseUtil.CoerceInt(timeAnchor.ParentElement.NextElementSibling.NextElementSibling.NextElementSibling.TextContent.Trim()) + release.Seeders;
+                    release.Size = ReleaseInfo.GetBytes(timeAnchor.ParentElement.PreviousElementSibling.TextContent);
+                    release.MinimumRatio = 1;
+                    release.MinimumSeedTime = 172800;
+
+                    releases.Add(release);
+                }
+            }
+            catch (Exception ex)
+            {
+                OnParseError(htmlResponse, ex);
+            }
+
+            return releases;
+        }
+    }
+}

src/Jackett/Indexers/Xthor.cs

@@ -0,0 +1,592 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using System.Web;
+using Jackett.Models;
+using Jackett.Models.IndexerConfig.Bespoke;
+using Jackett.Services;
+using Jackett.Utils;
+using Jackett.Utils.Clients;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using NLog;
+
+namespace Jackett.Indexers
+{
+    /// <summary>
+    /// Provider for Xthor Private French Tracker
+    /// </summary>
+    public class Xthor : BaseIndexer, IIndexer
+    {
+        private static string ApiEndpoint => "https://api.xthor.bz/";
+        private string TorrentCommentUrl => TorrentDescriptionUrl;
+        private string TorrentDescriptionUrl => SiteLink + "details.php?id={id}";
+        private bool DevMode => ConfigData.DevMode.Value;
+        private bool CacheMode => ConfigData.HardDriveCache.Value;
+        private static string Directory => System.IO.Path.GetTempPath() + "Jackett\\" + MethodBase.GetCurrentMethod().DeclaringType?.Name + "\\";
+        public Dictionary<string, string> EmulatedBrowserHeaders { get; } = new Dictionary<string, string>();
+        private ConfigurationDataXthor ConfigData => (ConfigurationDataXthor)configData;
+
+        public Xthor(IIndexerManagerService i, IWebClient w, Logger l, IProtectionService ps)
+            : base(
+                name: "Xthor",
+                description: "General French Private Tracker",
+                link: "https://xthor.bz/",
+                caps: new TorznabCapabilities(),
+                manager: i,
+                client: w,
+                logger: l,
+                p: ps,
+                downloadBase: "https://xthor.bz/download.php?torrent=",
+                configData: new ConfigurationDataXthor())
+        {
+            // Clean capabilities
+            TorznabCaps.Categories.Clear();
+
+            // Movies
+            AddCategoryMapping(6, TorznabCatType.MoviesSD);             // XVID
+            AddCategoryMapping(7, TorznabCatType.MoviesSD);             // X264
+            AddCategoryMapping(95, TorznabCatType.MoviesSD);            // WEBRIP
+            AddCategoryMapping(5, TorznabCatType.MoviesHD);             // HD 720P
+            AddCategoryMapping(4, TorznabCatType.MoviesHD);             // HD 1080P X264
+            AddCategoryMapping(100, TorznabCatType.MoviesHD);           // HD 1080P X265
+            AddCategoryMapping(94, TorznabCatType.MoviesHD);            // WEBDL
+            AddCategoryMapping(1, TorznabCatType.MoviesBluRay);         // FULL BLURAY
+            AddCategoryMapping(2, TorznabCatType.MoviesBluRay);         // BLURAY REMUX
+            AddCategoryMapping(3, TorznabCatType.MoviesBluRay);         // FULL BLURAY 3D
+            AddCategoryMapping(8, TorznabCatType.MoviesDVD);            // FULL DVD
+            AddCategoryMapping(9, TorznabCatType.MoviesOther);          // VOSTFR
+            AddCategoryMapping(36, TorznabCatType.XXX);                 // XXX
+
+            // Series
+            AddCategoryMapping(14, TorznabCatType.TVSD);                // SD VF
+            AddCategoryMapping(16, TorznabCatType.TVSD);                // SD VF VOSTFR
+            AddCategoryMapping(15, TorznabCatType.TVHD);                // HD VF
+            AddCategoryMapping(17, TorznabCatType.TVHD);                // HD VF VOSTFR
+            AddCategoryMapping(13, TorznabCatType.TVOTHER);             // PACK
+            AddCategoryMapping(98, TorznabCatType.TVOTHER);             // PACK VOSTFR HD
+            AddCategoryMapping(16, TorznabCatType.TVOTHER);             // PACK VOSTFR SD
+            AddCategoryMapping(30, TorznabCatType.TVOTHER);             // EMISSIONS
+            AddCategoryMapping(34, TorznabCatType.TVOTHER);             // EMISSIONS
+            AddCategoryMapping(33, TorznabCatType.TVOTHER);             // SHOWS
+
+            // Anime
+            AddCategoryMapping(31, TorznabCatType.TVAnime);             // MOVIES ANIME
+            AddCategoryMapping(32, TorznabCatType.TVAnime);             // SERIES ANIME
+
+            // Documentaries
+            AddCategoryMapping(12, TorznabCatType.TVDocumentary);       // DOCS
+
+            // Music
+            AddCategoryMapping(20, TorznabCatType.AudioVideo);          // CONCERT
+
+            // Other
+            AddCategoryMapping(21, TorznabCatType.PC);                  // PC
+            AddCategoryMapping(22, TorznabCatType.PCMac);               // PC
+            AddCategoryMapping(25, TorznabCatType.PCGames);             // GAMES
+            AddCategoryMapping(26, TorznabCatType.ConsoleXbox360);      // GAMES
+            AddCategoryMapping(28, TorznabCatType.ConsoleWii);          // GAMES
+            AddCategoryMapping(27, TorznabCatType.ConsolePS3);          // GAMES
+            AddCategoryMapping(29, TorznabCatType.ConsoleNDS);          // GAMES
+            AddCategoryMapping(24, TorznabCatType.BooksEbook);          // EBOOKS
+            AddCategoryMapping(96, TorznabCatType.BooksEbook);          // EBOOKS MAGAZINES
+            AddCategoryMapping(99, TorznabCatType.BooksEbook);          // EBOOKS ANIME
+            AddCategoryMapping(23, TorznabCatType.PCPhoneAndroid);      // ANDROID
+        }
+
+        /// <summary>
+        /// Configure our Provider
+        /// </summary>
+        /// <param name="configJson">Our params in Json</param>
+        /// <returns>Configuration state</returns>
+        #pragma warning disable 1998
+        public async Task<IndexerConfigurationStatus> ApplyConfiguration(JToken configJson)
+        #pragma warning restore 1998
+        {
+            // Provider not yet configured
+            IsConfigured = false;
+
+            // Retrieve config values set by Jackett's user
+            ConfigData.LoadValuesFromJson(configJson);
+
+            // Check & Validate Config
+            ValidateConfig();
+
+            // Setting our data for a better emulated browser (maximum security)
+            // TODO: Encoded Content not supported by Jackett at this time
+            // emulatedBrowserHeaders.Add("Accept-Encoding", "gzip, deflate");
+
+            // Clean headers
+            EmulatedBrowserHeaders.Clear();
+
+            // Inject headers
+            EmulatedBrowserHeaders.Add("Accept", "application/json-rpc, application/json");
+            EmulatedBrowserHeaders.Add("Content-Type", "application/json-rpc");
+
+            // Tracker is now configured
+            IsConfigured = true;
+
+            // Saving data
+            SaveConfig();
+
+            return IndexerConfigurationStatus.RequiresTesting;
+        }
+
+        /// <summary>
+        /// Execute our search query
+        /// </summary>
+        /// <param name="query">Query</param>
+        /// <returns>Releases</returns>
+        public async Task<IEnumerable<ReleaseInfo>> PerformQuery(TorznabQuery query)
+        {
+            var releases = new List<ReleaseInfo>();
+            var searchTerm = query.GetQueryString();
+
+            // Check cache first so we don't query the server (if search term used or not in dev mode)
+            if(!DevMode && !string.IsNullOrEmpty(searchTerm))
+            {
+                lock (cache)
+                {
+                    // Remove old cache items
+                    CleanCache();
+
+                    // Search in cache
+                    var cachedResult = cache.FirstOrDefault(i => i.Query == searchTerm);
+                    if (cachedResult != null)
+                        return cachedResult.Results.Select(s => (ReleaseInfo)s.Clone()).ToArray();
+                }
+            }
+
+            // Build our query
+            var request = BuildQuery(searchTerm, query, ApiEndpoint);
+
+            // Getting results & Store content
+            var results = await QueryExec(request);
+
+            try
+            {
+                // Deserialize our Json Response
+                var xthorResponse = JsonConvert.DeserializeObject<XthorResponse>(results.Content);
+
+                // Check Tracker's State
+                CheckApiState(xthorResponse.error);
+
+                // If contains torrents
+                if (xthorResponse.torrents != null)
+                {
+                    // Adding each torrent row to releases
+                    releases.AddRange(xthorResponse.torrents.Select(torrent => new ReleaseInfo
+                    {
+                        // Mapping data
+                        Category = MapTrackerCatToNewznab(torrent.category.ToString()),
+                        Title = torrent.name, Seeders = torrent.seeders,
+                        Peers = torrent.seeders + torrent.leechers,
+                        MinimumRatio = 1,
+                        MinimumSeedTime = 345600,
+                        PublishDate = DateTimeUtil.UnixTimestampToDateTime(torrent.added),
+                        Size = torrent.size,
+                        Guid = new Uri(TorrentDescriptionUrl.Replace("{id}", torrent.id.ToString())),
+                        Comments = new Uri(TorrentCommentUrl.Replace("{id}", torrent.id.ToString())),
+                        Link = new Uri(torrent.download_link)
+                    }));
+                }
+            }
+            catch (Exception ex)
+            {
+                OnParseError("Error, unable to parse result \n" + ex.StackTrace, ex);
+            }
+
+            // Return found releases
+            return releases;
+        }
+
+        /// <summary>
+        /// Response from Tracker's API
+        /// </summary>
+        public class XthorResponse
+        {
+            public XthorError error { get; set; }
+            public XthorUser user { get; set; }
+            public List<XthorTorrent> torrents { get; set; }
+        }
+
+        /// <summary>
+        /// State of API
+        /// </summary>
+        public class XthorError
+        {
+            public int code { get; set; }
+            public string descr { get; set; }
+        }
+
+        /// <summary>
+        /// User Informations
+        /// </summary>
+        public class XthorUser
+        {
+            public int id { get; set; }
+            public string username { get; set; }
+            public long uploaded { get; set; }
+            public long downloaded { get; set; }
+            public int uclass { get; set; } // Class is a reserved keyword.
+            public decimal bonus_point { get; set; }
+            public int hits_and_run { get; set; }
+            public string avatar_url { get; set; }
+        }
+
+        /// <summary>
+        /// Torrent Informations
+        /// </summary>
+        public class XthorTorrent
+        {
+            public int id { get; set; }
+            public int category { get; set; }
+            public int seeders { get; set; }
+            public int leechers { get; set; }
+            public string name { get; set; }
+            public int times_completed { get; set; }
+            public long size { get; set; }
+            public int added { get; set; }
+            public int freeleech { get; set; }
+            public int numfiles { get; set; }
+            public string release_group { get; set; }
+            public string download_link { get; set; }
+        }
+
+        /// <summary>
+        /// Build query to process
+        /// </summary>
+        /// <param name="term">Term to search</param>
+        /// <param name="query">Torznab Query for categories mapping</param>
+        /// <param name="url">Search url for provider</param>
+        /// <returns>URL to query for parsing and processing results</returns>
+        private string BuildQuery(string term, TorznabQuery query, string url)
+        {
+            var parameters = new NameValueCollection();
+            var categoriesList = MapTorznabCapsToTrackers(query);
+
+            // Passkey
+            parameters.Add("passkey", ConfigData.PassKey.Value);
+
+            // If search term provided
+            if (!string.IsNullOrWhiteSpace(term))
+            {
+                // Add search term
+                // ReSharper disable once AssignNullToNotNullAttribute
+                parameters.Add("search", HttpUtility.UrlEncode(term));
+            }
+            else
+            {
+                parameters.Add("search", string.Empty);
+                // Showing all torrents (just for output function)
+                term = "all";
+            }
+
+            // Loop on Categories needed
+            switch (categoriesList.Count)
+            {
+                case 0:
+                    // No category
+                    parameters.Add("category", string.Empty);
+                    break;
+                case 1:
+                    // One category
+                    parameters.Add("category", categoriesList[0]);
+                    break;
+                default:
+                    // Multiple Categories
+                    string categories = null;
+                    foreach (var category in categoriesList)
+                    {
+                        // Initiate our categories parameter
+                        if (categoriesList.First() == category)
+                        {
+                            categories = categoriesList[0];
+                        }
+                        // Adding next categories
+                        categories += "+" + category;
+                    }
+                    // Add categories
+                    if (categories != null) parameters.Add("category", categories);
+                    break;
+            }
+
+            // If Only Freeleech Enabled
+            if (ConfigData.Freeleech.Value)
+            {
+                parameters.Add("freeleech", "1");
+            }
+
+            // Building our query -- Cannot use GetQueryString due to UrlEncode (generating wrong category param)
+            url += "?" + string.Join("&", parameters.AllKeys.Select(a => a + "=" + parameters[a]));
+
+            Output("\nBuilded query for \"" + term + "\"... " + url);
+
+            // Return our search url
+            return url;
+        }
+
+        /// <summary>
+        /// Switch Method for Querying
+        /// </summary>
+        /// <param name="request">URL created by Query Builder</param>
+        /// <returns>Results from query</returns>
+        private async Task<WebClientStringResult> QueryExec(string request)
+        {
+            WebClientStringResult results;
+
+            // Switch in we are in DEV mode with Hard Drive Cache or not
+            if (DevMode && CacheMode)
+            {
+                // Check Cache before querying and load previous results if available
+                results = await QueryCache(request);
+            }
+            else
+            {
+                // Querying tracker directly
+                results = await QueryTracker(request);
+            }
+            return results;
+        }
+
+        /// <summary>
+        /// Get Torrents Page from Cache by Query Provided
+        /// </summary>
+        /// <param name="request">URL created by Query Builder</param>
+        /// <returns>Results from query</returns>
+        private async Task<WebClientStringResult> QueryCache(string request)
+        {
+            WebClientStringResult results;
+
+            // Create Directory if not exist
+            System.IO.Directory.CreateDirectory(Directory);
+
+            // Clean Storage Provider Directory from outdated cached queries
+            CleanCacheStorage();
+
+            // Create fingerprint for request
+            string file = Directory + request.GetHashCode() + ".json";
+
+            // Checking modes states
+            if (System.IO.File.Exists(file))
+            {
+                // File exist... loading it right now !
+                Output("Loading results from hard drive cache ..." + request.GetHashCode() + ".json");
+                results = JsonConvert.DeserializeObject<WebClientStringResult>(System.IO.File.ReadAllText(file));
+            }
+            else
+            {
+                // No cached file found, querying tracker directly
+                results = await QueryTracker(request);
+
+                // Cached file didn't exist for our query, writing it right now !
+                Output("Writing results to hard drive cache ..." + request.GetHashCode() + ".json");
+                System.IO.File.WriteAllText(file, JsonConvert.SerializeObject(results));
+            }
+            return results;
+        }
+
+        /// <summary>
+        /// Get Torrents Page from Tracker by Query Provided
+        /// </summary>
+        /// <param name="request">URL created by Query Builder</param>
+        /// <returns>Results from query</returns>
+        private async Task<WebClientStringResult> QueryTracker(string request)
+        {
+            // Cache mode not enabled or cached file didn't exist for our query
+            Output("\nQuerying tracker for results....");
+
+            // Build WebRequest for index
+            var myIndexRequest = new WebRequest()
+            {
+                Type = RequestType.GET,
+                Url = request,
+                Headers = EmulatedBrowserHeaders
+            };
+
+            // Request our first page
+            var results = await webclient.GetString(myIndexRequest);
+
+            // Return results from tracker
+            return results;
+        }
+
+        /// <summary>
+        /// Check API's state
+        /// </summary>
+        /// <param name="state">State of API</param>
+        private void CheckApiState(XthorError state)
+        {
+            // Switch on state
+            switch (state.code)
+            {
+                case 0:
+                    // Everything OK
+                    Output("\nAPI State : Everything OK ... -> " + state.descr);
+                    break;
+                case 1:
+                    // Passkey not found
+                    Output("\nAPI State : Error, Passkey not found in tracker's database, aborting... -> " + state.descr);
+                    throw new Exception("API State : Error, Passkey not found in tracker's database, aborting... -> " + state.descr);
+                case 2:
+                    // No results
+                    Output("\nAPI State : No results for query ... -> " + state.descr);
+                    break;
+                case 3:
+                    // Power Saver
+                    Output("\nAPI State : Power Saver mode, only cached query with no parameters available ... -> " + state.descr);
+                    break;
+                case 4:
+                    // DDOS Attack, API disabled
+                    Output("\nAPI State : Tracker is under DDOS attack, API disabled, aborting ... -> " + state.descr);
+                    throw new Exception("\nAPI State : Tracker is under DDOS attack, API disabled, aborting ... -> " + state.descr);
+                default:
+                    // Unknown state
+                    Output("\nAPI State : Unknown state, aborting querying ... -> " + state.descr);
+                    throw new Exception("API State : Unknown state, aborting querying ... -> " + state.descr);
+            }
+        }
+
+        /// <summary>
+        /// Clean Hard Drive Cache Storage
+        /// </summary>
+        /// <param name="force">Force Provider Folder deletion</param>
+        private void CleanCacheStorage(bool force = false)
+        {
+            // Check cleaning method
+            if(force)
+            {
+                // Deleting Provider Storage folder and all files recursively
+                Output("\nDeleting Provider Storage folder and all files recursively ...");
+                
+                // Check if directory exist
+                if(System.IO.Directory.Exists(Directory))
+                {
+                    // Delete storage directory of provider
+                    System.IO.Directory.Delete(Directory, true);
+                    Output("-> Storage folder deleted successfully.");
+                }
+                else
+                {
+                    // No directory, so nothing to do
+                    Output("-> No Storage folder found for this provider !");
+                }
+            }
+            else
+            {
+                var i = 0;
+                // Check if there is file older than ... and delete them
+                Output("\nCleaning Provider Storage folder... in progress.");
+                System.IO.Directory.GetFiles(Directory)
+                .Select(f => new System.IO.FileInfo(f))
+                .Where(f => f.LastAccessTime < DateTime.Now.AddMilliseconds(-Convert.ToInt32(ConfigData.HardDriveCacheKeepTime.Value)))
+                .ToList()
+                .ForEach(f => {
+                    Output("Deleting cached file << " + f.Name + " >> ... done.");
+                    f.Delete();
+                    i++;
+                    });
+
+                // Inform on what was cleaned during process
+                if(i > 0) {
+                    Output("-> Deleted " + i + " cached files during cleaning.");
+                }
+                else {
+                    Output("-> Nothing deleted during cleaning.");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Output message for logging or developpment (console)
+        /// </summary>
+        /// <param name="message">Message to output</param>
+        /// <param name="level">Level for Logger</param>
+        private void Output(string message, string level = "debug")
+        {
+            // Check if we are in dev mode
+            if(DevMode)
+            {
+                // Output message to console
+                Console.WriteLine(message);
+            }
+            else
+            {
+                // Send message to logger with level
+                switch (level)
+                {
+                    default:
+                        goto case "debug";
+                    case "debug":
+                        // Only if Debug Level Enabled on Jackett
+                        if (Engine.Logger.IsDebugEnabled)
+                        {
+                            logger.Debug(message);
+                        }
+                        break;
+                    case "info":
+                        logger.Info(message);
+                        break;
+                    case "error":
+                        logger.Error(message);
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Validate Config entered by user on Jackett
+        /// </summary>
+        private void ValidateConfig()
+        {
+            Output("\nValidating Settings ... \n");
+
+            // Check Passkey Setting
+            if (string.IsNullOrEmpty(ConfigData.PassKey.Value))
+            {
+                throw new ExceptionWithConfigData("You must provide your passkey for this tracker to be allowed to use API !", ConfigData);
+            }
+            else
+            {
+                Output("Validated Setting -- PassKey (auth) => " + ConfigData.PassKey.Value);
+            }
+
+            // Check Dev Cache Settings
+            if (ConfigData.HardDriveCache.Value)
+            {
+                Output("\nValidated Setting -- DEV Hard Drive Cache enabled");
+
+                // Check if Dev Mode enabled !
+                if (!ConfigData.DevMode.Value)
+                {
+                    throw new ExceptionWithConfigData("Hard Drive is enabled but not in DEV MODE, Please enable DEV MODE !", ConfigData);
+                }
+
+                // Check Cache Keep Time Setting
+                if (!string.IsNullOrEmpty(ConfigData.HardDriveCacheKeepTime.Value))
+                {
+                    try
+                    {
+                        Output("Validated Setting -- Cache Keep Time (ms) => " + Convert.ToInt32(ConfigData.HardDriveCacheKeepTime.Value));
+                    }
+                    catch (Exception)
+                    {
+                        throw new ExceptionWithConfigData("Please enter a numeric hard drive keep time in ms !", ConfigData);
+                    }
+                }
+                else
+                {
+                    throw new ExceptionWithConfigData("Hard Drive Cache enabled, Please enter a maximum keep time for cache !", ConfigData);
+                }
+            }
+            else
+            {
+                // Delete cache if previously existed
+                CleanCacheStorage(true);
+            }
+        }
+    }
+}

src/Jackett/Jackett.csproj

@@ -58,8 +58,8 @@
     </StartupObject>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="AngleSharp, Version=0.9.4.42449, Culture=neutral, PublicKeyToken=e83494dcdc6d31ea, processorArchitecture=MSIL">
-      <HintPath>..\packages\AngleSharp.0.9.4\lib\net45\AngleSharp.dll</HintPath>
+    <Reference Include="AngleSharp, Version=0.9.5.41771, Culture=neutral, PublicKeyToken=e83494dcdc6d31ea, processorArchitecture=MSIL">
+      <HintPath>..\packages\AngleSharp.0.9.5\lib\net45\AngleSharp.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="Autofac, Version=3.5.0.0, Culture=neutral, PublicKeyToken=17863af14b0044da, processorArchitecture=MSIL">
@@ -186,6 +186,9 @@
     <Compile Include="Controllers\TorznabController.cs" />
     <Compile Include="Controllers\DownloadController.cs" />
     <Compile Include="Engine.cs" />
+    <Compile Include="Indexers\MyAnonamouse.cs" />
+    <Compile Include="Indexers\Xthor.cs" />
+    <Compile Include="Indexers\PhxBit.cs" />
     <Compile Include="Indexers\AlphaRatio.cs" />
     <Compile Include="Indexers\BitSoup.cs" />
     <Compile Include="Indexers\BlueTigers.cs" />
@@ -200,7 +203,9 @@
     <Compile Include="Indexers\BroadcastTheNet.cs" />
     <Compile Include="Indexers\DanishBits.cs" />
     <Compile Include="Indexers\Abnormal.cs" />
+    <Compile Include="Indexers\Fuzer.cs" />
     <Compile Include="Indexers\GFTracker.cs" />
+    <Compile Include="Indexers\ILoveTorrents.cs" />
     <Compile Include="Indexers\RevolutionTT.cs" />
     <Compile Include="Indexers\TehConnection.cs" />
     <Compile Include="Indexers\Hounddawgs.cs" />
@@ -212,18 +217,22 @@
     <Compile Include="Indexers\ImmortalSeed.cs" />
     <Compile Include="Indexers\FileList.cs" />
     <Compile Include="Indexers\Abstract\AvistazTracker.cs" />
-    <Compile Include="Indexers\FrenchADN.cs" />
+    <Compile Include="Indexers\FrenchAdn.cs" />
+    <Compile Include="Indexers\TransmitheNet.cs" />
     <Compile Include="Indexers\WiHD.cs" />
     <Compile Include="Indexers\XSpeeds.cs" />
     <Compile Include="Models\GitHub\Asset.cs" />
     <Compile Include="Models\GitHub\Release.cs" />
+    <Compile Include="Models\IndexerConfig\Bespoke\ConfigurationDataXthor.cs" />
+    <Compile Include="Models\IndexerConfig\Bespoke\ConfigurationDataPhxBit.cs" />
     <Compile Include="Models\IndexerConfig\Bespoke\ConfigurationDataBlueTigers.cs" />
     <Compile Include="Models\IndexerConfig\Bespoke\ConfigurationDataAbnormal.cs" />
-    <Compile Include="Models\IndexerConfig\Bespoke\ConfigurationDataFrenchADN.cs" />
+    <Compile Include="Models\IndexerConfig\Bespoke\ConfigurationDataFrenchAdn.cs" />
     <Compile Include="Models\IndexerConfig\Bespoke\ConfigurationDataWiHD.cs" />
     <Compile Include="Models\IndexerConfig\ConfigurationDataBasicLoginWithFilter.cs" />
     <Compile Include="Models\IndexerConfig\ConfigurationDataAPIKey.cs" />
     <Compile Include="Models\IndexerConfig\ConfigurationDataBasicLoginWithRSSAndDisplay.cs" />
+    <Compile Include="Models\IndexerConfig\ConfigurationDataBasicLoginWithAlternateLink.cs" />
     <Compile Include="Models\ManualSearchResult.cs" />
     <Compile Include="Indexers\TVChaosUK.cs" />
     <Compile Include="Indexers\NCore.cs" />
@@ -233,6 +242,7 @@
     <Compile Include="Indexers\Pretome.cs" />
     <Compile Include="Indexers\PrivateHD.cs" />
     <Compile Include="Indexers\SceneAccess.cs" />
+    <Compile Include="Indexers\SceneFZ.cs" />
     <Compile Include="Indexers\SceneTime.cs" />
     <Compile Include="Indexers\SpeedCD.cs" />
     <Compile Include="Indexers\TorrentDay.cs" />
@@ -318,6 +328,7 @@
     <Compile Include="Startup.cs" />
     <Compile Include="Models\TorznabQuery.cs" />
     <Compile Include="CurlHelper.cs" />
+    <Compile Include="Utils\StringCipher.cs" />
     <Compile Include="Utils\StringUtil.cs" />
     <Compile Include="Utils\TorznabCapsUtil.cs" />
     <Compile Include="Utils\Clients\UnixSafeCurlWebClient.cs" />
@@ -436,6 +447,15 @@
     <Content Include="Content\login.html">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Content\logos\myanonamouse.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Content\logos\xthor.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="Content\logos\phxbit.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="Content\logos\animebytes.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -469,6 +489,9 @@
     <Content Include="Content\logos\filelist.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Content\logos\fuzer.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="Content\logos\gftracker.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -478,6 +501,9 @@
     <Content Include="Content\logos\hdtorrents.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Content\logos\ilovetorrents.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="Content\logos\immortalseed.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -499,6 +525,9 @@
     <Content Include="Content\logos\sceneaccess.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Content\logos\scenefz.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="Content\logos\scenetime.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -571,6 +600,9 @@
     <Content Include="Content\logos\torrentleech.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Content\logos\transmithenet.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="Content\logos\tvchaosuk.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>

src/Jackett/Models/IndexerConfig/Bespoke/ConfigurationDataFrenchADN.cs

@@ -1,6 +1,6 @@
 namespace Jackett.Models.IndexerConfig.Bespoke
 {
-    class ConfigurationDataFrenchADN : ConfigurationData
+    internal class ConfigurationDataFrenchAdn : ConfigurationData
     {
         public DisplayItem CredentialsWarning { get; private set; }
         public StringItem Username { get; private set; }
@@ -16,7 +16,7 @@
         public DisplayItem HeadersWarning { get; private set; }
         public StringItem HeaderAccept { get; private set; }
         public StringItem HeaderAcceptLang { get; private set; }
-        public BoolItem HeaderDNT { get; private set; }
+        public BoolItem HeaderDnt { get; private set; }
         public BoolItem HeaderUpgradeInsecure { get; private set; }
         public StringItem HeaderUserAgent { get; private set; }
         public DisplayItem DevWarning { get; private set; }
@@ -24,8 +24,7 @@
         public BoolItem HardDriveCache { get; private set; }
         public StringItem HardDriveCacheKeepTime { get; private set; }
 
-        public ConfigurationDataFrenchADN()
-            : base()
+        public ConfigurationDataFrenchAdn()
         {
             CredentialsWarning = new DisplayItem("<b>Credentials Configuration</b> (<i>Private Tracker</i>),<br /><br /> <ul><li><b>Username</b> is your account name on this tracker.</li><li><b>Password</b> is your password associated to your account name.</li></ul>") { Name = "Credentials" };
             Username = new StringItem { Name = "Username (Required)", Value = "" };
@@ -41,7 +40,7 @@
             HeadersWarning = new DisplayItem("<b>Browser Headers Configuration</b> (<i>Required if browser simulation enabled</i>),<br /><br /> <ul><li>By filling these fields, <b>Jackett will inject headers</b> with your values <u>to simulate a real browser</u>.</li><li>You can get <b>your browser values</b> here: <a href='https://www.whatismybrowser.com/detect/what-http-headers-is-my-browser-sending' target='blank'>www.whatismybrowser.com</a></li></ul><br /><i><b>Note that</b> some headers are not necessary because they are injected automatically by this provider such as Accept_Encoding, Connection, Host or X-Requested-With</i>") { Name = "Injecting headers" };
             HeaderAccept = new StringItem { Name = "Accept", Value = "" };
             HeaderAcceptLang = new StringItem { Name = "Accept-Language", Value = "" };
-            HeaderDNT = new BoolItem { Name = "DNT", Value = false };
+            HeaderDnt = new BoolItem { Name = "DNT", Value = false };
             HeaderUpgradeInsecure = new BoolItem { Name = "Upgrade-Insecure-Requests", Value = false };
             HeaderUserAgent = new StringItem { Name = "User-Agent", Value = "" };
             DevWarning = new DisplayItem("<b>Development Facility</b> (<i>For Developers ONLY</i>),<br /><br /> <ul><li>By enabling development mode, <b>Jackett will bypass his cache</b> and will <u>output debug messages to console</u> instead of his log file.</li><li>By enabling Hard Drive Cache, <b>This provider</b> will <u>save each query answers from tracker</u> in temp directory, in fact this reduce drastically HTTP requests when building a provider at parsing step for example. So, <b> Jackett will search for a cached query answer on hard drive before executing query on tracker side !</b> <i>DEV MODE must be enabled to use it !</li></ul>") { Name = "Development" };

src/Jackett/Models/IndexerConfig/Bespoke/ConfigurationDataPhxBit.cs

@@ -0,0 +1,55 @@
+namespace Jackett.Models.IndexerConfig.Bespoke
+{
+    class ConfigurationDataPhxBit : ConfigurationData
+    {
+        public HiddenItem PassKey { get; set; }
+        public DisplayItem CredentialsWarning { get; private set; }
+        public StringItem Username { get; private set; }
+        public StringItem Password { get; private set; }
+        public DisplayItem PagesWarning { get; private set; }
+        public StringItem Pages { get; private set; }
+        public DisplayItem SecurityWarning { get; private set; }
+        public BoolItem Latency { get; private set; }
+        public BoolItem Browser { get; private set; }
+        public DisplayItem LatencyWarning { get; private set; }
+        public StringItem LatencyStart { get; private set; }
+        public StringItem LatencyEnd { get; private set; }
+        public DisplayItem HeadersWarning { get; private set; }
+        public StringItem HeaderAccept { get; private set; }
+        public StringItem HeaderAcceptLang { get; private set; }
+        public BoolItem HeaderDNT { get; private set; }
+        public BoolItem HeaderUpgradeInsecure { get; private set; }
+        public StringItem HeaderUserAgent { get; private set; }
+        public DisplayItem DevWarning { get; private set; }
+        public BoolItem DevMode { get; private set; }
+        public BoolItem HardDriveCache { get; private set; }
+        public StringItem HardDriveCacheKeepTime { get; private set; }
+
+        public ConfigurationDataPhxBit()
+            : base()
+        {
+            PassKey = new HiddenItem { Name = "PassKey", Value = "" };
+            CredentialsWarning = new DisplayItem("<b>Credentials Configuration</b> (<i>Private Tracker</i>),<br /><br /> <ul><li><b>Username</b> is your account name on this tracker.</li><li><b>Password</b> is your password associated to your account name.</li></ul>") { Name = "Credentials" };
+            Username = new StringItem { Name = "Username (Required)", Value = "" };
+            Password = new StringItem { Name = "Password (Required)", Value = "" };
+            PagesWarning = new DisplayItem("<b>Preferences Configuration</b> (<i>Tweak your search settings</i>),<br /><br /> <ul><li><b>Max Pages to Process</b> let you specify how many page (max) Jackett can process when doing a search. Setting a value <b>higher than 4 is dangerous</b> for you account ! (<b>Result of too many requests to tracker...that <u>will be suspect</u></b>).</li></ul>") { Name  = "Preferences" };
+            Pages = new StringItem { Name = "Max Pages to Process (Required)", Value = "4" };
+            SecurityWarning = new DisplayItem("<b>Security Configuration</b> (<i>Read this area carefully !</i>),<br /><br /> <ul><li><b>Latency Simulation</b> will simulate human browsing with Jacket by pausing Jacket for an random time between each request, to fake a real content browsing.</li><li><b>Browser Simulation</b> will simulate a real human browser by injecting additionals headers when doing requests to tracker.</li></ul>") { Name = "Security" };
+            Latency = new BoolItem() { Name = "Latency Simulation (Optional)", Value = false };
+            Browser = new BoolItem() { Name = "Browser Simulation (Optional)", Value = true };
+            LatencyWarning = new DisplayItem("<b>Latency Configuration</b> (<i>Required if latency simulation enabled</i>),<br /><br/> <ul><li>By filling this range, <b>Jackett will make a random timed pause</b> <u>between requests</u> to tracker <u>to simulate a real browser</u>.</li><li>MilliSeconds <b>only</b></li></ul>") { Name = "Simulate Latency" };
+            LatencyStart = new StringItem { Name = "Minimum Latency (ms)", Value = "1589" };
+            LatencyEnd = new StringItem { Name = "Maximum Latency (ms)", Value = "3674" };
+            HeadersWarning = new DisplayItem("<b>Browser Headers Configuration</b> (<i>Required if browser simulation enabled</i>),<br /><br /> <ul><li>By filling these fields, <b>Jackett will inject headers</b> with your values <u>to simulate a real browser</u>.</li><li>You can get <b>your browser values</b> here: <a href='https://www.whatismybrowser.com/detect/what-http-headers-is-my-browser-sending' target='blank'>www.whatismybrowser.com</a></li></ul><br /><i><b>Note that</b> some headers are not necessary because they are injected automatically by this provider such as Accept_Encoding, Connection, Host or X-Requested-With</i>") { Name = "Injecting headers" };
+            HeaderAccept = new StringItem { Name = "Accept", Value = "" };
+            HeaderAcceptLang = new StringItem { Name = "Accept-Language", Value = "" };
+            HeaderDNT = new BoolItem { Name = "DNT", Value = false };
+            HeaderUpgradeInsecure = new BoolItem { Name = "Upgrade-Insecure-Requests", Value = false };
+            HeaderUserAgent = new StringItem { Name = "User-Agent", Value = "" };
+            DevWarning = new DisplayItem("<b>Development Facility</b> (<i>For Developers ONLY</i>),<br /><br /> <ul><li>By enabling development mode, <b>Jackett will bypass his cache</b> and will <u>output debug messages to console</u> instead of his log file.</li><li>By enabling Hard Drive Cache, <b>This provider</b> will <u>save each query answers from tracker</u> in temp directory, in fact this reduce drastically HTTP requests when building a provider at parsing step for example. So, <b> Jackett will search for a cached query answer on hard drive before executing query on tracker side !</b> <i>DEV MODE must be enabled to use it !</li></ul>") { Name = "Development" };
+            DevMode = new BoolItem { Name = "Enable DEV MODE (Developers ONLY)", Value = false };
+            HardDriveCache = new BoolItem { Name = "Enable HARD DRIVE CACHE (Developers ONLY)", Value = false };
+            HardDriveCacheKeepTime = new StringItem { Name = "Keep Cached files for (ms)", Value = "300000" };
+            }
+    }
+}

src/Jackett/Models/IndexerConfig/Bespoke/ConfigurationDataXthor.cs

@@ -0,0 +1,27 @@
+namespace Jackett.Models.IndexerConfig.Bespoke
+{
+    class ConfigurationDataXthor : ConfigurationData
+    {
+        public DisplayItem CredentialsWarning { get; private set; }
+        public StringItem PassKey { get; set; }
+        public DisplayItem PagesWarning { get; private set; }
+        public BoolItem Freeleech { get; private set; }
+        public DisplayItem DevWarning { get; private set; }
+        public BoolItem DevMode { get; private set; }
+        public BoolItem HardDriveCache { get; private set; }
+        public StringItem HardDriveCacheKeepTime { get; private set; }
+
+        public ConfigurationDataXthor()
+            : base()
+        {
+            CredentialsWarning = new DisplayItem("<b>Credentials Configuration</b> (<i>Private Tracker</i>),<br /><br /> <ul><li><b>PassKey</b> is your private key on your account</li></ul>") { Name = "Credentials" };
+            PassKey = new StringItem { Name = "PassKey", Value = "" };
+            PagesWarning = new DisplayItem("<b>Preferences Configuration</b> (<i>Tweak your search settings</i>),<br /><br /> <ul><li><b>Freeleech Only</b> let you search <u>only</u> for torrents which are marked Freeleech.</li></ul>") { Name  = "Preferences" };
+            Freeleech = new BoolItem() { Name = "Freeleech Only (Optional)", Value = false };
+            DevWarning = new DisplayItem("<b>Development Facility</b> (<i>For Developers ONLY</i>),<br /><br /> <ul><li>By enabling development mode, <b>Jackett will bypass his cache</b> and will <u>output debug messages to console</u> instead of his log file.</li><li>By enabling Hard Drive Cache, <b>This provider</b> will <u>save each query answers from tracker</u> in temp directory, in fact this reduce drastically HTTP requests when building a provider at parsing step for example. So, <b> Jackett will search for a cached query answer on hard drive before executing query on tracker side !</b> <i>DEV MODE must be enabled to use it !</li></ul>") { Name = "Development" };
+            DevMode = new BoolItem { Name = "Enable DEV MODE (Developers ONLY)", Value = false };
+            HardDriveCache = new BoolItem { Name = "Enable HARD DRIVE CACHE (Developers ONLY)", Value = false };
+            HardDriveCacheKeepTime = new StringItem { Name = "Keep Cached files for (ms)", Value = "300000" };
+            }
+    }
+}

src/Jackett/Models/IndexerConfig/ConfigurationDataBasicLoginWithAlternateLink.cs

@@ -0,0 +1,27 @@
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett.Models.IndexerConfig
+{
+    public class ConfigurationDataBasicLoginWithAlternateLink : ConfigurationData
+    {
+        public StringItem Username { get; private set; }
+        public StringItem Password { get; private set; }
+        public DisplayItem Instructions { get; private set; }
+        public StringItem AlternateLink { get; set; }
+
+        public ConfigurationDataBasicLoginWithAlternateLink(string instructionMessageOptional = null)
+        {
+            Username = new StringItem { Name = "Username" };
+            Password = new StringItem { Name = "Password" };
+            Instructions = new DisplayItem(instructionMessageOptional) { Name = "" };
+            AlternateLink = new StringItem { Name = "Alternate Link" };
+        }
+
+
+    }
+}

src/Jackett/Models/IndexerConfig/ConfigurationDataBasicLoginWithFilter.cs

@@ -11,6 +11,7 @@ namespace Jackett.Models.IndexerConfig
     {
         public StringItem Username { get; private set; }
         public StringItem Password { get; private set; }
+        public HiddenItem LastLoggedInCheck { get; private set; }
         public DisplayItem FilterExample { get; private set; }
         public StringItem FilterString { get; private set; }
         
@@ -18,6 +19,7 @@ namespace Jackett.Models.IndexerConfig
         {
             Username = new StringItem { Name = "Username" };
             Password = new StringItem { Name = "Password" };
+            LastLoggedInCheck = new HiddenItem { Name = "LastLoggedInCheck" };
             FilterExample = new DisplayItem(FilterInstructions)
             {
                 Name = ""

src/Jackett/Models/IndexerConfig/ConfigurationDataCaptchaLogin.cs

@@ -18,13 +18,17 @@ namespace Jackett.Models.IndexerConfig
 
         public HiddenItem CaptchaCookie { get; private set; }
 
-        public ConfigurationDataCaptchaLogin()
+        public DisplayItem Instructions { get; private set; }
+
+        /// <param name="instructionMessageOptional">Enter any instructions the user will need to setup the tracker</param>
+        public ConfigurationDataCaptchaLogin(string instructionMessageOptional = null)
         {
             Username = new StringItem { Name = "Username" };
             Password = new StringItem { Name = "Password" };
             CaptchaImage = new ImageItem { Name = "Captcha Image" };
             CaptchaText = new StringItem { Name = "Captcha Text" };
             CaptchaCookie = new HiddenItem("") { Name = "Captcha Cookie" };
+            Instructions = new DisplayItem(instructionMessageOptional) { Name = "" };
         }
     }
 }

src/Jackett/Models/TorznabQuery.cs

@@ -18,6 +18,7 @@ namespace Jackett.Models
         public int Limit { get; set; }
         public int Offset { get; set; }
         public int RageID { get; set; }
+        public string ImdbID { get; set; }
 
         public int Season { get; set; }
         public string Episode { get; set; }

src/Jackett/Services/ProtectionService.cs

@@ -6,6 +6,7 @@ using System.Reflection;
 using System.Security.Cryptography;
 using System.Text;
 using System.Threading.Tasks;
+using Jackett.Utils;
 
 namespace Jackett.Services
 {
@@ -18,6 +19,7 @@ namespace Jackett.Services
     public class ProtectionService : IProtectionService
     {
         DataProtectionScope PROTECTION_SCOPE = DataProtectionScope.LocalMachine;
+        private const string JACKETT_KEY = "JACKETT_KEY";
         const string APPLICATION_KEY = "Dvz66r3n8vhTGip2/quiw5ISyM37f7L2iOdupzdKmzkvXGhAgQiWK+6F+4qpxjPVNks1qO7LdWuVqRlzgLzeW8mChC6JnBMUS1Fin4N2nS9lh4XPuCZ1che75xO92Nk2vyXUo9KSFG1hvEszAuLfG2Mcg1r0sVyVXd2gQDU/TbY=";
 
         IServerService serverService;
@@ -34,6 +36,34 @@ namespace Jackett.Services
         }
 
         public string Protect(string plainText)
+        {
+            var jackettKey = Environment.GetEnvironmentVariable(JACKETT_KEY);
+
+            if (jackettKey == null)
+            {
+                return ProtectDefaultMethod(plainText);
+            }
+            else
+            {
+                return ProtectUsingKey(plainText, jackettKey);
+            }
+        }
+
+        public string UnProtect(string plainText)
+        {
+            var jackettKey = Environment.GetEnvironmentVariable(JACKETT_KEY);
+
+            if (jackettKey == null)
+            {
+                return UnProtectDefaultMethod(plainText);
+            }
+            else
+            {
+                return UnProtectUsingKey(plainText, jackettKey);
+            }
+        }
+
+        private string ProtectDefaultMethod(string plainText)
         {
             if (string.IsNullOrEmpty(plainText))
                 return string.Empty;
@@ -72,7 +102,7 @@ namespace Jackett.Services
             return Convert.ToBase64String(protectedBytes);
         }
 
-        public string UnProtect(string plainText)
+        private string UnProtectDefaultMethod(string plainText)
         {
             if (string.IsNullOrEmpty(plainText))
                 return string.Empty;
@@ -111,6 +141,16 @@ namespace Jackett.Services
             return Encoding.UTF8.GetString(unprotectedBytes);
         }
 
+        private string ProtectUsingKey(string plainText, string key)
+        {
+            return StringCipher.Encrypt(plainText, key);
+        }
+
+        private string UnProtectUsingKey(string plainText, string key)
+        {
+            return StringCipher.Decrypt(plainText, key);
+        }
+
         public void Protect<T>(T obj)
         {
             var type = obj.GetType();

src/Jackett/Utils/StringCipher.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett.Utils
+{
+    public static class StringCipher
+    {
+        // This constant is used to determine the keysize of the encryption algorithm in bits.
+        // We divide this by 8 within the code below to get the equivalent number of bytes.
+        private const int Keysize = 256;
+
+        // This constant determines the number of iterations for the password bytes generation function.
+        private const int DerivationIterations = 1000;
+
+        public static string Encrypt(string plainText, string passPhrase)
+        {
+            // Salt and IV is randomly generated each time, but is preprended to encrypted cipher text
+            // so that the same Salt and IV values can be used when decrypting.  
+            var saltStringBytes = Generate256BitsOfRandomEntropy();
+            var ivStringBytes = Generate256BitsOfRandomEntropy();
+            var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
+            using (var password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes, DerivationIterations))
+            {
+                var keyBytes = password.GetBytes(Keysize / 8);
+                using (var symmetricKey = new RijndaelManaged())
+                {
+                    symmetricKey.BlockSize = 256;
+                    symmetricKey.Mode = CipherMode.CBC;
+                    symmetricKey.Padding = PaddingMode.PKCS7;
+                    using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, ivStringBytes))
+                    {
+                        using (var memoryStream = new MemoryStream())
+                        {
+                            using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
+                            {
+                                cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
+                                cryptoStream.FlushFinalBlock();
+                                // Create the final bytes as a concatenation of the random salt bytes, the random iv bytes and the cipher bytes.
+                                var cipherTextBytes = saltStringBytes;
+                                cipherTextBytes = cipherTextBytes.Concat(ivStringBytes).ToArray();
+                                cipherTextBytes = cipherTextBytes.Concat(memoryStream.ToArray()).ToArray();
+                                memoryStream.Close();
+                                cryptoStream.Close();
+                                return Convert.ToBase64String(cipherTextBytes);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public static string Decrypt(string cipherText, string passPhrase)
+        {
+            // Get the complete stream of bytes that represent:
+            // [32 bytes of Salt] + [32 bytes of IV] + [n bytes of CipherText]
+            var cipherTextBytesWithSaltAndIv = Convert.FromBase64String(cipherText);
+            // Get the saltbytes by extracting the first 32 bytes from the supplied cipherText bytes.
+            var saltStringBytes = cipherTextBytesWithSaltAndIv.Take(Keysize / 8).ToArray();
+            // Get the IV bytes by extracting the next 32 bytes from the supplied cipherText bytes.
+            var ivStringBytes = cipherTextBytesWithSaltAndIv.Skip(Keysize / 8).Take(Keysize / 8).ToArray();
+            // Get the actual cipher text bytes by removing the first 64 bytes from the cipherText string.
+            var cipherTextBytes = cipherTextBytesWithSaltAndIv.Skip((Keysize / 8) * 2).Take(cipherTextBytesWithSaltAndIv.Length - ((Keysize / 8) * 2)).ToArray();
+
+            using (var password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes, DerivationIterations))
+            {
+                var keyBytes = password.GetBytes(Keysize / 8);
+                using (var symmetricKey = new RijndaelManaged())
+                {
+                    symmetricKey.BlockSize = 256;
+                    symmetricKey.Mode = CipherMode.CBC;
+                    symmetricKey.Padding = PaddingMode.PKCS7;
+                    using (var decryptor = symmetricKey.CreateDecryptor(keyBytes, ivStringBytes))
+                    {
+                        using (var memoryStream = new MemoryStream(cipherTextBytes))
+                        {
+                            using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
+                            {
+                                var plainTextBytes = new byte[cipherTextBytes.Length];
+                                var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
+                                memoryStream.Close();
+                                cryptoStream.Close();
+                                return Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private static byte[] Generate256BitsOfRandomEntropy()
+        {
+            var randomBytes = new byte[32]; // 32 Bytes will give us 256 bits.
+            using (var rngCsp = new RNGCryptoServiceProvider())
+            {
+                // Fill the array with cryptographically secure random bytes.
+                rngCsp.GetBytes(randomBytes);
+            }
+            return randomBytes;
+        }
+    }
+}

src/Jackett/Utils/TorznabCapsUtil.cs

@@ -74,7 +74,7 @@ namespace Jackett.Utils
             // Filter out releases that do have a valid imdb ID, that is not equal to the one we're searching for.
             return
                 results.Where(
-                    result => !result.Imdb.HasValue || result.Imdb.Value == 0 || ("tt" + result.Imdb.Value).Equals(imdb));
+                    result => !result.Imdb.HasValue || result.Imdb.Value == 0 || ("tt" + result.Imdb.Value.ToString("D7")).Equals(imdb));
         } 
 
         private static string CleanTitle(string title)

src/Jackett/packages.config

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="AngleSharp" version="0.9.4" targetFramework="net45" />
+  <package id="AngleSharp" version="0.9.5" targetFramework="net45" />
   <package id="Autofac" version="3.5.2" targetFramework="net45" />
   <package id="Autofac.Owin" version="3.1.0" targetFramework="net45" />
   <package id="Autofac.WebApi" version="3.1.0" targetFramework="net45" />