Пример #1
0
        public AlphaRatio(IIndexerManagerService i, IWebClient w, Logger l, IProtectionService ps)
            : base(name: "AlphaRatio",
                description: "Legendary",
                link: "https://alpharatio.cc/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                downloadBase: "https://alpharatio.cc/torrents.php?action=download&id=",
                configData: new ConfigurationDataBasicLogin())
        {
            Encoding = Encoding.GetEncoding("UTF-8");
            Language = "en-us";

            AddCategoryMapping(1, TorznabCatType.TVSD);
            AddCategoryMapping(2, TorznabCatType.TVHD);
            AddCategoryMapping(6, TorznabCatType.MoviesSD);
            AddCategoryMapping(7, TorznabCatType.MoviesHD);
            AddCategoryMapping(10, TorznabCatType.XXX);
            AddCategoryMapping(20, TorznabCatType.XXX);
            AddCategoryMapping(12, TorznabCatType.PCGames);
            AddCategoryMapping(13, TorznabCatType.ConsoleXbox);
            AddCategoryMapping(14, TorznabCatType.ConsolePS3);
            AddCategoryMapping(15, TorznabCatType.ConsoleWii);
            AddCategoryMapping(16, TorznabCatType.PC);
            AddCategoryMapping(17, TorznabCatType.PCMac);
            AddCategoryMapping(19, TorznabCatType.PCPhoneOther);
            AddCategoryMapping(21, TorznabCatType.BooksEbook);
            AddCategoryMapping(22, TorznabCatType.AudioAudiobook);
            AddCategoryMapping(23, TorznabCatType.Audio);
        }
Пример #2
0
		public Hounddawgs(IIndexerManagerService i, Logger l, IWebClient c, IProtectionService ps)
			: base(name: "Hounddawgs",
				description: "A danish closed torrent tracker",
				link: "https://hounddawgs.org/",
				caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
				manager: i,
				client: c,
				logger: l,
				p: ps,
				configData: new NxtGnConfigurationData())
		{
			AddCategoryMapping(92, TorznabCatType.TV);
			AddCategoryMapping(92, TorznabCatType.TVHD);
			AddCategoryMapping(92, TorznabCatType.TVWEBDL);

			AddCategoryMapping(93, TorznabCatType.TVSD);
			AddCategoryMapping(93, TorznabCatType.TV);

			AddCategoryMapping(57, TorznabCatType.TV);
			AddCategoryMapping(57, TorznabCatType.TVHD);
			AddCategoryMapping(57, TorznabCatType.TVWEBDL);

			AddCategoryMapping(74, TorznabCatType.TVSD);
			AddCategoryMapping(74, TorznabCatType.TV);

		}
Пример #3
0
        public HDTorrents(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "HD-Torrents",
                description: "HD-Torrents is a private torrent website with HD torrents and strict rules on their content.",
                link: "http://hdts.ru/",// Of the accessible domains the .ru seems the most reliable.  https://hdts.ru | https://hd-torrents.org | https://hd-torrents.net | https://hd-torrents.me
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataBasicLogin())
        {
            TorznabCaps.Categories.Clear();

            AddCategoryMapping("1", TorznabCatType.MoviesHD);// Movie/Blu-Ray
            AddCategoryMapping("2", TorznabCatType.MoviesHD);// Movie/Remux
            AddCategoryMapping("5", TorznabCatType.MoviesHD);//Movie/1080p/i
            AddCategoryMapping("3", TorznabCatType.MoviesHD);//Movie/720p
            AddCategoryMapping("63", TorznabCatType.Audio);//Movie/Audio Track

            AddCategoryMapping("59", TorznabCatType.TVHD);//TV Show/Blu-ray
            AddCategoryMapping("60", TorznabCatType.TVHD);//TV Show/Remux
            AddCategoryMapping("30", TorznabCatType.TVHD);//TV Show/1080p/i
            AddCategoryMapping("38", TorznabCatType.TVHD);//TV Show/720p

            AddCategoryMapping("44", TorznabCatType.Audio);//Music/Album
            AddCategoryMapping("61", TorznabCatType.AudioVideo);//Music/Blu-Ray
            AddCategoryMapping("62", TorznabCatType.AudioVideo);//Music/Remux
            AddCategoryMapping("57", TorznabCatType.AudioVideo);//Music/1080p/i
            AddCategoryMapping("45", TorznabCatType.AudioVideo);//Music/720p

            AddCategoryMapping("58", TorznabCatType.XXX);//XXX/Blu-ray
            AddCategoryMapping("48", TorznabCatType.XXX);//XXX/1080p/i
            AddCategoryMapping("47", TorznabCatType.XXX);//XXX/720p
        }
Пример #4
0
        public PassThePopcorn(IIndexerManagerService i, Logger l, IWebClient c, IProtectionService ps)
            : base(name: "PassThePopcorn",
                description: "PassThePopcorn",
                link: "https://passthepopcorn.me/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: c,
                logger: l,
                p: ps,
                configData: new ConfigurationDataBasicLoginWithFilterAndPasskey(@"Enter filter options below to restrict search results. 
                                                                        Separate options with a space if using more than one option.<br>Filter options available:
                                                                        <br><code>GoldenPopcorn</code><br><code>Scene</code><br><code>Checked</code>"))
        {
            Encoding = Encoding.UTF8;
            Language = "en-us";

            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);
        }
Пример #5
0
        public Rarbg(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
            : base(name: "RARBG",
                description: "RARBG",
                link: defaultSiteLink,
                caps: new TorznabCapabilities(),
                manager: i,
                client: wc,
                logger: l,
                p: ps,
                configData: new ConfigurationDataUrl(defaultSiteLink))
        {
            categoryLabels = new Dictionary<string, int>();

            AddCat(4, TorznabCatType.XXX, "XXX (18+)");
            AddCat(14, TorznabCatType.MoviesSD, "Movies/XVID");
            AddCat(48, TorznabCatType.MoviesHD, "Movies/XVID/720");
            AddCat(17, TorznabCatType.MoviesSD, "Movies/x264");
            AddCat(44, TorznabCatType.MoviesHD, "Movies/x264/1080");
            AddCat(45, TorznabCatType.MoviesHD, "Movies/x264/720");
            AddCat(47, TorznabCatType.Movies3D, "Movies/x264/3D");
            AddCat(42, TorznabCatType.MoviesBluRay, "Movies/Full BD");
            AddCat(46, TorznabCatType.MoviesBluRay, "Movies/BD Remux");
            AddCat(18, TorznabCatType.TVSD, "TV Episodes");
            AddCat(41, TorznabCatType.TVHD, "TV HD Episodes");
            AddCat(23, TorznabCatType.AudioMP3, "Music/MP3");
            AddCat(25, TorznabCatType.AudioLossless, "Music/FLAC");
            AddCat(27, TorznabCatType.PCGames, "Games/PC ISO");
            AddCat(28, TorznabCatType.PCGames, "Games/PC RIP");
            AddCat(40, TorznabCatType.ConsolePS3, "Games/PS3");
            AddCat(32, TorznabCatType.ConsoleXbox360, "Games/XBOX-360");
            AddCat(33, TorznabCatType.PCISO, "Software/PC ISO");
            AddCat(35, TorznabCatType.BooksEbook, "e-Books");
        }
Пример #6
0
        public BitHdtv(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "BIT-HDTV",
                description: "Home of high definition invites",
                link: "https://www.bit-hdtv.com/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataBasicLogin())
        {
            Encoding = Encoding.GetEncoding("iso-8859-1");
            Language = "en-us";

            AddCategoryMapping(1, TorznabCatType.TVAnime); // Anime
            AddCategoryMapping(2, TorznabCatType.MoviesBluRay); // Blu-ray
            AddCategoryMapping(4, TorznabCatType.TVDocumentary); // Documentaries
            AddCategoryMapping(6, TorznabCatType.AudioLossless); // HQ Audio
            AddCategoryMapping(7, TorznabCatType.Movies); // Movies
            AddCategoryMapping(8, TorznabCatType.AudioVideo); // Music Videos
            AddCategoryMapping(5, TorznabCatType.TVSport); // Sports
            AddCategoryMapping(10, TorznabCatType.TV); // TV
            AddCategoryMapping(12, TorznabCatType.TV); // TV/Seasonpack
            AddCategoryMapping(11, TorznabCatType.XXX); // XXX
        }
Пример #7
0
        public Strike(IIndexerManagerService i, Logger l, IWebClient wc, IProtectionService ps)
            : base(name: "Strike",
                description: "Torrent search engine",
                link: defaultSiteLink,
                caps: new TorznabCapabilities(),
                manager: i,
                client: wc,
                logger: l,
                p: ps,
                configData: new ConfigurationDataStrike(defaultSiteLink))
        {
            AddCategoryMapping("Anime", TorznabCatType.TVAnime);
            AddCategoryMapping("Applications", TorznabCatType.PC);
            AddCategoryMapping("Books", TorznabCatType.Books);
            AddCategoryMapping("Games", TorznabCatType.PCGames);
            AddCategoryMapping("Movies", TorznabCatType.Movies);
            AddCategoryMapping("TV", TorznabCatType.TV);
            AddCategoryMapping("XXX", TorznabCatType.XXX);
            AddCategoryMapping("Music", TorznabCatType.Audio);

            /*AddCategoryMapping("Movies:Highres Movies", TorznabCatType.MoviesHD);
            AddCategoryMapping("Movies:3D Movies", TorznabCatType.Movies3D);
            AddCategoryMapping("Books:Ebooks", TorznabCatType.BooksEbook);
            AddCategoryMapping("Books:Comics", TorznabCatType.BooksComics);
            AddCategoryMapping("Books:Audio Books", TorznabCatType.AudioAudiobook);
            AddCategoryMapping("Games:XBOX360", TorznabCatType.ConsoleXbox360);
            AddCategoryMapping("Games:Wii", TorznabCatType.ConsoleWii);
            AddCategoryMapping("Games:PSP", TorznabCatType.ConsolePSP);
            AddCategoryMapping("Games:PS3", TorznabCatType.ConsolePS3);
            AddCategoryMapping("Games:PC", TorznabCatType.PCGames);
            AddCategoryMapping("Games:Android", TorznabCatType.PCPhoneAndroid);
            AddCategoryMapping("Music:Mp3", TorznabCatType.AudioMP3);*/
        }
Пример #8
0
 public AnimeTorrents(IIndexerManagerService i, HttpWebClient c, Logger l, IProtectionService ps)
     : base(name: "AnimeTorrents",
         description: "Definitive source for anime and manga",
         link: "http://animetorrents.me/",
         caps: new TorznabCapabilities(),
         manager: i,
         client: c, // Forced HTTP client for custom headers
         logger: l,
         p: ps,
         configData: new ConfigurationDataBasicLogin())
 {
     AddCategoryMapping(1, TorznabCatType.MoviesSD); // Anime Movie
     AddCategoryMapping(6, TorznabCatType.MoviesHD); // Anime Movie HD
     AddCategoryMapping(2, TorznabCatType.TVAnime); // Anime Series
     AddCategoryMapping(7, TorznabCatType.TVAnime); // Anime Series HD
     AddCategoryMapping(5, TorznabCatType.XXXDVD); // Hentai (censored)
     AddCategoryMapping(9, TorznabCatType.XXXDVD); // Hentai (censored) HD
     AddCategoryMapping(4, TorznabCatType.XXXDVD); // Hentai (un-censored)
     AddCategoryMapping(8, TorznabCatType.XXXDVD); // Hentai (un-censored) HD
     AddCategoryMapping(13, TorznabCatType.BooksForeign); // Light Novel
     AddCategoryMapping(3, TorznabCatType.BooksComics); // Manga
     AddCategoryMapping(10, TorznabCatType.BooksComics); // Manga 18+
     AddCategoryMapping(11, TorznabCatType.TVAnime); // OVA
     AddCategoryMapping(12, TorznabCatType.TVAnime); // OVA HD
     AddCategoryMapping(14, TorznabCatType.BooksComics); // Doujin Anime
     AddCategoryMapping(15, TorznabCatType.XXXDVD); // Doujin Anime 18+
     AddCategoryMapping(16, TorznabCatType.AudioForeign); // Doujin Music
     AddCategoryMapping(17, TorznabCatType.BooksComics); // Doujinshi
     AddCategoryMapping(18, TorznabCatType.BooksComics); // Doujinshi 18+
     AddCategoryMapping(19, TorznabCatType.Audio); // OST
 }
Пример #9
0
        public Hebits(IIndexerManagerService i, Logger l, IWebClient wc, IProtectionService ps)
            : base(name: "Hebits",
                description: "The Israeli Tracker",
                link: "https://hebits.net/",
                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                manager: i,
                client: wc,
                logger: l,
                p: ps,
                downloadBase: "https://hebits.net/",
                configData: new ConfigurationDataBasicLogin())
        {
            Encoding = Encoding.GetEncoding("windows-1255");
            Language = "he-il";

            AddCategoryMapping(19, TorznabCatType.MoviesSD);
            AddCategoryMapping(25, TorznabCatType.MoviesOther); // Israeli Content
            AddCategoryMapping(20, TorznabCatType.MoviesDVD);
            AddCategoryMapping(36, TorznabCatType.MoviesBluRay);
            AddCategoryMapping(27, TorznabCatType.MoviesHD);

            AddCategoryMapping(7, TorznabCatType.TVSD); // Israeli SDTV
            AddCategoryMapping(24, TorznabCatType.TVSD); // English SDTV
            AddCategoryMapping(1, TorznabCatType.TVHD); // Israel HDTV
            AddCategoryMapping(37, TorznabCatType.TVHD); // Israel HDTV
        }
Пример #10
0
        public myAmity(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
            : base(name: "myAmity",
                   description: "A German general tracker.",
                   link: "https://ttv2.myamity.info/",
                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                   manager: i,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.GetEncoding("UTF-8");
            Language = "de-de";

            AddCategoryMapping(20, TorznabCatType.PC); // Apps - PC
            AddCategoryMapping(24, TorznabCatType.AudioAudiobook); // Audio - Hoerbuch/-spiel
            AddCategoryMapping(22, TorznabCatType.Audio); // Audio - Musik
            AddCategoryMapping(52, TorznabCatType.Movies3D); // Filme - 3D
            AddCategoryMapping(51, TorznabCatType.MoviesBluRay); // Filme - BluRay Complete
            AddCategoryMapping(1,  TorznabCatType.MoviesDVD); // Filme - DVD
            AddCategoryMapping(54, TorznabCatType.MoviesHD); // Filme - HD/1080p
            AddCategoryMapping(3,  TorznabCatType.MoviesHD); // Filme - HD/720p
            AddCategoryMapping(48, TorznabCatType.XXX); // Filme - Heimatfilme.XXX
            AddCategoryMapping(50, TorznabCatType.Movies); // Filme - x264/H.264
            AddCategoryMapping(2,  TorznabCatType.MoviesSD); // Filme - XViD
            AddCategoryMapping(11, TorznabCatType.Console); // Games - Konsolen
            AddCategoryMapping(10, TorznabCatType.PCGames); // Games - PC
            AddCategoryMapping(53, TorznabCatType.Other); // International - Complete
            AddCategoryMapping(36, TorznabCatType.Books); // Sonstige - E-Books
            AddCategoryMapping(38, TorznabCatType.Other); // Sonstige - Handy
            AddCategoryMapping(7,  TorznabCatType.TVDocumentary); // TV/HDTV - Dokus
            AddCategoryMapping(8,  TorznabCatType.TV); // TV/HDTV - Serien
        }
Пример #11
0
 public FileList(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
     : base(name: "FileList",
         description: "The best Romanian site.",
         link: "http://filelist.ro/",
         caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
         manager: i,
         client: wc,
         logger: l,
         p: ps,
         configData: new ConfigurationDataFileList())
 {
     AddCategoryMapping(24, TorznabCatType.TVAnime);
     AddCategoryMapping(11, TorznabCatType.Audio);
     AddCategoryMapping(15, TorznabCatType.TV);
     //AddCategoryMapping(18, TorznabCatType.); Other
     AddCategoryMapping(16, TorznabCatType.TVDocumentary);
     AddCategoryMapping(25, TorznabCatType.Movies3D);
     AddCategoryMapping(20, TorznabCatType.MoviesBluRay);
     AddCategoryMapping(2, TorznabCatType.MoviesSD);
     AddCategoryMapping(3, TorznabCatType.MoviesForeign); //RO
     AddCategoryMapping(4, TorznabCatType.MoviesHD);
     AddCategoryMapping(19, TorznabCatType.MoviesForeign); // RO
     AddCategoryMapping(1, TorznabCatType.MoviesSD);
     AddCategoryMapping(10, TorznabCatType.Console);
     AddCategoryMapping(9, TorznabCatType.PCGames);
     //AddCategoryMapping(17, TorznabCatType); Linux No cat
     AddCategoryMapping(22, TorznabCatType.PCPhoneOther); //Apps/mobile
     AddCategoryMapping(8, TorznabCatType.PC);
     AddCategoryMapping(21, TorznabCatType.TVHD);
     AddCategoryMapping(23, TorznabCatType.TVSD);
     AddCategoryMapping(13, TorznabCatType.TVSport);
     AddCategoryMapping(14, TorznabCatType.TV);
     AddCategoryMapping(12, TorznabCatType.AudioVideo);
     AddCategoryMapping(7, TorznabCatType.XXX);
 }
Пример #12
0
        public BeyondHD(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "BeyondHD",
                description: "Without BeyondHD, your HDTV is just a TV",
                link: "https://beyondhd.me/",
                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataCookie())
        {
            AddCategoryMapping("40,44,48,89,46,45", TorznabCatType.TV);
            AddCategoryMapping("40", TorznabCatType.TVHD);
            AddCategoryMapping("44", TorznabCatType.TVHD);
            AddCategoryMapping("48", TorznabCatType.TVHD);
            AddCategoryMapping("46", TorznabCatType.TVHD);
            AddCategoryMapping("45", TorznabCatType.TVHD);
            AddCategoryMapping("44", TorznabCatType.TVSD);
            AddCategoryMapping("46", TorznabCatType.TVSD);
            AddCategoryMapping("45", TorznabCatType.TVSD);

            AddCategoryMapping("41,77,71,94,78,37,54,17", TorznabCatType.Movies);
            AddCategoryMapping("77", TorznabCatType.MoviesHD);
            AddCategoryMapping("71", TorznabCatType.Movies3D);
            AddCategoryMapping("78", TorznabCatType.MoviesHD);
            AddCategoryMapping("37", TorznabCatType.MoviesBluRay);
            AddCategoryMapping("54", TorznabCatType.MoviesHD);

            AddCategoryMapping("55,56,42,36,69", TorznabCatType.Audio);
            AddCategoryMapping("36", TorznabCatType.AudioLossless);
            AddCategoryMapping("69", TorznabCatType.AudioMP3);
        }
Пример #13
0
 // minimal constructor used by e.g. cardigann generic indexer
 public BaseIndexer(IIndexerManagerService manager, IWebClient client, Logger logger, IProtectionService p)
 {
     this.logger = logger;
     indexerService = manager;
     webclient = client;
     protectionService = p;
 }
Пример #14
0
        public PirateTheNet(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "PirateTheNet",
                description: "A movie tracker",
                link: "http://piratethe.net/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.GetEncoding("UTF-8");
            Language = "en-us";

            this.configData.DisplayText.Value = "Only the results from the first search result page are shown, adjust your profile settings to show the maximum.";
            this.configData.DisplayText.Name = "Notice";

            AddCategoryMapping("1080P", TorznabCatType.MoviesHD);
            AddCategoryMapping("720P", TorznabCatType.MoviesHD);
            AddCategoryMapping("BDRip", TorznabCatType.MoviesSD);
            AddCategoryMapping("BluRay", TorznabCatType.MoviesBluRay);
            AddCategoryMapping("BRRip", TorznabCatType.MoviesSD);
            AddCategoryMapping("DVDR", TorznabCatType.MoviesDVD);
            AddCategoryMapping("DVDRip", TorznabCatType.MoviesSD);
            AddCategoryMapping("FLAC", TorznabCatType.AudioLossless);
            AddCategoryMapping("MP3", TorznabCatType.AudioMP3);
            AddCategoryMapping("MP4", TorznabCatType.AudioOther);
            AddCategoryMapping("Packs", TorznabCatType.Movies);
            AddCategoryMapping("R5", TorznabCatType.MoviesDVD);
            AddCategoryMapping("Remux", TorznabCatType.Movies);
            AddCategoryMapping("TVRip", TorznabCatType.MoviesOther);
            AddCategoryMapping("WebRip", TorznabCatType.MoviesWEBDL);
        }
Пример #15
0
        public FunFile(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "FunFile",
                description: "A general tracker",
                link: "https://www.funfile.org/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.GetEncoding("iso-8859-1");
            Language = "en-us";

            AddCategoryMapping(44, TorznabCatType.TVAnime); // Anime
            AddCategoryMapping(22, TorznabCatType.PC); // Applications
            AddCategoryMapping(43, TorznabCatType.AudioAudiobook); // Audio Books
            AddCategoryMapping(27, TorznabCatType.Books); // Ebook
            AddCategoryMapping(4,  TorznabCatType.PCGames); // Games
            AddCategoryMapping(40, TorznabCatType.OtherMisc); // Miscellaneous
            AddCategoryMapping(19, TorznabCatType.Movies); // Movies
            AddCategoryMapping(6,  TorznabCatType.Audio); // Music
            AddCategoryMapping(31, TorznabCatType.PCPhoneOther); // Portable
            AddCategoryMapping(7,  TorznabCatType.TV); // TV
        }
Пример #16
0
        public BB(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "bB",
                description: "bB",
                link: "http://www.reddit.com/r/baconbits/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataBasicLogin())
        {
            Encoding = Encoding.GetEncoding("UTF-8");
            Language = "en-us";

            AddCategoryMapping(1, TorznabCatType.Audio);
            AddCategoryMapping(2, TorznabCatType.PC);
            AddCategoryMapping(3, TorznabCatType.BooksEbook);
            AddCategoryMapping(4, TorznabCatType.AudioAudiobook);
            AddCategoryMapping(7, TorznabCatType.BooksComics);
            AddCategoryMapping(8, TorznabCatType.TVAnime);
            AddCategoryMapping(9, TorznabCatType.Movies);
            AddCategoryMapping(10, TorznabCatType.TVHD);
            AddCategoryMapping(10, TorznabCatType.TVSD);
            AddCategoryMapping(10, TorznabCatType.TV);
            AddCategoryMapping(11, TorznabCatType.PCGames);
        }
Пример #17
0
        public GFTracker(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "GFTracker",
                description: "Home of user happiness",
                link: "https://www.thegft.org/",
                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataRecaptchaLogin())
        {
            Encoding = Encoding.UTF8;
            Language = "en-us";

            AddCategoryMapping(4, TorznabCatType.TV);               // TV/XVID
            AddCategoryMapping(17, TorznabCatType.TVHD);            // TV/X264
            AddCategoryMapping(19, TorznabCatType.TV);              // TV/DVDRIP
            AddCategoryMapping(26, TorznabCatType.TVHD);            // TV/BLURAY
            AddCategoryMapping(37, TorznabCatType.TV);              // TV/DVDR
            AddCategoryMapping(47, TorznabCatType.TV);              // TV/SD

            AddCategoryMapping(7, TorznabCatType.Movies);           // Movies/XVID
            AddCategoryMapping(8, TorznabCatType.MoviesDVD);        // Movies/DVDR
            AddCategoryMapping(12, TorznabCatType.MoviesBluRay);    // Movies/BLURAY
            AddCategoryMapping(18, TorznabCatType.MoviesHD);        // Movies/X264-HD
            AddCategoryMapping(49, TorznabCatType.MoviesSD);        // Movies/X264-SD
        }
Пример #18
0
        public SceneAccess(IIndexerManagerService i, IWebClient c, Logger l, IProtectionService ps)
            : base(name: "SceneAccess",
                description: "Your gateway to the scene",
                link: "https://sceneaccess.eu/",
                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                manager: i,
                client: c,
                logger: l,
                p: ps,
                configData: new ConfigurationDataBasicLogin())
        {

            AddCategoryMapping(8, TorznabCatType.MoviesSD);
            AddCategoryMapping(22, TorznabCatType.MoviesHD);
            AddCategoryMapping(7, TorznabCatType.MoviesSD);
            AddCategoryMapping(4, TorznabCatType.Movies);

            AddCategoryMapping(27, TorznabCatType.TVHD);
            AddCategoryMapping(17, TorznabCatType.TVSD);
            AddCategoryMapping(11, TorznabCatType.MoviesSD);
            AddCategoryMapping(26, TorznabCatType.TV);

            AddCategoryMapping(3, TorznabCatType.PCGames);
            AddCategoryMapping(5, TorznabCatType.ConsolePS3);
            AddCategoryMapping(20, TorznabCatType.ConsolePSP);
            AddCategoryMapping(28, TorznabCatType.TV);
            AddCategoryMapping(23, TorznabCatType.Console);
            AddCategoryMapping(29, TorznabCatType.Console);

            AddCategoryMapping(40, TorznabCatType.AudioLossless);
            AddCategoryMapping(13, TorznabCatType.AudioMP3);
            AddCategoryMapping(15, TorznabCatType.AudioVideo);

            AddCategoryMapping(1, TorznabCatType.PCISO);
            AddCategoryMapping(2, TorznabCatType.PCISO);
            AddCategoryMapping(14, TorznabCatType.PCISO);
            AddCategoryMapping(21, TorznabCatType.Other);

            AddCategoryMapping(41, TorznabCatType.MoviesHD);
            AddCategoryMapping(42, TorznabCatType.MoviesSD);
            AddCategoryMapping(43, TorznabCatType.MoviesSD);
            AddCategoryMapping(44, TorznabCatType.TVHD);
            AddCategoryMapping(45, TorznabCatType.TVSD);

            AddCategoryMapping(12, TorznabCatType.XXXXviD);
            AddCategoryMapping(35, TorznabCatType.XXXx264);
            AddCategoryMapping(36, TorznabCatType.XXX);

            AddCategoryMapping(30, TorznabCatType.MoviesForeign);
            AddCategoryMapping(31, TorznabCatType.MoviesForeign);
            AddCategoryMapping(32, TorznabCatType.MoviesForeign);
            AddCategoryMapping(33, TorznabCatType.TVFOREIGN);
            AddCategoryMapping(34, TorznabCatType.TVFOREIGN);

            AddCategoryMapping(4, TorznabCatType.Movies);
            AddCategoryMapping(37, TorznabCatType.XXX);
            AddCategoryMapping(38, TorznabCatType.Audio);

        }
Пример #19
0
        public DigitalHive(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "DigitalHive",
                description: "DigitalHive is one of the oldest general trackers",
                link: "https://www.digitalhive.org/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataRecaptchaLogin())
        {
            Encoding = Encoding.GetEncoding("iso-8859-1");
            Language = "en-us";

            AddCategoryMapping(0, TorznabCatType.Other);
            AddCategoryMapping(48, TorznabCatType.Other); // 0Day
            AddCategoryMapping(56, TorznabCatType.XXXImageset); // 0Day-Imagesets
            AddCategoryMapping(6, TorznabCatType.Audio); // 0Day-Music
            AddCategoryMapping(51, TorznabCatType.XXX); // 0Day-XXX
            AddCategoryMapping(2, TorznabCatType.TVAnime); // Anime
            AddCategoryMapping(59, TorznabCatType.MoviesBluRay); // BluRay
            AddCategoryMapping(40, TorznabCatType.TVDocumentary); // Documentary
            AddCategoryMapping(20, TorznabCatType.MoviesDVD); // DVD-R
            AddCategoryMapping(25, TorznabCatType.BooksEbook); // Ebooks
            AddCategoryMapping(38, TorznabCatType.PCPhoneIOS); // HandHeld
            AddCategoryMapping(38, TorznabCatType.PCPhoneAndroid); // HandHeld
            AddCategoryMapping(38, TorznabCatType.PCPhoneOther); // HandHeld
            AddCategoryMapping(37, TorznabCatType.Other); // Kids Stuff
            AddCategoryMapping(23, TorznabCatType.PC); // Linux
            AddCategoryMapping(24, TorznabCatType.PCMac); // Mac
            AddCategoryMapping(22, TorznabCatType.OtherMisc); // Misc
            AddCategoryMapping(35, TorznabCatType.MoviesOther); // Movie Pack
            AddCategoryMapping(36, TorznabCatType.MoviesHD); // Movie-HD
            AddCategoryMapping(19, TorznabCatType.MoviesSD); // Movie-SD
            AddCategoryMapping(50, TorznabCatType.Audio); // Music
            AddCategoryMapping(53, TorznabCatType.AudioLossless); // Music-FLAC
            AddCategoryMapping(49, TorznabCatType.AudioVideo); // MVID
            AddCategoryMapping(1, TorznabCatType.PC); // PC Apps
            AddCategoryMapping(4, TorznabCatType.PCGames); // PC Games
            AddCategoryMapping(17, TorznabCatType.ConsolePS3); // Playstation
            AddCategoryMapping(17, TorznabCatType.ConsolePS4); // Playstation
            AddCategoryMapping(17, TorznabCatType.ConsolePSVita); // Playstation
            AddCategoryMapping(17, TorznabCatType.ConsolePSP); // Playstation
            AddCategoryMapping(28, TorznabCatType.ConsolePSP); // PSP
            AddCategoryMapping(34, TorznabCatType.TVOTHER); // TV Pack
            AddCategoryMapping(32, TorznabCatType.TVHD); // TV-HD
            AddCategoryMapping(55, TorznabCatType.TVOTHER); // TV-HDRip
            AddCategoryMapping(7, TorznabCatType.TVSD); // TV-SD
            AddCategoryMapping(57, TorznabCatType.TVOTHER); // TV-SDRip
            AddCategoryMapping(33, TorznabCatType.ConsoleWii); // WII
            AddCategoryMapping(33, TorznabCatType.ConsoleWiiU); // WII
            AddCategoryMapping(45, TorznabCatType.ConsoleXbox); // XBox
            AddCategoryMapping(45, TorznabCatType.ConsoleXbox360); // XBox
            AddCategoryMapping(45, TorznabCatType.ConsoleXBOX360DLC); // XBox
            AddCategoryMapping(45, TorznabCatType.ConsoleXboxOne); // XBox
            AddCategoryMapping(9, TorznabCatType.XXX); // XXX
            AddCategoryMapping(52, TorznabCatType.XXXOther); // XXX-ISO
        }
Пример #20
0
        public IPTorrents(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
            : base(name: "IPTorrents",
                description: "Always a step ahead.",
                link: "https://iptorrents.com/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: wc,
                logger: l,
                p: ps,
                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);
            AddCategoryMapping(90, TorznabCatType.MoviesSD);
            AddCategoryMapping(96, TorznabCatType.MoviesSD);
            AddCategoryMapping(6, TorznabCatType.MoviesSD);
            AddCategoryMapping(48, TorznabCatType.MoviesHD);
            AddCategoryMapping(54, TorznabCatType.Movies);
            AddCategoryMapping(62, TorznabCatType.MoviesSD);
            AddCategoryMapping(38, TorznabCatType.MoviesForeign);
            AddCategoryMapping(68, TorznabCatType.Movies);
            AddCategoryMapping(20, TorznabCatType.MoviesHD);
            AddCategoryMapping(7, TorznabCatType.MoviesSD);

            AddCategoryMapping(73, TorznabCatType.TV);
            AddCategoryMapping(26, TorznabCatType.TVSD);
            AddCategoryMapping(55, TorznabCatType.TVSD);
            AddCategoryMapping(78, TorznabCatType.TVSD);
            AddCategoryMapping(23, TorznabCatType.TVHD);
            AddCategoryMapping(24, TorznabCatType.TVSD);
            AddCategoryMapping(25, TorznabCatType.TVSD);
            AddCategoryMapping(66, TorznabCatType.TVSD);
            AddCategoryMapping(82, TorznabCatType.TVSD);
            AddCategoryMapping(65, TorznabCatType.TV);
            AddCategoryMapping(83, TorznabCatType.TV);
            AddCategoryMapping(79, TorznabCatType.TVSD);
            AddCategoryMapping(22, TorznabCatType.TVHD);
            AddCategoryMapping(79, TorznabCatType.TVSD);
            AddCategoryMapping(4, TorznabCatType.TVSD);
            AddCategoryMapping(5, TorznabCatType.TVHD);

            AddCategoryMapping(75, TorznabCatType.Audio);
            AddCategoryMapping(73, TorznabCatType.Audio);
            AddCategoryMapping(80, TorznabCatType.AudioLossless);
            AddCategoryMapping(93, TorznabCatType.Audio);

            AddCategoryMapping(60, TorznabCatType.TVAnime);
            AddCategoryMapping(1, TorznabCatType.PC);
            AddCategoryMapping(64, TorznabCatType.AudioAudiobook);
            AddCategoryMapping(35, TorznabCatType.Books);
            AddCategoryMapping(94, TorznabCatType.BooksComics);
        }
Пример #21
0
        public TorrentDay(IIndexerManagerService i, Logger l, IWebClient wc, IProtectionService ps)
            : base(name: "TorrentDay",
                description: "TorrentDay",
                link: "https://tdonline.org/",
                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                manager: i,
                client: wc,
                logger: l,
                p: ps,
                configData: new ConfigurationDataRecaptchaLogin())
        {

            AddCategoryMapping(29, TorznabCatType.TVAnime);
            AddCategoryMapping(28, TorznabCatType.PC);
            AddCategoryMapping(28, TorznabCatType.AudioAudiobook);
            AddCategoryMapping(20, TorznabCatType.Books);
            AddCategoryMapping(30, TorznabCatType.TVDocumentary);
            //Freelech
            //Mac

            AddCategoryMapping(25, TorznabCatType.MoviesSD);
            AddCategoryMapping(11, TorznabCatType.MoviesHD);
            AddCategoryMapping(5, TorznabCatType.MoviesHD);
            AddCategoryMapping(3, TorznabCatType.MoviesSD);
            AddCategoryMapping(21, TorznabCatType.MoviesSD);
            AddCategoryMapping(22, TorznabCatType.MoviesForeign);
            // Movie packs
            AddCategoryMapping(44, TorznabCatType.MoviesSD);
            AddCategoryMapping(1, TorznabCatType.MoviesSD);

            // Music
            AddCategoryMapping(17, TorznabCatType.AudioMP3);
            AddCategoryMapping(44, TorznabCatType.AudioLossless);
            AddCategoryMapping(23, TorznabCatType.AudioForeign);
            AddCategoryMapping(41, TorznabCatType.AudioOther);
            AddCategoryMapping(16, TorznabCatType.AudioVideo);

            AddCategoryMapping(4, TorznabCatType.PCGames);
            // ps3
            // psp
            // wii
            // 360

            AddCategoryMapping(24, TorznabCatType.TVSD);
            AddCategoryMapping(32, TorznabCatType.TVHD);
            AddCategoryMapping(31, TorznabCatType.TVSD);
            AddCategoryMapping(33, TorznabCatType.TVSD);
            AddCategoryMapping(14, TorznabCatType.TVHD);
            AddCategoryMapping(26, TorznabCatType.TVSD);
            AddCategoryMapping(7, TorznabCatType.TVHD);
            AddCategoryMapping(2, TorznabCatType.TVSD);

            AddCategoryMapping(6, TorznabCatType.XXX);
            AddCategoryMapping(15, TorznabCatType.XXX);
        }
Пример #22
0
        public TorrentNetwork(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
            : base(name: "Torrent Network",
                   description: "A German general tracker.",
                   link: "https://tntracker.org/",
                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                   manager: i,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.GetEncoding("UTF-8");
            Language = "de-de";

            AddCategoryMapping(1,  TorznabCatType.AudioAudiobook); // aBook
            AddCategoryMapping(4,  TorznabCatType.PCMac); // App|Mac
            AddCategoryMapping(5,  TorznabCatType.PC); // App|Win
            AddCategoryMapping(7,  TorznabCatType.TVDocumentary); // Docu|HD
            AddCategoryMapping(6,  TorznabCatType.TVDocumentary); // Docu|SD
            AddCategoryMapping(8,  TorznabCatType.Books); // eBook
            AddCategoryMapping(10, TorznabCatType.PCGames); // Game|PC
            AddCategoryMapping(13, TorznabCatType.ConsolePS4); // Game|PSX
            AddCategoryMapping(12, TorznabCatType.ConsoleWii); // Game|Wii
            AddCategoryMapping(14, TorznabCatType.ConsoleXbox); // Game|XBOX
            AddCategoryMapping(30, TorznabCatType.Other); // Misc
            AddCategoryMapping(17, TorznabCatType.MoviesHD); // Movie|DE|1080p
            AddCategoryMapping(20, TorznabCatType.MoviesHD); // Movie|DE|2160p
            AddCategoryMapping(36, TorznabCatType.Movies3D); // Movie|DE|3D
            AddCategoryMapping(18, TorznabCatType.MoviesHD); // Movie|DE|720p
            AddCategoryMapping(34, TorznabCatType.TVAnime); // Movie|DE|Anime
            AddCategoryMapping(19, TorznabCatType.MoviesBluRay); // Movie|DE|BluRay
            AddCategoryMapping(45, TorznabCatType.Movies); // Movie|DE|Remux
            AddCategoryMapping(24, TorznabCatType.MoviesSD); // Movie|DE|SD
            AddCategoryMapping(39, TorznabCatType.Movies); // Movie|EN/JP|Anime
            AddCategoryMapping(43, TorznabCatType.MoviesHD); // Movie|EN|1080p
            AddCategoryMapping(37, TorznabCatType.MoviesHD); // Movie|EN|2160p
            AddCategoryMapping(35, TorznabCatType.MoviesHD); // Movie|EN|720p
            AddCategoryMapping(38, TorznabCatType.MoviesBluRay); // Movie|EN|BluRay
            AddCategoryMapping(46, TorznabCatType.Movies); // Movie|EN|Remux
            AddCategoryMapping(22, TorznabCatType.MoviesSD); // Movie|EN|SD
            AddCategoryMapping(44, TorznabCatType.AudioLossless); // Music|Flac
            AddCategoryMapping(25, TorznabCatType.AudioMP3); // Music|MP3
            AddCategoryMapping(26, TorznabCatType.AudioVideo); // Music|Video
            AddCategoryMapping(31, TorznabCatType.TVSport); // Sport
            AddCategoryMapping(2,  TorznabCatType.TVAnime); // TV|DE|Anime
            AddCategoryMapping(28, TorznabCatType.TVHD); // TV|DE|HD
            AddCategoryMapping(16, TorznabCatType.TV); // TV|DE|Pack
            AddCategoryMapping(27, TorznabCatType.TVSD); // TV|DE|SD
            AddCategoryMapping(41, TorznabCatType.TVAnime); // TV|EN/JP|Anime
            AddCategoryMapping(40, TorznabCatType.TVHD); // TV|EN|HD
            AddCategoryMapping(42, TorznabCatType.TV); // TV|EN|Pack
            AddCategoryMapping(29, TorznabCatType.TVSD); // TV|EN|SD
            AddCategoryMapping(33, TorznabCatType.XXX); // XXX|HD
            AddCategoryMapping(32, TorznabCatType.XXX); // XXX|SD
        }
Пример #23
0
        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);
        }
Пример #24
0
 public Avistaz(IIndexerManagerService indexerManager, IWebClient webClient, Logger logger, IProtectionService protectionService)
     : base(name: "Avistaz",
         desc: "Aka AsiaTorrents",
         link: "https://avistaz.to/",
         indexerManager: indexerManager,
         logger: logger,
         protectionService: protectionService,
         webClient: webClient
         )
 {
 }
Пример #25
0
 public EuTorrents(IIndexerManagerService indexerManager, IWebClient webClient, Logger logger, IProtectionService protectionService)
     : base(name: "EuTorrents",
         desc: "Part of the Avistaz network.",
         link: "https://eutorrents.to/",
         indexerManager: indexerManager,
         logger: logger,
         protectionService: protectionService,
         webClient: webClient
         )
 {
 }
Пример #26
0
 public CinemaZ(IIndexerManagerService indexerManager, IWebClient webClient, Logger logger, IProtectionService protectionService)
     : base(name: "CinemaZ",
         desc: "Part of the Avistaz network.",
         link: "https://cinemaz.to/",
         indexerManager: indexerManager,
         logger: logger,
         protectionService: protectionService,
         webClient: webClient
         )
 {
 }
Пример #27
0
        public NxtGn(IIndexerManagerService i, Logger l, IWebClient c, IProtectionService ps)
            : base(name: "NextGen",
                description: "A danish closed torrent tracker",
                link: "https://nxtgn.info/",
                caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                manager: i,
                client: c,
                logger: l,
                p: ps,
                configData: new ConfigurationDataBasicLoginWithRSS())
        {
			//Movies Mapping
			AddCategoryMapping(9, TorznabCatType.MoviesHD);
			AddCategoryMapping(9, TorznabCatType.Movies);
			AddCategoryMapping(9, TorznabCatType.MoviesBluRay);
			AddCategoryMapping(47, TorznabCatType.Movies3D);
			AddCategoryMapping(38, TorznabCatType.MoviesHD);
			AddCategoryMapping(38, TorznabCatType.MoviesWEBDL);
			AddCategoryMapping(38, TorznabCatType.MoviesBluRay);
			AddCategoryMapping(5, TorznabCatType.MoviesSD);
			AddCategoryMapping(23, TorznabCatType.MoviesForeign);
			AddCategoryMapping(22, TorznabCatType.MoviesSD);
			AddCategoryMapping(33, TorznabCatType.MoviesHD);
			AddCategoryMapping(33, TorznabCatType.Movies);
			AddCategoryMapping(17, TorznabCatType.MoviesForeign);
			AddCategoryMapping(17, TorznabCatType.MoviesDVD);

			//TV Mapping
			//Category 4: TV (Working)
			AddCategoryMapping(4, TorznabCatType.TVSD);
			AddCategoryMapping(4, TorznabCatType.TV);
			AddCategoryMapping(4, TorznabCatType.TVHD);
			//Category 21: Boxset/SD (Working)
			AddCategoryMapping(21, TorznabCatType.TVFOREIGN);
			//Category 24: Boxsets/TV (Working)
			AddCategoryMapping(24, TorznabCatType.TVFOREIGN);
			//Category 26: NG Serier WEB-DL (Working)
			AddCategoryMapping(26, TorznabCatType.TVHD);
			AddCategoryMapping(26, TorznabCatType.TV);
			AddCategoryMapping(26, TorznabCatType.TVWEBDL);
			//Category 31: TVHD (Working)
			AddCategoryMapping(31, TorznabCatType.TVHD);
			AddCategoryMapping(31, TorznabCatType.TV);
			//Category 43: NG WWW HD (Working)
			AddCategoryMapping(43, TorznabCatType.TVHD);
			AddCategoryMapping(43, TorznabCatType.TV);
			AddCategoryMapping(43, TorznabCatType.TVWEBDL);
			//Category 45: TV-Misc (Working)
			AddCategoryMapping(45, TorznabCatType.TV);
			AddCategoryMapping(45, TorznabCatType.TVSD);
			//Category 46: NG Serier HDTV (Working)
			AddCategoryMapping(46, TorznabCatType.TVHD);
			AddCategoryMapping(46, TorznabCatType.TV);
        }
Пример #28
0
        public SceneTime(IIndexerManagerService i, Logger l, IWebClient w, IProtectionService ps)
            : base(name: "SceneTime",
                description: "Always on time",
                link: "https://www.scenetime.com/",
                caps: new TorznabCapabilities(),
                manager: i,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataRecaptchaLogin("For best results, change the 'Torrents per page' setting to the maximum in your profile on the SceneTime webpage."))
        {
            Encoding = Encoding.GetEncoding("iso-8859-1");
            Language = "en-us";

            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);
        }
Пример #29
0
 public PrivateHD(IIndexerManagerService indexerManager, IWebClient webClient, Logger logger, IProtectionService protectionService)
     : base(name: "PrivateHD",
         desc: "BitTorrent site for High Quality, High Definition (HD) movies and TV Shows",
         link: "https://privatehd.to/",
         indexerManager: indexerManager,
         logger: logger,
         protectionService: protectionService,
         webClient: webClient
         )
 {
 }
Пример #30
0
 public HDSpace(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
     : base(name: "HD-Space",
         description: "Sharing The Universe",
         link: "https://hd-space.org/",
         caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
         manager: i,
         client: wc,
         logger: l,
         p: ps,
         configData: new ConfigurationDataBasicLogin())
 {
 }
Пример #31
0
        public MyAnonamouse(IIndexerConfigurationService configService, WebClient c, Logger l, IProtectionService ps)
            : base(id: "myanonamouse",
                   name: "MyAnonamouse",
                   description: "Friendliness, Warmth and Sharing",
                   link: "https://www.myanonamouse.net/",
                   configService: configService,
                   caps: new TorznabCapabilities
        {
            BookSearchParams = new List <BookSearchParam>
            {
                BookSearchParam.Q
            }
        },
                   client: c,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataMyAnonamouse())
        {
            Encoding = Encoding.UTF8;
            Language = "en-us";
            Type     = "private";
            webclient.EmulateBrowser = false;

            AddCategoryMapping("13", TorznabCatType.AudioAudiobook, "AudioBooks");
            AddCategoryMapping("14", TorznabCatType.BooksEBook, "E-Books");
            AddCategoryMapping("15", TorznabCatType.AudioAudiobook, "Musicology");
            AddCategoryMapping("16", TorznabCatType.AudioAudiobook, "Radio");
            AddCategoryMapping("39", TorznabCatType.AudioAudiobook, "Audiobooks - Action/Adventure");
            AddCategoryMapping("49", TorznabCatType.AudioAudiobook, "Audiobooks - Art");
            AddCategoryMapping("50", TorznabCatType.AudioAudiobook, "Audiobooks - Biographical");
            AddCategoryMapping("83", TorznabCatType.AudioAudiobook, "Audiobooks - Business");
            AddCategoryMapping("51", TorznabCatType.AudioAudiobook, "Audiobooks - Computer/Internet");
            AddCategoryMapping("97", TorznabCatType.AudioAudiobook, "Audiobooks - Crafts");
            AddCategoryMapping("40", TorznabCatType.AudioAudiobook, "Audiobooks - Crime/Thriller");
            AddCategoryMapping("41", TorznabCatType.AudioAudiobook, "Audiobooks - Fantasy");
            AddCategoryMapping("106", TorznabCatType.AudioAudiobook, "Audiobooks - Food");
            AddCategoryMapping("42", TorznabCatType.AudioAudiobook, "Audiobooks - General Fiction");
            AddCategoryMapping("52", TorznabCatType.AudioAudiobook, "Audiobooks - General Non-Fic");
            AddCategoryMapping("98", TorznabCatType.AudioAudiobook, "Audiobooks - Historical Fiction");
            AddCategoryMapping("54", TorznabCatType.AudioAudiobook, "Audiobooks - History");
            AddCategoryMapping("55", TorznabCatType.AudioAudiobook, "Audiobooks - Home/Garden");
            AddCategoryMapping("43", TorznabCatType.AudioAudiobook, "Audiobooks - Horror");
            AddCategoryMapping("99", TorznabCatType.AudioAudiobook, "Audiobooks - Humor");
            AddCategoryMapping("84", TorznabCatType.AudioAudiobook, "Audiobooks - Instructional");
            AddCategoryMapping("44", TorznabCatType.AudioAudiobook, "Audiobooks - Juvenile");
            AddCategoryMapping("56", TorznabCatType.AudioAudiobook, "Audiobooks - Language");
            AddCategoryMapping("45", TorznabCatType.AudioAudiobook, "Audiobooks - Literary Classics");
            AddCategoryMapping("57", TorznabCatType.AudioAudiobook, "Audiobooks - Math/Science/Tech");
            AddCategoryMapping("85", TorznabCatType.AudioAudiobook, "Audiobooks - Medical");
            AddCategoryMapping("87", TorznabCatType.AudioAudiobook, "Audiobooks - Mystery");
            AddCategoryMapping("119", TorznabCatType.AudioAudiobook, "Audiobooks - Nature");
            AddCategoryMapping("88", TorznabCatType.AudioAudiobook, "Audiobooks - Philosophy");
            AddCategoryMapping("58", TorznabCatType.AudioAudiobook, "Audiobooks - Pol/Soc/Relig");
            AddCategoryMapping("59", TorznabCatType.AudioAudiobook, "Audiobooks - Recreation");
            AddCategoryMapping("46", TorznabCatType.AudioAudiobook, "Audiobooks - Romance");
            AddCategoryMapping("47", TorznabCatType.AudioAudiobook, "Audiobooks - Science Fiction");
            AddCategoryMapping("53", TorznabCatType.AudioAudiobook, "Audiobooks - Self-Help");
            AddCategoryMapping("89", TorznabCatType.AudioAudiobook, "Audiobooks - Travel/Adventure");
            AddCategoryMapping("100", TorznabCatType.AudioAudiobook, "Audiobooks - True Crime");
            AddCategoryMapping("108", TorznabCatType.AudioAudiobook, "Audiobooks - Urban Fantasy");
            AddCategoryMapping("48", TorznabCatType.AudioAudiobook, "Audiobooks - Western");
            AddCategoryMapping("111", TorznabCatType.AudioAudiobook, "Audiobooks - Young Adult");
            AddCategoryMapping("60", TorznabCatType.BooksEBook, "Ebooks - Action/Adventure");
            AddCategoryMapping("71", TorznabCatType.BooksEBook, "Ebooks - Art");
            AddCategoryMapping("72", TorznabCatType.BooksEBook, "Ebooks - Biographical");
            AddCategoryMapping("90", TorznabCatType.BooksEBook, "Ebooks - Business");
            AddCategoryMapping("61", TorznabCatType.BooksComics, "Ebooks - Comics/Graphic novels");
            AddCategoryMapping("73", TorznabCatType.BooksEBook, "Ebooks - Computer/Internet");
            AddCategoryMapping("101", TorznabCatType.BooksEBook, "Ebooks - Crafts");
            AddCategoryMapping("62", TorznabCatType.BooksEBook, "Ebooks - Crime/Thriller");
            AddCategoryMapping("63", TorznabCatType.BooksEBook, "Ebooks - Fantasy");
            AddCategoryMapping("107", TorznabCatType.BooksEBook, "Ebooks - Food");
            AddCategoryMapping("64", TorznabCatType.BooksEBook, "Ebooks - General Fiction");
            AddCategoryMapping("74", TorznabCatType.BooksEBook, "Ebooks - General Non-Fiction");
            AddCategoryMapping("102", TorznabCatType.BooksEBook, "Ebooks - Historical Fiction");
            AddCategoryMapping("76", TorznabCatType.BooksEBook, "Ebooks - History");
            AddCategoryMapping("77", TorznabCatType.BooksEBook, "Ebooks - Home/Garden");
            AddCategoryMapping("65", TorznabCatType.BooksEBook, "Ebooks - Horror");
            AddCategoryMapping("103", TorznabCatType.BooksEBook, "Ebooks - Humor");
            AddCategoryMapping("115", TorznabCatType.BooksEBook, "Ebooks - Illusion/Magic");
            AddCategoryMapping("91", TorznabCatType.BooksEBook, "Ebooks - Instructional");
            AddCategoryMapping("66", TorznabCatType.BooksEBook, "Ebooks - Juvenile");
            AddCategoryMapping("78", TorznabCatType.BooksEBook, "Ebooks - Language");
            AddCategoryMapping("67", TorznabCatType.BooksEBook, "Ebooks - Literary Classics");
            AddCategoryMapping("79", TorznabCatType.BooksMags, "Ebooks - Magazines/Newspapers");
            AddCategoryMapping("80", TorznabCatType.BooksTechnical, "Ebooks - Math/Science/Tech");
            AddCategoryMapping("92", TorznabCatType.BooksEBook, "Ebooks - Medical");
            AddCategoryMapping("118", TorznabCatType.BooksEBook, "Ebooks - Mixed Collections");
            AddCategoryMapping("94", TorznabCatType.BooksEBook, "Ebooks - Mystery");
            AddCategoryMapping("120", TorznabCatType.BooksEBook, "Ebooks - Nature");
            AddCategoryMapping("95", TorznabCatType.BooksEBook, "Ebooks - Philosophy");
            AddCategoryMapping("81", TorznabCatType.BooksEBook, "Ebooks - Pol/Soc/Relig");
            AddCategoryMapping("82", TorznabCatType.BooksEBook, "Ebooks - Recreation");
            AddCategoryMapping("68", TorznabCatType.BooksEBook, "Ebooks - Romance");
            AddCategoryMapping("69", TorznabCatType.BooksEBook, "Ebooks - Science Fiction");
            AddCategoryMapping("75", TorznabCatType.BooksEBook, "Ebooks - Self-Help");
            AddCategoryMapping("96", TorznabCatType.BooksEBook, "Ebooks - Travel/Adventure");
            AddCategoryMapping("104", TorznabCatType.BooksEBook, "Ebooks - True Crime");
            AddCategoryMapping("109", TorznabCatType.BooksEBook, "Ebooks - Urban Fantasy");
            AddCategoryMapping("70", TorznabCatType.BooksEBook, "Ebooks - Western");
            AddCategoryMapping("112", TorznabCatType.BooksEBook, "Ebooks - Young Adult");
            AddCategoryMapping("19", TorznabCatType.AudioAudiobook, "Guitar/Bass Tabs");
            AddCategoryMapping("20", TorznabCatType.AudioAudiobook, "Individual Sheet");
            AddCategoryMapping("24", TorznabCatType.AudioAudiobook, "Individual Sheet MP3");
            AddCategoryMapping("126", TorznabCatType.AudioAudiobook, "Instructional Book with Video");
            AddCategoryMapping("22", TorznabCatType.AudioAudiobook, "Instructional Media - Music");
            AddCategoryMapping("113", TorznabCatType.AudioAudiobook, "Lick Library - LTP/Jam With");
            AddCategoryMapping("114", TorznabCatType.AudioAudiobook, "Lick Library - Techniques/QL");
            AddCategoryMapping("17", TorznabCatType.AudioAudiobook, "Music - Complete Editions");
            AddCategoryMapping("26", TorznabCatType.AudioAudiobook, "Music Book");
            AddCategoryMapping("27", TorznabCatType.AudioAudiobook, "Music Book MP3");
            AddCategoryMapping("30", TorznabCatType.AudioAudiobook, "Sheet Collection");
            AddCategoryMapping("31", TorznabCatType.AudioAudiobook, "Sheet Collection MP3");
            AddCategoryMapping("127", TorznabCatType.AudioAudiobook, "Radio -  Comedy");
            AddCategoryMapping("130", TorznabCatType.AudioAudiobook, "Radio - Drama");
            AddCategoryMapping("128", TorznabCatType.AudioAudiobook, "Radio - Factual/Documentary");
            AddCategoryMapping("132", TorznabCatType.AudioAudiobook, "Radio - Reading");
        }
Пример #32
0
        public BitCityReloaded(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
            : base(name: "Bit-City Reloaded",
                   description: "A German general tracker.",
                   link: "https://bc-reloaded.net/",
                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.GetEncoding("iso-8859-1");
            Language = "de-de";
            Type     = "private";

            this.configData.DisplayText.Value = "Only the results from the first search result page are shown, adjust your profile settings to show a reasonable amount (it looks like there's no maximum).";
            this.configData.DisplayText.Name  = "Notice";

            AddCategoryMapping(1, TorznabCatType.Other);           // Anderes
            AddCategoryMapping(2, TorznabCatType.TVAnime);         // Anime
            AddCategoryMapping(34, TorznabCatType.PC);             // Appz/Linux
            AddCategoryMapping(35, TorznabCatType.PCMac);          // Appz/Mac
            AddCategoryMapping(36, TorznabCatType.PC);             // Appz/Other
            AddCategoryMapping(20, TorznabCatType.PC);             // Appz/Win
            AddCategoryMapping(3, TorznabCatType.TVDocumentary);   // Doku/Alle Formate
            AddCategoryMapping(4, TorznabCatType.Books);           // EBooks
            AddCategoryMapping(12, TorznabCatType.ConsolePS4);     // Games PS / PSX
            AddCategoryMapping(11, TorznabCatType.ConsoleNDS);     // Games/Nintendo DS
            AddCategoryMapping(10, TorznabCatType.PCGames);        // Games/PC
            AddCategoryMapping(13, TorznabCatType.ConsoleWii);     // Games/Wii
            AddCategoryMapping(14, TorznabCatType.ConsoleXbox);    // Games/Xbox & 360
            AddCategoryMapping(15, TorznabCatType.PCPhoneOther);   // Handy & PDA
            AddCategoryMapping(16, TorznabCatType.AudioAudiobook); // Hörspiel/Hörbuch
            AddCategoryMapping(30, TorznabCatType.Other);          // International
            AddCategoryMapping(17, TorznabCatType.Other);          // MegaPack
            AddCategoryMapping(43, TorznabCatType.Movies3D);       // Movie/3D
            AddCategoryMapping(5, TorznabCatType.MoviesDVD);       // Movie/DVD/R
            AddCategoryMapping(6, TorznabCatType.MoviesHD);        // Movie/HD 1080p
            AddCategoryMapping(7, TorznabCatType.MoviesHD);        // Movie/HD 720p
            AddCategoryMapping(32, TorznabCatType.MoviesOther);    // Movie/TVRip
            AddCategoryMapping(9, TorznabCatType.MoviesOther);     // Movie/XviD,DivX,h264
            AddCategoryMapping(26, TorznabCatType.XXX);            // Movie/XXX
            AddCategoryMapping(41, TorznabCatType.XXXOther);       // Movie/XXX/Other
            AddCategoryMapping(42, TorznabCatType.XXXPacks);       // Movie/XXX/Pack
            AddCategoryMapping(45, TorznabCatType.MoviesHD);       // Movies/4K
            AddCategoryMapping(33, TorznabCatType.MoviesBluRay);   // Movies/BluRay
            AddCategoryMapping(18, TorznabCatType.Audio);          // Musik
            AddCategoryMapping(19, TorznabCatType.AudioVideo);     // Musik Videos
            AddCategoryMapping(44, TorznabCatType.TVOTHER);        // Serie/DVD/R
            AddCategoryMapping(22, TorznabCatType.TVHD);           // Serie/HDTV
            AddCategoryMapping(38, TorznabCatType.TV);             // Serie/Pack
            AddCategoryMapping(23, TorznabCatType.TVOTHER);        // Serie/XviD,DivX,h264
            AddCategoryMapping(25, TorznabCatType.TVSport);        // Sport
        }
Пример #33
0
        public Orpheus(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
            : base(id: "orpheus",
                   name: "Orpheus",
                   description: "A music tracker",
                   link: "https://orpheus.network/",
                   caps: new TorznabCapabilities
        {
            // TODO: add book search
            TvSearchParams = new List <TvSearchParam>
            {
                TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep
            },
            MovieSearchParams = new List <MovieSearchParam>
            {
                MovieSearchParam.Q
            },
            SupportedMusicSearchParamsList = new List <string>
            {
                "q", "album", "artist", "label", "year"
            }
        },
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   supportsFreeleechTokens: true,
                   has2Fa: true)
        {
            Language = "en-us";
            Type     = "private";

            AddCategoryMapping(1, TorznabCatType.Audio, "Music");
            AddCategoryMapping(2, TorznabCatType.PC, "Applications");
            AddCategoryMapping(3, TorznabCatType.Books, "E-Books");
            AddCategoryMapping(4, TorznabCatType.AudioAudiobook, "Audiobooks");
            AddCategoryMapping(5, TorznabCatType.Movies, "E-Learning Videos");
            AddCategoryMapping(6, TorznabCatType.TV, "Comedy");
            AddCategoryMapping(7, TorznabCatType.Books, "Comics");
        }
Пример #34
0
        public RarBG(IIndexerConfigurationService configService, Utils.Clients.WebClient wc, Logger l,
                     IProtectionService ps, ICacheService cs)
            : base(id: "rarbg",
                   name: "RARBG",
                   description: "RARBG is a Public torrent site for MOVIES / TV / GENERAL",
                   link: "https://rarbg.to/",
                   caps: new TorznabCapabilities
        {
            TvSearchParams = new List <TvSearchParam>
            {
                TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep
            },
            MovieSearchParams = new List <MovieSearchParam>
            {
                MovieSearchParam.Q, MovieSearchParam.ImdbId
            },
            MusicSearchParams = new List <MusicSearchParam>
            {
                MusicSearchParam.Q
            },
            BookSearchParams = new List <BookSearchParam>
            {
                BookSearchParam.Q
            }
        },
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   cacheService: cs,
                   configData: new ConfigurationData())
        {
            Encoding = Encoding.GetEncoding("windows-1252");
            Language = "en-us";
            Type     = "public";

            webclient.requestDelay = 2.5; // The api has a 1req/2s limit

            var sort = new SelectItem(new Dictionary <string, string>
            {
                { "last", "created" },
                { "seeders", "seeders" },
                { "leechers", "leechers" }
            })
            {
                Name = "Sort requested from site", Value = "last"
            };

            configData.AddDynamic("sort", sort);

            AddCategoryMapping(4, TorznabCatType.XXX, "XXX (18+)");
            AddCategoryMapping(14, TorznabCatType.MoviesSD, "Movies/XVID");
            AddCategoryMapping(17, TorznabCatType.MoviesSD, "Movies/x264");
            AddCategoryMapping(18, TorznabCatType.TVSD, "TV Episodes");
            AddCategoryMapping(23, TorznabCatType.AudioMP3, "Music/MP3");
            AddCategoryMapping(25, TorznabCatType.AudioLossless, "Music/FLAC");
            AddCategoryMapping(27, TorznabCatType.PCGames, "Games/PC ISO");
            AddCategoryMapping(28, TorznabCatType.PCGames, "Games/PC RIP");
            AddCategoryMapping(32, TorznabCatType.ConsoleXBox360, "Games/XBOX-360");
            AddCategoryMapping(33, TorznabCatType.PCISO, "Software/PC ISO");
            AddCategoryMapping(35, TorznabCatType.BooksEBook, "e-Books");
            AddCategoryMapping(40, TorznabCatType.ConsolePS3, "Games/PS3");
            AddCategoryMapping(41, TorznabCatType.TVHD, "TV HD Episodes");
            AddCategoryMapping(42, TorznabCatType.MoviesBluRay, "Movies/Full BD");
            AddCategoryMapping(44, TorznabCatType.MoviesHD, "Movies/x264/1080");
            AddCategoryMapping(45, TorznabCatType.MoviesHD, "Movies/x264/720");
            AddCategoryMapping(46, TorznabCatType.MoviesBluRay, "Movies/BD Remux");
            AddCategoryMapping(47, TorznabCatType.Movies3D, "Movies/x264/3D");
            AddCategoryMapping(48, TorznabCatType.MoviesHD, "Movies/XVID/720");
            AddCategoryMapping(49, TorznabCatType.TVUHD, "TV UHD Episodes");
            // torrentapi.org returns "Movies/TV-UHD-episodes" for some reason
            // possibly because thats what the category is called on the /top100.php page
            AddCategoryMapping(49, TorznabCatType.TVUHD, "Movies/TV-UHD-episodes");
            AddCategoryMapping(50, TorznabCatType.MoviesUHD, "Movies/x264/4k");
            AddCategoryMapping(51, TorznabCatType.MoviesUHD, "Movies/x265/4k");
            AddCategoryMapping(52, TorznabCatType.MoviesUHD, "Movs/x265/4k/HDR");
            AddCategoryMapping(53, TorznabCatType.ConsolePS4, "Games/PS4");
            AddCategoryMapping(54, TorznabCatType.MoviesHD, "Movies/x265/1080");

            _appId = "jackett_" + EnvironmentUtil.JackettVersion();

            EnableConfigurableRetryAttempts();
        }
Пример #35
0
        public PsyTorrents(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
            : base(id: "psytorrents",
                   name: "Psytorrents",
                   description: "Psytorrents (PSY) is a Private Torrent Tracker for ELECTRONIC MUSIC",
                   link: "https://psytorrents.info/",
                   caps: new TorznabCapabilities
        {
            MovieSearchParams = new List <MovieSearchParam>
            {
                MovieSearchParam.Q
            },
            MusicSearchParams = new List <MusicSearchParam>
            {
                MusicSearchParam.Q
            }
        },
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   supportsFreeleechTokens: true)
        {
            Language = "en-us";
            Type     = "private";

            webclient.AddTrustedCertificate(new Uri(SiteLink).Host, "B52C043ABDE7AFB2231E162B1DD468758AEEE307");
            webclient.AddTrustedCertificate(new Uri(SiteLink).Host, "AAA3E062739F3733FE659BA4A89E55E4EB48063B");

            AddCategoryMapping(1, TorznabCatType.Audio, "Music");
            AddCategoryMapping(2, TorznabCatType.Movies, "Movies");
            AddCategoryMapping(3, TorznabCatType.PC0day, "App");
        }
Пример #36
0
        // standard constructor used by most indexers
        public BaseIndexer(string name, string link, string description, IIndexerManagerService manager, IWebClient client, Logger logger, ConfigurationData configData, IProtectionService p, TorznabCapabilities caps = null, string downloadBase = null)
            : this(manager, client, logger, p)
        {
            if (!link.EndsWith("/"))
            {
                throw new Exception("Site link must end with a slash.");
            }

            DisplayName          = name;
            DisplayDescription   = description;
            SiteLink             = link;
            this.downloadUrlBase = downloadBase;
            this.configData      = configData;

            if (caps == null)
            {
                caps = TorznabUtil.CreateDefaultTorznabTVCaps();
            }
            TorznabCaps = caps;
        }
Пример #37
0
 // minimal constructor used by e.g. cardigann generic indexer
 public BaseIndexer(IIndexerManagerService manager, IWebClient client, Logger logger, IProtectionService p)
 {
     this.logger       = logger;
     indexerService    = manager;
     webclient         = client;
     protectionService = p;
 }
Пример #38
0
        public void LoadValuesFromJson(JToken json, IProtectionService ps = null)
        {
            if (json == null)
            {
                return;
            }

            var arr = (JArray)json;

            // transistion from alternatelink to sitelink
            var alternatelinkItem = arr.FirstOrDefault(f => f.Value <string>("id") == "alternatelink");

            if (alternatelinkItem != null && !string.IsNullOrEmpty(alternatelinkItem.Value <string>("value")))
            {
                //SiteLink.Value = alternatelinkItem.Value<string>("value");
            }

            foreach (var item in GetItems(forDisplay: false))
            {
                var arrItem = arr.FirstOrDefault(f => f.Value <string>("id") == item.ID);
                if (arrItem == null)
                {
                    continue;
                }

                switch (item.ItemType)
                {
                case ItemType.InputString:
                    var sItem    = (StringItem)item;
                    var newValue = arrItem.Value <string>("value");

                    if (string.Equals(item.Name, "password", StringComparison.InvariantCultureIgnoreCase))
                    {
                        if (newValue != PASSWORD_REPLACEMENT)
                        {
                            sItem.Value = newValue;
                            if (ps != null)
                            {
                                sItem.Value = ps.UnProtect(newValue);
                            }
                        }
                    }
                    else
                    {
                        sItem.Value = newValue;
                    }
                    break;

                case ItemType.HiddenData:
                    ((HiddenItem)item).Value = arrItem.Value <string>("value");
                    break;

                case ItemType.InputBool:
                    ((BoolItem)item).Value = arrItem.Value <bool>("value");
                    break;

                case ItemType.InputSelect:
                    ((SelectItem)item).Value = arrItem.Value <string>("value");
                    break;

                case ItemType.Recaptcha:
                    ((RecaptchaItem)item).Value     = arrItem.Value <string>("value");
                    ((RecaptchaItem)item).Cookie    = arrItem.Value <string>("cookie");
                    ((RecaptchaItem)item).Version   = arrItem.Value <string>("version");
                    ((RecaptchaItem)item).Challenge = arrItem.Value <string>("challenge");
                    break;
                }
            }
        }
Пример #39
0
        public TVVault(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
            : base(name: "TV-Vault",
                   description: "A TV tracker for old shows.",
                   link: "https://tv-vault.me/",
                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.UTF8;
            Language = "en-us";
            Type     = "private";

            AddCategoryMapping(1, TorznabCatType.TV);
            AddCategoryMapping(2, TorznabCatType.Movies);
        }
Пример #40
0
        public JToken ToJson(IProtectionService ps, bool forDisplay = true)
        {
            var items  = GetItems(forDisplay);
            var jArray = new JArray();

            foreach (var item in items)
            {
                var jObject = new JObject();
                jObject["id"]   = item.ID;
                jObject["type"] = item.ItemType.ToString().ToLower();
                jObject["name"] = item.Name;
                switch (item.ItemType)
                {
                case ItemType.Recaptcha:
                    jObject["sitekey"] = ((RecaptchaItem)item).SiteKey;
                    jObject["version"] = ((RecaptchaItem)item).Version;
                    break;

                case ItemType.InputString:
                case ItemType.HiddenData:
                case ItemType.DisplayInfo:
                    var value = ((StringItem)item).Value;
                    if (string.Equals(item.Name, "password", StringComparison.InvariantCultureIgnoreCase))     // if we chagne this logic we've to change the MigratedFromDPAPI() logic too, #2114 is realted
                    {
                        if (string.IsNullOrEmpty(value))
                        {
                            value = string.Empty;
                        }
                        else if (forDisplay)
                        {
                            value = PASSWORD_REPLACEMENT;
                        }
                        else if (ps != null)
                        {
                            value = ps.Protect(value);
                        }
                    }
                    jObject["value"] = value;
                    break;

                case ItemType.InputBool:
                    jObject["value"] = ((BoolItem)item).Value;
                    break;

                case ItemType.InputSelect:
                    jObject["value"]   = ((SelectItem)item).Value;
                    jObject["options"] = new JObject();

                    foreach (var option in ((SelectItem)item).Options)
                    {
                        jObject["options"][option.Key] = option.Value;
                    }
                    break;

                case ItemType.DisplayImage:
                    var dataUri = DataUrlUtils.BytesToDataUrl(((ImageItem)item).Value, "image/jpeg");
                    jObject["value"] = dataUri;
                    break;
                }
                jArray.Add(jObject);
            }
            return(jArray);
        }
Пример #41
0
        public XSpeeds(IIndexerConfigurationService configService, IWebClient wc, Logger l, IProtectionService ps)
            : base(name: "XSpeeds",
                   description: "XSpeeds",
                   link: "https://www.xspeeds.eu/",
                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.GetEncoding("UTF-8");
            Language = "en-us";
            Type     = "private";

            configData.DisplayText.Value = "Expect an initial delay (often around 10 seconds) due to XSpeeds CloudFlare DDoS protection";
            configData.DisplayText.Name  = "Notice";

            AddCategoryMapping(70, TorznabCatType.TVAnime);        // Anime
            AddCategoryMapping(4, TorznabCatType.PC);              // Apps
            AddCategoryMapping(82, TorznabCatType.PCMac);          // Mac
            AddCategoryMapping(80, TorznabCatType.AudioAudiobook); // Audiobooks
            AddCategoryMapping(66, TorznabCatType.MoviesBluRay);   // Blu-Ray
            AddCategoryMapping(48, TorznabCatType.Books);          // Books Magazines
            AddCategoryMapping(68, TorznabCatType.MoviesOther);    // Cams/TS
            AddCategoryMapping(65, TorznabCatType.TVDocumentary);  // Documentaries
            AddCategoryMapping(10, TorznabCatType.MoviesDVD);      // DVDR
            AddCategoryMapping(72, TorznabCatType.MoviesForeign);  // Foreign
            AddCategoryMapping(74, TorznabCatType.TVOTHER);        // Kids
            AddCategoryMapping(44, TorznabCatType.TVSport);        // MMA
            AddCategoryMapping(11, TorznabCatType.Movies);         // Movie Boxsets
            AddCategoryMapping(12, TorznabCatType.Movies);         // Movies
            AddCategoryMapping(13, TorznabCatType.Audio);          // Music
            AddCategoryMapping(15, TorznabCatType.AudioVideo);     // Music Videos
            AddCategoryMapping(32, TorznabCatType.ConsoleNDS);     // NDS Games
            AddCategoryMapping(9, TorznabCatType.Other);           // Other
            AddCategoryMapping(6, TorznabCatType.PCGames);         // PC Games
            AddCategoryMapping(45, TorznabCatType.Other);          // Pictures
            AddCategoryMapping(31, TorznabCatType.ConsolePS4);     // Playstation
            AddCategoryMapping(71, TorznabCatType.TV);             // PPV
            AddCategoryMapping(54, TorznabCatType.TV);             // Soaps
            AddCategoryMapping(20, TorznabCatType.TVSport);        // Sports
            AddCategoryMapping(86, TorznabCatType.TVSport);        // MotorSports
            AddCategoryMapping(89, TorznabCatType.TVSport);        // Olympics 2016
            AddCategoryMapping(88, TorznabCatType.TVSport);        // World Cup
            AddCategoryMapping(83, TorznabCatType.Movies);         // TOTM
            AddCategoryMapping(21, TorznabCatType.TVSD);           // TV Boxsets
            AddCategoryMapping(76, TorznabCatType.TVHD);           // HD Boxsets
            AddCategoryMapping(47, TorznabCatType.TVHD);           // TV-HD
            AddCategoryMapping(16, TorznabCatType.TVSD);           // TV-SD
            AddCategoryMapping(7, TorznabCatType.ConsoleWii);      // Wii Games
            AddCategoryMapping(43, TorznabCatType.TVSport);        // Wrestling
            AddCategoryMapping(8, TorznabCatType.ConsoleXbox);     // Xbox Games

            // RSS Textual categories
            AddCategoryMapping("Anime", TorznabCatType.TVAnime);
            AddCategoryMapping("Apps", TorznabCatType.PC);
            AddCategoryMapping("Mac", TorznabCatType.PCMac);
            AddCategoryMapping("Audiobooks", TorznabCatType.AudioAudiobook);
            AddCategoryMapping("Blu-Ray", TorznabCatType.MoviesBluRay);
            AddCategoryMapping("Books Magazines", TorznabCatType.Books);
            AddCategoryMapping("Cams/TS", TorznabCatType.MoviesOther);
            AddCategoryMapping("Documentaries", TorznabCatType.TVDocumentary);
            AddCategoryMapping("DVDR", TorznabCatType.MoviesDVD);
            AddCategoryMapping("Foreign", TorznabCatType.MoviesForeign);
            AddCategoryMapping("Kids", TorznabCatType.TVOTHER);
            AddCategoryMapping("MMA", TorznabCatType.TVSport);
            AddCategoryMapping("Movie Boxsets", TorznabCatType.Movies);
            AddCategoryMapping("Movies", TorznabCatType.Movies);
            AddCategoryMapping("Music", TorznabCatType.Audio);
            AddCategoryMapping("Music Videos", TorznabCatType.AudioVideo);
            AddCategoryMapping("NDS Games", TorznabCatType.ConsoleNDS);
            AddCategoryMapping("Other", TorznabCatType.Other);
            AddCategoryMapping("PC Games", TorznabCatType.PCGames);
            AddCategoryMapping("Pictures", TorznabCatType.Other);
            AddCategoryMapping("Playstation", TorznabCatType.ConsolePS4);
            AddCategoryMapping("PPV", TorznabCatType.TV);
            AddCategoryMapping("Soaps", TorznabCatType.TV);
            AddCategoryMapping("Sports", TorznabCatType.TVSport);
            AddCategoryMapping("MotorSports", TorznabCatType.TVSport);
            AddCategoryMapping("Olympics 2016", TorznabCatType.TVSport);
            AddCategoryMapping("World Cup", TorznabCatType.TVSport);
            AddCategoryMapping("TOTM", TorznabCatType.Movies);
            AddCategoryMapping("TV Boxsets", TorznabCatType.TVSD);
            AddCategoryMapping("HD Boxsets", TorznabCatType.TVHD);
            AddCategoryMapping("TV-HD", TorznabCatType.TVHD);
            AddCategoryMapping("TV-SD", TorznabCatType.TVSD);
            AddCategoryMapping("Wii Games", TorznabCatType.ConsoleWii);
            AddCategoryMapping("Wrestling", TorznabCatType.TVSport);
            AddCategoryMapping("Xbox Games", TorznabCatType.ConsoleXbox);
        }
Пример #42
0
        public TVstore(IIndexerConfigurationService configService, Utils.Clients.WebClient wc, Logger l, IProtectionService ps)
            : base(name: "TVstore",
                   description: "TV Store is a HUNGARIAN Private Torrent Tracker for TV",
                   link: "https://tvstore.me/",
                   caps: new TorznabCapabilities(),
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataTVstore())
        {
            Encoding = Encoding.UTF8;
            Language = "hu-hu";
            Type     = "private";

            TorznabCaps.SupportsImdbTVSearch = true;
            AddCategoryMapping(1, TorznabCatType.TV);
            AddCategoryMapping(2, TorznabCatType.TVHD);
            AddCategoryMapping(3, TorznabCatType.TVSD);
        }
Пример #43
0
        public BrokenStones(IIndexerConfigurationService configService, IWebClient webClient, Logger logger, IProtectionService protectionService)
            : base(name: "BrokenStones",
                   desc: null,
                   link: "https://brokenstones.club/",
                   configService: configService,
                   logger: logger,
                   protectionService: protectionService,
                   webClient: webClient
                   )
        {
            Language = "en-us";
            Type     = "private";

            AddCategoryMapping(1, TorznabCatType.PCMac, "MacOS Apps");
            AddCategoryMapping(2, TorznabCatType.PCMac, "MacOS Games");
            AddCategoryMapping(3, TorznabCatType.PCPhoneIOS, "iOS Apps");
            AddCategoryMapping(4, TorznabCatType.PCPhoneIOS, "iOS Games");
            AddCategoryMapping(5, TorznabCatType.Other, "Graphics");
            AddCategoryMapping(6, TorznabCatType.Audio, "Audio");
            AddCategoryMapping(7, TorznabCatType.Other, "Tutorials");
            AddCategoryMapping(8, TorznabCatType.Other, "Other");
        }
Пример #44
0
 protected BaseFeedIndexer(string name, string link, string description, IIndexerConfigurationService configService, WebClient client, Logger logger, ConfigurationData configData, IProtectionService p, TorznabCapabilities caps = null, string downloadBase = null) : base(name, link, description, configService, client, logger, configData, p, caps, downloadBase)
 {
 }
Пример #45
0
        public FunFile(IIndexerConfigurationService configService, WebClient w, Logger l, IProtectionService ps)
            : base(name: "FunFile",
                   description: "A general tracker",
                   link: "https://www.funfile.org/",
                   caps: new TorznabCapabilities(),
                   configService: configService,
                   client: w,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.GetEncoding("iso-8859-1");
            Language = "en-us";
            Type     = "private";

            AddCategoryMapping(44, TorznabCatType.TVAnime);        // Anime
            AddCategoryMapping(22, TorznabCatType.PC);             // Applications
            AddCategoryMapping(43, TorznabCatType.AudioAudiobook); // Audio Books
            AddCategoryMapping(27, TorznabCatType.Books);          // Ebook
            AddCategoryMapping(4, TorznabCatType.PCGames);         // Games
            AddCategoryMapping(40, TorznabCatType.OtherMisc);      // Miscellaneous
            AddCategoryMapping(19, TorznabCatType.Movies);         // Movies
            AddCategoryMapping(6, TorznabCatType.Audio);           // Music
            AddCategoryMapping(31, TorznabCatType.PCPhoneOther);   // Portable
            AddCategoryMapping(7, TorznabCatType.TV);              // TV
        }
Пример #46
0
 protected BaseMetaIndexer(string name, string description, IFallbackStrategyProvider fallbackStrategyProvider, IResultFilterProvider resultFilterProvider, IIndexerConfigurationService configService, WebClient webClient, Logger logger, ConfigurationData configData, IProtectionService p, Func <IIndexer, bool> filter)
     : base(name, "http://127.0.0.1/", description, configService, webClient, logger, configData, p, null, null)
 {
     filterFunc = filter;
     this.fallbackStrategyProvider = fallbackStrategyProvider;
     this.resultFilterProvider     = resultFilterProvider;
 }
Пример #47
0
 public BlackholeController(IIndexerManagerService i, Logger l, ServerConfig sConfig, IProtectionService ps)
 {
     logger            = l;
     indexerService    = i;
     serverConfig      = sConfig;
     protectionService = ps;
 }
Пример #48
0
        public MejorTorrent(IIndexerConfigurationService configService, WebClient w, Logger l, IProtectionService ps)
            : base(id: "mejortorrent",
                   name: "MejorTorrent",
                   description: "MejorTorrent - Hay veces que un torrent viene mejor! :)",
                   link: "https://www.mejortorrentt.net/",
                   caps: new TorznabCapabilities(),
                   configService: configService,
                   client: w,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationData())
        {
            Encoding = Encoding.UTF8;
            Language = "es-es";
            Type     = "public";

            var matchWords = new BoolItem()
            {
                Name = "Match words in title", Value = true
            };

            configData.AddDynamic("MatchWords", matchWords);

            AddCategoryMapping(MejorTorrentCatType.Pelicula, TorznabCatType.Movies);
            AddCategoryMapping(MejorTorrentCatType.Serie, TorznabCatType.TVSD);
            AddCategoryMapping(MejorTorrentCatType.SerieHd, TorznabCatType.TVHD);
            AddCategoryMapping(MejorTorrentCatType.Musica, TorznabCatType.Audio);
            AddCategoryMapping(MejorTorrentCatType.Otro, TorznabCatType.Other);
        }
Пример #49
0
        public Torrentech(IIndexerConfigurationService configService, Utils.Clients.WebClient wc, Logger l, IProtectionService ps)
            : base(name: "Torrentech",
                   description: "TorrenTech (TTH) is a Private Torrent Tracker for ELECTRONIC MUSIC",
                   link: "https://www.torrentech.org/",
                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
        {
            Encoding = Encoding.UTF8;
            Language = "en-us";
            Type     = "private";

            AddCategoryMapping(1, TorznabCatType.AudioMP3);
            AddCategoryMapping(2, TorznabCatType.AudioLossless);
            AddCategoryMapping(3, TorznabCatType.AudioOther);
        }
Пример #50
0
        public Nordicbits(IIndexerConfigurationService configService, Utils.Clients.WebClient w, Logger l, IProtectionService ps)
            : base(
                name: "Nordicbits",
                description: "Nordicbits is a Danish Private site for MOVIES / TV / GENERAL",
                link: "https://nordicb.org/",
                caps: new TorznabCapabilities(),
                configService: configService,
                client: w,
                logger: l,
                p: ps,
                configData: new ConfigurationDataNordicbits())
        {
            Encoding = Encoding.GetEncoding("iso-8859-1");
            Language = "da-dk";
            Type     = "private";

            TorznabCaps.SupportsImdbMovieSearch = false;

            // Apps
            AddCategoryMapping("cat=63", TorznabCatType.PCPhoneAndroid, "APPS - Android");
            AddCategoryMapping("cat=17", TorznabCatType.PC, "APPS - MAC");
            AddCategoryMapping("cat=12", TorznabCatType.PCMac, "APPS - Windows");
            AddCategoryMapping("cat=62", TorznabCatType.PCPhoneIOS, "APPS - IOS");
            AddCategoryMapping("cat=64", TorznabCatType.PC, "APPS - Linux");

            // Books
            AddCategoryMapping("cat=54", TorznabCatType.AudioAudiobook, "Books - Audiobooks");
            AddCategoryMapping("cat=9", TorznabCatType.BooksEbook, "Books - E-Books");

            // Games
            AddCategoryMapping("cat=24", TorznabCatType.PCGames, "Games - PC");
            AddCategoryMapping("cat=53", TorznabCatType.Console, "Games - Nintendo");
            AddCategoryMapping("cat=49", TorznabCatType.ConsolePS4, "Games - Playstation");
            AddCategoryMapping("cat=51", TorznabCatType.ConsoleXbox, "Games - XBOX");

            // Movies
            AddCategoryMapping("cat=35", TorznabCatType.Movies3D, "Movies - 3D");
            AddCategoryMapping("cat=42", TorznabCatType.MoviesUHD, "Movies - 4K/2160p");
            AddCategoryMapping("cat=47", TorznabCatType.MoviesUHD, "Movies - 4k/2160p Boxset");
            AddCategoryMapping("cat=15", TorznabCatType.MoviesBluRay, "Movies - BluRay");
            AddCategoryMapping("cat=58", TorznabCatType.MoviesHD, "Movies - Remux");
            AddCategoryMapping("cat=16", TorznabCatType.MoviesDVD, "Movies - DVD Boxset");
            AddCategoryMapping("cat=6", TorznabCatType.MoviesDVD, "Movies - DVD");
            AddCategoryMapping("cat=21", TorznabCatType.MoviesHD, "Movies - HD-1080p");
            AddCategoryMapping("cat=19", TorznabCatType.MoviesHD, "Movies - HD-1080p Boxset");
            AddCategoryMapping("cat=22", TorznabCatType.MoviesHD, "Movies - HD-720p");
            AddCategoryMapping("cat=20", TorznabCatType.MoviesHD, "Movies - HD-720p Boxset");
            AddCategoryMapping("cat=25", TorznabCatType.MoviesHD, "Movies - Kids");
            AddCategoryMapping("cat=10", TorznabCatType.MoviesSD, "Movies - SD");
            AddCategoryMapping("cat=23", TorznabCatType.MoviesSD, "Movies - MP4 Tablet");
            AddCategoryMapping("cat=65", TorznabCatType.XXX, "Movies - P**n");

            // Music
            AddCategoryMapping("cat=28", TorznabCatType.AudioLossless, "Music - FLAC");
            AddCategoryMapping("cat=60", TorznabCatType.AudioLossless, "Music - FLAC Boxset");
            AddCategoryMapping("cat=4", TorznabCatType.AudioMP3, "Music - MP3");
            AddCategoryMapping("cat=59", TorznabCatType.AudioMP3, "Music - MP3 Boxset");
            AddCategoryMapping("cat=61", TorznabCatType.AudioMP3, "Music - Musicvideos Boxset");
            AddCategoryMapping("cat=1", TorznabCatType.AudioMP3, "Music - Musicvideos");

            // Series
            AddCategoryMapping("cat=48", TorznabCatType.TVUHD, "TV - HD-4K/2160p");
            AddCategoryMapping("cat=57", TorznabCatType.TVUHD, "TV - HD-4K/2160p Boxset");
            AddCategoryMapping("cat=11", TorznabCatType.TVSD, "TV - Boxset");
            AddCategoryMapping("cat=7", TorznabCatType.TVHD, "TV - HD-1080p");
            AddCategoryMapping("cat=31", TorznabCatType.TVHD, "TV - HD-1080p Boxset");
            AddCategoryMapping("cat=30", TorznabCatType.TVHD, "TV - HD-720p");
            AddCategoryMapping("cat=32", TorznabCatType.TVHD, "TV - HD-720p Boxset");
            AddCategoryMapping("cat=5", TorznabCatType.TVSD, "TV - SD");
            AddCategoryMapping("cat=66", TorznabCatType.TVSport, "TV - SD/HD Mixed");
        }
Пример #51
0
        public DanishBits(IIndexerConfigurationService configService, WebClient c, Logger l, IProtectionService ps)
            : base(name: "DanishBits",
                   description: "A danish closed torrent tracker",
                   link: "https://danishbits.org/",
                   endpoint: "couchpotato.php",
                   configService: configService,
                   client: c,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataUserPasskey("Note about Passkey: This is not your login Password. Find the Passkey by logging into DanishBits with your Browser, and under your account page you'll see your passkey under the 'Personal' section on the left side.")
                   )
        {
            Encoding = Encoding.UTF8;
            Language = "da-dk";
            Type     = "private";

            AddCategoryMapping("movie", TorznabCatType.Movies);
            AddCategoryMapping("tv", TorznabCatType.TV);
            AddCategoryMapping("blandet", TorznabCatType.Other); // e.g. games
        }
Пример #52
0
        public Cinecalidad(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps,
                           ICacheService cs)
            : base(id: "cinecalidad",
                   name: "Cinecalidad",
                   description: "Películas Full HD en Castellano y Latino Dual.",
                   link: "https://www.cinecalidad.is/",
                   caps: new TorznabCapabilities {
            MovieSearchParams = new List <MovieSearchParam> {
                MovieSearchParam.Q
            }
        },
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   cacheService: cs,
                   configData: new ConfigurationData())
        {
            Encoding = Encoding.UTF8;
            Language = "es-es";
            Type     = "public";

            var language = new SingleSelectConfigurationItem("Select language", new Dictionary <string, string>
            {
                { "castellano", "Castilian Spanish" },
                { "latino", "Latin American Spanish" }
            })
            {
                Value = "castellano"
            };

            configData.AddDynamic("language", language);

            AddCategoryMapping(1, TorznabCatType.MoviesHD);
        }
Пример #53
0
        public Cinecalidad(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps,
                           ICacheService cs)
            : base(id: "cinecalidad",
                   name: "Cinecalidad",
                   description: "Películas Full HD en Latino Dual.",
                   link: "https://cinecalidad.dev/",
                   caps: new TorznabCapabilities
        {
            MovieSearchParams = new List <MovieSearchParam> {
                MovieSearchParam.Q
            }
        },
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   cacheService: cs,
                   configData: new ConfigurationData())
        {
            Encoding = Encoding.UTF8;
            Language = "es-419";
            Type     = "public";

            AddCategoryMapping(1, TorznabCatType.MoviesHD);
        }
Пример #54
0
        public InternetArchive(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
            : base(id: "internetarchive",
                   name: "Internet Archive",
                   description: "Internet Archive is a non-profit digital library offering free universal access to books, movies & music, as well as 406 billion archived web pages",
                   link: "https://archive.org/",
                   caps: new TorznabCapabilities {
            // TODO: add music and book search
            TvSearchParams = new List <TvSearchParam>
            {
                TvSearchParam.Q
            },
            MovieSearchParams = new List <MovieSearchParam>
            {
                MovieSearchParam.Q
            }
        },
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationData())
        {
            Encoding = Encoding.UTF8;
            Language = "en-us";
            Type     = "public";

            var sort = new SelectItem(new Dictionary <string, string>
            {
                { "publicdate", "created" },
                { "downloads", "downloads" },
                { "item_size", "size" }
            })
            {
                Name = "Sort requested from site", Value = "publicdate"
            };

            configData.AddDynamic("sort", sort);

            var order = new SelectItem(new Dictionary <string, string>
            {
                { "desc", "desc" },
                { "asc", "asc" },
            })
            {
                Name = "Order requested from site", Value = "desc"
            };

            configData.AddDynamic("order", order);

            var titleOnly = new BoolItem()
            {
                Name = "Search only in title", Value = true
            };

            configData.AddDynamic("titleOnly", titleOnly);

            AddCategoryMapping("audio", TorznabCatType.Audio);
            AddCategoryMapping("etree", TorznabCatType.Audio);
            AddCategoryMapping("movies", TorznabCatType.Movies);
            AddCategoryMapping("image", TorznabCatType.OtherMisc);
            AddCategoryMapping("texts", TorznabCatType.Books);
            AddCategoryMapping("software", TorznabCatType.PC);
            AddCategoryMapping("web", TorznabCatType.Other);
            AddCategoryMapping("collection", TorznabCatType.Other);
            AddCategoryMapping("account", TorznabCatType.Other);
            AddCategoryMapping("data", TorznabCatType.Other);
            AddCategoryMapping("other", TorznabCatType.Other);
        }
Пример #55
0
        public BitSoup(IIndexerManagerService i, IWebClient wc, Logger l, IProtectionService ps)
            : base(name: "BitSoup",
                   description: "SoupieBits",
                   link: "https://www.bitsoup.me/",
                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                   manager: i,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataBasicLoginWithAlternateLink())
        {
            Encoding = Encoding.UTF8;
            Language = "en-us";

            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);
            //AddCategoryMapping("308", TorznabCatType.ConsolePSP);
            AddCategoryMapping("35", TorznabCatType.ConsoleWii);
            //AddCategoryMapping("309", TorznabCatType.ConsoleXbox);
            AddCategoryMapping("12", TorznabCatType.ConsoleXbox360);
            //AddCategoryMapping("305", TorznabCatType.ConsoleWiiwareVC);
            //AddCategoryMapping("309", TorznabCatType.ConsoleXBOX360DLC);
            AddCategoryMapping("38", TorznabCatType.ConsolePS3);
            //AddCategoryMapping("239", TorznabCatType.ConsoleOther);
            //AddCategoryMapping("245", TorznabCatType.ConsoleOther);
            //AddCategoryMapping("246", TorznabCatType.ConsoleOther);
            //AddCategoryMapping("626", TorznabCatType.ConsoleOther);
            //AddCategoryMapping("628", TorznabCatType.ConsoleOther);
            //AddCategoryMapping("630", TorznabCatType.ConsoleOther);
            //AddCategoryMapping("307", TorznabCatType.Console3DS);
            //AddCategoryMapping("308", TorznabCatType.ConsolePSVita);
            //AddCategoryMapping("307", TorznabCatType.ConsoleWiiU);
            //AddCategoryMapping("309", TorznabCatType.ConsoleXboxOne);
            //AddCategoryMapping("308", TorznabCatType.ConsolePS4);
            //AddCategoryMapping("631", TorznabCatType.Movies);
            //AddCategoryMapping("631", TorznabCatType.MoviesForeign);
            //AddCategoryMapping("455", TorznabCatType.MoviesOther);
            //AddCategoryMapping("633", TorznabCatType.MoviesOther);
            AddCategoryMapping("19", TorznabCatType.MoviesSD);
            AddCategoryMapping("41", TorznabCatType.MoviesHD);
            AddCategoryMapping("17", TorznabCatType.Movies3D);
            AddCategoryMapping("80", TorznabCatType.MoviesBluRay);
            AddCategoryMapping("20", TorznabCatType.MoviesDVD);
            //AddCategoryMapping("631", TorznabCatType.MoviesWEBDL);
            AddCategoryMapping("6", TorznabCatType.Audio);
            //AddCategoryMapping("623", TorznabCatType.AudioMP3);
            AddCategoryMapping("29", TorznabCatType.AudioVideo);
            //AddCategoryMapping("402", TorznabCatType.AudioVideo);
            AddCategoryMapping("5", TorznabCatType.AudioAudiobook);
            //AddCategoryMapping("1", TorznabCatType.AudioLossless);
            //AddCategoryMapping("403", TorznabCatType.AudioOther);
            //AddCategoryMapping("642", TorznabCatType.AudioOther);
            //AddCategoryMapping("1", TorznabCatType.AudioForeign);
            //AddCategoryMapping("233", TorznabCatType.PC);
            //AddCategoryMapping("236", TorznabCatType.PC);
            //AddCategoryMapping("1", TorznabCatType.PC0day);
            AddCategoryMapping("1", TorznabCatType.PCISO);
            //AddCategoryMapping("235", TorznabCatType.PCMac);
            //AddCategoryMapping("627", TorznabCatType.PCPhoneOther);
            AddCategoryMapping("21", TorznabCatType.PCGames);
            AddCategoryMapping("4", TorznabCatType.PCGames);
            //AddCategoryMapping("625", TorznabCatType.PCPhoneIOS);
            //AddCategoryMapping("625", TorznabCatType.PCPhoneAndroid);
            AddCategoryMapping("45", TorznabCatType.TV);
            //AddCategoryMapping("433", TorznabCatType.TV);
            //AddCategoryMapping("639", TorznabCatType.TVWEBDL);
            //AddCategoryMapping("433", TorznabCatType.TVWEBDL);
            //AddCategoryMapping("639", TorznabCatType.TVFOREIGN);
            //AddCategoryMapping("433", TorznabCatType.TVFOREIGN);
            AddCategoryMapping("7", TorznabCatType.TVSD);
            AddCategoryMapping("49", TorznabCatType.TVSD);
            AddCategoryMapping("42", TorznabCatType.TVHD);
            //AddCategoryMapping("433", TorznabCatType.TVHD);
            //AddCategoryMapping("635", TorznabCatType.TVOTHER);
            //AddCategoryMapping("636", TorznabCatType.TVSport);
            AddCategoryMapping("23", TorznabCatType.TVAnime);
            //AddCategoryMapping("634", TorznabCatType.TVDocumentary);
            AddCategoryMapping("9", TorznabCatType.XXX);
            //AddCategoryMapping("1", TorznabCatType.XXXDVD);
            //AddCategoryMapping("1", TorznabCatType.XXXWMV);
            //AddCategoryMapping("1", TorznabCatType.XXXXviD);
            //AddCategoryMapping("1", TorznabCatType.XXXx264);
            //AddCategoryMapping("1", TorznabCatType.XXXOther);
            //AddCategoryMapping("1", TorznabCatType.XXXImageset);
            //AddCategoryMapping("1", TorznabCatType.XXXPacks);
            //AddCategoryMapping("340", TorznabCatType.Other);
            //AddCategoryMapping("342", TorznabCatType.Other);
            //AddCategoryMapping("344", TorznabCatType.Other);
            //AddCategoryMapping("391", TorznabCatType.Other);
            //AddCategoryMapping("392", TorznabCatType.Other);
            //AddCategoryMapping("393", TorznabCatType.Other);
            //AddCategoryMapping("394", TorznabCatType.Other);
            //AddCategoryMapping("234", TorznabCatType.Other);
            //AddCategoryMapping("638", TorznabCatType.Other);
            //AddCategoryMapping("629", TorznabCatType.Other);
            //AddCategoryMapping("1", TorznabCatType.OtherMisc);
            //AddCategoryMapping("1", TorznabCatType.OtherHashed);
            //AddCategoryMapping("408", TorznabCatType.Books);
            AddCategoryMapping("24", TorznabCatType.BooksEbook);
            //AddCategoryMapping("406", TorznabCatType.BooksComics);
            //AddCategoryMapping("407", TorznabCatType.BooksComics);
            //AddCategoryMapping("409", TorznabCatType.BooksComics);
            //AddCategoryMapping("410", TorznabCatType.BooksMagazines);
            //AddCategoryMapping("1", TorznabCatType.BooksTechnical);
            //AddCategoryMapping("1", TorznabCatType.BooksOther);
            //AddCategoryMapping("1", TorznabCatType.BooksForeign);
        }
Пример #56
0
        public Synthesiz3r(IIndexerConfigurationService configService, IWebClient webClient, Logger logger, IProtectionService protectionService)
            : base(name: "Synthesiz3r",
                   desc: "Synthesiz3r (ST3) is a Private Torrent Tracker for ELECTRONIC MUSIC",
                   link: "https://synthesiz3r.com/",
                   configService: configService,
                   logger: logger,
                   protectionService: protectionService,
                   webClient: webClient
                   )
        {
            Language = "en-us";
            Type     = "private";

            AddCategoryMapping(1, TorznabCatType.Audio, "Music");
            AddCategoryMapping(2, TorznabCatType.PC, "Applications");
            AddCategoryMapping(3, TorznabCatType.Books, "E-Books");
            AddCategoryMapping(4, TorznabCatType.AudioAudiobook, "Audiobooks");
            AddCategoryMapping(5, TorznabCatType.Movies, "E-Learning Videos");
            AddCategoryMapping(6, TorznabCatType.TV, "Comedy");
            AddCategoryMapping(7, TorznabCatType.Books, "Comics");
        }
Пример #57
0
        public NCore(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps) :
            base(id: "ncore",
                 name: "nCore",
                 description: "A Hungarian private torrent site.",
                 link: "https://ncore.cc/",
                 caps: new TorznabCapabilities
        {
            TvSearchParams = new List <TvSearchParam>
            {
                TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep, TvSearchParam.ImdbId
            },
            MovieSearchParams = new List <MovieSearchParam>
            {
                MovieSearchParam.Q, MovieSearchParam.ImdbId
            },
            MusicSearchParams = new List <MusicSearchParam>
            {
                MusicSearchParam.Q
            },
            BookSearchParams = new List <BookSearchParam>
            {
                BookSearchParam.Q
            }
        },
                 configService: configService,
                 client: wc,
                 logger: l,
                 p: ps,
                 configData: new ConfigurationDataNCore())
        {
            Encoding = Encoding.UTF8;
            Language = "hu-hu";
            Type     = "private";

            AddCategoryMapping("xvid_hun", TorznabCatType.MoviesSD, "Film SD/HU");
            AddCategoryMapping("xvid", TorznabCatType.MoviesSD, "Film SD/EN");
            AddCategoryMapping("dvd_hun", TorznabCatType.MoviesDVD, "Film DVDR/HU");
            AddCategoryMapping("dvd", TorznabCatType.MoviesDVD, "Film DVDR/EN");
            AddCategoryMapping("dvd9_hun", TorznabCatType.MoviesDVD, "Film DVD9/HU");
            AddCategoryMapping("dvd9", TorznabCatType.MoviesDVD, "Film DVD9/EN");
            AddCategoryMapping("hd_hun", TorznabCatType.MoviesHD, "Film HD/HU");
            AddCategoryMapping("hd", TorznabCatType.MoviesHD, "Film HD/EN");
            AddCategoryMapping("xvidser_hun", TorznabCatType.TVSD, "Sorozat SD/HU");
            AddCategoryMapping("xvidser", TorznabCatType.TVSD, "Sorozat SD/EN");
            AddCategoryMapping("dvdser_hun", TorznabCatType.TVSD, "Sorozat DVDR/HU");
            AddCategoryMapping("dvdser", TorznabCatType.TVSD, "Sorozat DVDR/EN");
            AddCategoryMapping("hdser_hun", TorznabCatType.TVHD, "Sorozat HD/HU");
            AddCategoryMapping("hdser", TorznabCatType.TVHD, "Sorozat HD/EN");
            AddCategoryMapping("mp3_hun", TorznabCatType.AudioMP3, "Zene MP3/HU");
            AddCategoryMapping("mp3", TorznabCatType.AudioMP3, "Zene MP3/EN");
            AddCategoryMapping("lossless_hun", TorznabCatType.AudioLossless, "Zene Lossless/HU");
            AddCategoryMapping("lossless", TorznabCatType.AudioLossless, "Zene Lossless/EN");
            AddCategoryMapping("clip", TorznabCatType.AudioVideo, "Zene Klip");
            AddCategoryMapping("xxx_xvid", TorznabCatType.XXXXviD, "XXX SD");
            AddCategoryMapping("xxx_dvd", TorznabCatType.XXXDVD, "XXX DVDR");
            AddCategoryMapping("xxx_imageset", TorznabCatType.XXXImageSet, "XXX Imageset");
            AddCategoryMapping("xxx_hd", TorznabCatType.XXX, "XXX HD");
            AddCategoryMapping("game_iso", TorznabCatType.PCGames, "Játék PC/ISO");
            AddCategoryMapping("game_rip", TorznabCatType.PCGames, "Játék PC/RIP");
            AddCategoryMapping("console", TorznabCatType.Console, "Játék Konzol");
            AddCategoryMapping("iso", TorznabCatType.PCISO, "Program Prog/ISO");
            AddCategoryMapping("misc", TorznabCatType.PC0day, "Program Prog/RIP");
            AddCategoryMapping("mobil", TorznabCatType.PCMobileOther, "Program Prog/Mobil");
            AddCategoryMapping("ebook_hun", TorznabCatType.Books, "Könyv eBook/HU");
            AddCategoryMapping("ebook", TorznabCatType.Books, "Könyv eBook/EN");
        }
Пример #58
0
        public BeyondHD(IIndexerConfigurationService configService, WebClient w, Logger l, IProtectionService ps)
            : base(name: "BeyondHD",
                   description: "Without BeyondHD, your HDTV is just a TV",
                   link: "https://beyond-hd.me/",
                   caps: new TorznabCapabilities(),
                   configService: configService,
                   client: w,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataLoginLink())
        {
            Encoding = Encoding.UTF8;
            Language = "en-us";
            Type     = "private";

            configData.DisplayText.Value = "Go to the general tab of your BeyondHD user profile and create/copy the Login Link.";

            AddCategoryMapping(37, TorznabCatType.MoviesBluRay, "Movie / Blu-ray");
            AddCategoryMapping(71, TorznabCatType.Movies3D, "Movie / 3D");
            AddCategoryMapping(83, TorznabCatType.Movies3D, "FraMeSToR 3D");

            AddCategoryMapping(77, TorznabCatType.MoviesHD, "Movie / 1080p/i");
            AddCategoryMapping(102, TorznabCatType.MoviesUHD, "Movie / 4K Disk");
            AddCategoryMapping(94, TorznabCatType.MoviesUHD, "Movie / 4K Other");
            AddCategoryMapping(103, TorznabCatType.MoviesUHD, "Movie / 4K Remux");
            AddCategoryMapping(78, TorznabCatType.MoviesHD, "Movie / 720p");
            AddCategoryMapping(54, TorznabCatType.MoviesHD, "Movie / MP4");
            AddCategoryMapping(17, TorznabCatType.MoviesHD, "Movie / Remux");
            AddCategoryMapping(38, TorznabCatType.MoviesHD, "Movie / WEB-DL");
            AddCategoryMapping(106, TorznabCatType.MoviesHD, "Internal / BHDStudio 1080p");
            AddCategoryMapping(105, TorznabCatType.MoviesHD, "Internal / BHDStudio 720p");
            AddCategoryMapping(50, TorznabCatType.MoviesHD, "Internal / FraMeSToR 1080p");
            AddCategoryMapping(75, TorznabCatType.MoviesHD, "Internal / FraMeSToR 720p");
            AddCategoryMapping(49, TorznabCatType.MoviesHD, "Internal / FraMeSToR REMUX");
            AddCategoryMapping(101, TorznabCatType.MoviesHD, "Internal / FraMeSToR 4K REMUX");
            AddCategoryMapping(61, TorznabCatType.MoviesHD, "Internal / HDX REMUX");
            AddCategoryMapping(86, TorznabCatType.MoviesHD, "Internal / SC4R");
            AddCategoryMapping(95, TorznabCatType.MoviesHD, "Nightripper 1080p");
            AddCategoryMapping(96, TorznabCatType.MoviesHD, "Nightripper 720p");
            AddCategoryMapping(98, TorznabCatType.MoviesHD, "Nightripper MicroHD");

            AddCategoryMapping(104, TorznabCatType.TVUHD, "TV Show / 4K");
            AddCategoryMapping(40, TorznabCatType.TVHD, "TV Show / Blu-ray");
            AddCategoryMapping(44, TorznabCatType.TVHD, "TV Show / Encodes");
            AddCategoryMapping(48, TorznabCatType.TVHD, "TV Show / HDTV");
            AddCategoryMapping(89, TorznabCatType.TVHD, "TV Show / Packs");
            AddCategoryMapping(46, TorznabCatType.TVHD, "TV Show / Remux");
            AddCategoryMapping(99, TorznabCatType.TVHD, "TV Show / Sports");
            AddCategoryMapping(100, TorznabCatType.TVHD, "TV Show / Sports / WEB-DL");
            AddCategoryMapping(45, TorznabCatType.TVHD, "TV Show / WEB-DL");
            AddCategoryMapping(97, TorznabCatType.TVHD, "Nightripper TV Show Encodes");

            AddCategoryMapping(36, TorznabCatType.AudioLossless, "Music / Lossless");
            AddCategoryMapping(69, TorznabCatType.AudioMP3, "Music / MP3");
            AddCategoryMapping(55, TorznabCatType.AudioVideo, "Music / 1080p/i");
            AddCategoryMapping(56, TorznabCatType.AudioVideo, "Music / 720p");
            AddCategoryMapping(42, TorznabCatType.AudioVideo, "Music / Blu-ray");
        }
Пример #59
0
 public ConfigurationData(JToken json, IProtectionService ps)
 {
     LoadValuesFromJson(json, ps);
 }
Пример #60
0
        public FileList(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
            : base(name: "FileList",
                   description: "The best Romanian site.",
                   link: "http://filelist.ro/",
                   caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
                   configService: configService,
                   client: wc,
                   logger: l,
                   p: ps,
                   configData: new ConfigurationDataFileList())
        {
            Encoding = Encoding.UTF8;
            Language = "ro-ro";
            Type     = "private";

            TorznabCaps.SupportsImdbSearch = true;

            AddCategoryMapping(24, TorznabCatType.TVAnime, "Anime");
            AddCategoryMapping(11, TorznabCatType.Audio, "Audio");
            AddCategoryMapping(15, TorznabCatType.TV, "Desene");
            AddCategoryMapping(18, TorznabCatType.Other, "Diverse");
            AddCategoryMapping(16, TorznabCatType.Books, "Docs");
            AddCategoryMapping(25, TorznabCatType.Movies3D, "Filme 3D");
            AddCategoryMapping(6, TorznabCatType.MoviesHD, "Filme 4K");
            AddCategoryMapping(26, TorznabCatType.MoviesBluRay, "Filme 4K Blu-Ray");
            AddCategoryMapping(20, TorznabCatType.MoviesBluRay, "Filme Blu-Ray");
            AddCategoryMapping(2, TorznabCatType.MoviesDVD, "Filme DVD");
            AddCategoryMapping(3, TorznabCatType.MoviesForeign, "Filme DVD-RO");
            AddCategoryMapping(4, TorznabCatType.MoviesHD, "Filme HD");
            AddCategoryMapping(19, TorznabCatType.MoviesForeign, "Filme HD-RO");
            AddCategoryMapping(1, TorznabCatType.MoviesSD, "Filme SD");
            AddCategoryMapping(5, TorznabCatType.AudioLossless, "FLAC");
            AddCategoryMapping(10, TorznabCatType.Console, "Jocuri Console");
            AddCategoryMapping(9, TorznabCatType.PCGames, "Jocuri PC");
            AddCategoryMapping(17, TorznabCatType.PC, "Linux");
            AddCategoryMapping(22, TorznabCatType.PCPhoneOther, "Mobile");
            AddCategoryMapping(8, TorznabCatType.PC, "Programe");
            AddCategoryMapping(27, TorznabCatType.TVHD, "Seriale 4K");
            AddCategoryMapping(21, TorznabCatType.TVHD, "Seriale HD");
            AddCategoryMapping(23, TorznabCatType.TVSD, "Seriale SD");
            AddCategoryMapping(13, TorznabCatType.TVSport, "Sport");
            AddCategoryMapping(12, TorznabCatType.AudioVideo, "Videoclip");
            AddCategoryMapping(7, TorznabCatType.XXX, "XXX");
        }