public MejorTorrent(IIndexerConfigurationService configService, WebClient w, Logger l, IProtectionService ps)
: base(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);
}
public TorrentMafya(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps,
ICacheService cs)
: base(id: "torrentmafya",
name: "TorrentMafya",
description: "TorrentMafya is a Turkish general torrent tracker ",
link: "https://www.torrentmafya.org/",
caps: new TorznabCapabilities
{
TvSearchParams = new List <TvSearchParam>
{
TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep
},
MovieSearchParams = new List <MovieSearchParam>
{
MovieSearchParam.Q
}
},
configService: configService,
client: wc,
logger: l,
p: ps,
cacheService: cs,
configData: new ConfigurationData())
{
Encoding = Encoding.UTF8;
Language = "tr-TR";
Type = "public";
AddCategoryMapping("games", TorznabCatType.PCGames, "Oyun");
AddCategoryMapping("programs", TorznabCatType.PC, "Program");
AddCategoryMapping("movies", TorznabCatType.Movies, "Film");
AddCategoryMapping("tv", TorznabCatType.TV, "Dizi");
AddCategoryMapping("apk", TorznabCatType.PCMobileAndroid, "APK");
configData.AddDynamic("keyInfo", new DisplayInfoConfigurationItem(String.Empty, "TorrentMafya allows only Turkish IP addressess. The error <b>403 Forbidden: Parse error</b> means your IP was not accepted."));
}
public Psytorrents(IIndexerConfigurationService configService, WebClient webClient, Logger logger, IProtectionService protectionService)
: base(name: "Psytorrents",
desc: "Psytorrents (PSY) is a Private Torrent Tracker for ELECTRONIC MUSIC",
link: "https://psytorrents.info/",
configService: configService,
logger: logger,
protectionService: protectionService,
webClient: webClient,
supportsFreeleechTokens: true
)
{
Language = "en-us";
Type = "private";
AddCategoryMapping(1, TorznabCatType.Audio, "Music");
AddCategoryMapping(2, TorznabCatType.Movies, "Movies");
AddCategoryMapping(3, TorznabCatType.PC0day, "App");
foreach (var certificateHash in certificateHashs)
{
webclient.AddTrustedCertificate(new Uri(SiteLink).Host, certificateHash);
}
}
public Milkie(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(id: "milkie",
name: "Milkie",
description: "Milkie.cc (ME) is private torrent tracker for 0day / general",
link: "https://milkie.cc/",
caps: new TorznabCapabilities(),
configService: configService,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationDataAPIKey())
{
Encoding = Encoding.UTF8;
Language = "en-us";
Type = "private";
AddCategoryMapping("1", TorznabCatType.Movies, "Movies");
AddCategoryMapping("2", TorznabCatType.TV, "TV");
AddCategoryMapping("3", TorznabCatType.Audio, "Music");
AddCategoryMapping("4", TorznabCatType.PCGames, "Games");
AddCategoryMapping("5", TorznabCatType.Books, "Ebook");
AddCategoryMapping("6", TorznabCatType.PC, "Apps");
AddCategoryMapping("7", TorznabCatType.XXX, "Adult");
}
public GazelleTracker(IIndexerConfigurationService configService, Utils.Clients.WebClient webClient, Logger logger, IProtectionService protectionService, string name, string desc, string link, bool supportsFreeleechTokens, bool imdbInTags = false)
: base(name: name,
description: desc,
link: link,
caps: new TorznabCapabilities(),
configService: configService,
client: webClient,
logger: logger,
p: protectionService,
configData: new ConfigurationDataBasicLogin())
{
Encoding = Encoding.UTF8;
this.supportsFreeleechTokens = supportsFreeleechTokens;
this.imdbInTags = imdbInTags;
if (supportsFreeleechTokens)
{
var useTokenItem = new ConfigurationData.BoolItem {
Value = false
};
useTokenItem.Name = "Use Freeleech Tokens when available";
configData.AddDynamic("usetoken", useTokenItem);
}
}
public DICMusic(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(id: "dicmusic",
name: "DICMusic",
description: "DICMusic is a CHINESE Private Torrent Tracker for MUSIC",
link: "https://dicmusic.club/",
caps: new TorznabCapabilities
{
SupportedMusicSearchParamsList = new List <string> {
"q", "album", "artist", "label", "year"
}
},
configService: configService,
client: wc,
logger: l,
p: ps,
supportsFreeleechTokens: true,
has2Fa: true)
{
Language = "zh-cn";
Type = "private";
AddCategoryMapping(1, TorznabCatType.Audio, "Music");
AddCategoryMapping(2, TorznabCatType.PC, "Applications");
}
public BrokenStones(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(id: "brokenstones",
name: "BrokenStones",
description: "Broken Stones is a Private site for MacOS and iOS APPS / GAMES",
link: "https://brokenstones.club/",
caps: new TorznabCapabilities(),
configService: configService,
client: wc,
logger: l,
p: ps,
supportsFreeleechTokens: true)
{
Language = "en-us";
Type = "private";
AddCategoryMapping(1, TorznabCatType.PCMac, "MacOS Apps");
AddCategoryMapping(2, TorznabCatType.PCMac, "MacOS Games");
AddCategoryMapping(3, TorznabCatType.PCMobileiOS, "iOS Apps");
AddCategoryMapping(4, TorznabCatType.PCMobileiOS, "iOS Games");
AddCategoryMapping(5, TorznabCatType.Other, "Graphics");
AddCategoryMapping(6, TorznabCatType.Audio, "Audio");
AddCategoryMapping(7, TorznabCatType.Other, "Tutorials");
AddCategoryMapping(8, TorznabCatType.Other, "Other");
}
public ShizaProject(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(id: "ShizaProject",
name: "ShizaProject",
description: "ShizaProject Tracker is a semi-private russian tracker and release group for anime",
link: "http://shiza-project.com/",
caps: new TorznabCapabilities
{
TvSearchParams = new List <TvSearchParam>
{
TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep
}
},
configService: configService,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationDataBasicLoginWithEmail())
{
Encoding = Encoding.UTF8;
Language = "ru-ru";
Type = "semi-private";
AddCategoryMapping(1, TorznabCatType.TVAnime, "Anime");
}
public AnimeTosho(IIndexerConfigurationService configService, WebClient client, Logger logger, IProtectionService ps)
: base(id: "animetosho",
name: "Anime Tosho",
description: "AnimeTosho (AT) is an automated service that provides torrent files, magnet links and DDL for all anime releases",
link: "https://animetosho.org/",
caps: new TorznabCapabilities
{
TvSearchParams = new List <TvSearchParam>
{
TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep
}
},
configService: configService,
client: client,
logger: logger,
p: ps,
configData: new ConfigurationData())
{
Encoding = Encoding.UTF8;
Language = "en-en";
Type = "public";
AddCategoryMapping(1, TorznabCatType.TVAnime);
}
protected GazelleTracker(string link, string id, string name, string description,
IIndexerConfigurationService configService, WebClient client, Logger logger,
IProtectionService p, ICacheService cs, TorznabCapabilities caps,
bool supportsFreeleechTokens, bool imdbInTags = false, bool has2Fa = false,
bool useApiKey = false, bool usePassKey = false, string instructionMessageOptional = null)
: base(id: id,
name: name,
description: description,
link: link,
caps: caps,
configService: configService,
client: client,
logger: logger,
p: p,
cacheService: cs,
configData: new ConfigurationDataGazelleTracker(
has2Fa, supportsFreeleechTokens, useApiKey, usePassKey, instructionMessageOptional))
{
Encoding = Encoding.UTF8;
this.imdbInTags = imdbInTags;
this.useApiKey = useApiKey;
this.usePassKey = usePassKey;
}
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 SelectItem(new Dictionary <string, string>
{
{ "castellano", "Castilian Spanish" },
{ "latino", "Latin American Spanish" }
})
{
Name = "Select language",
Value = "castellano"
};
configData.AddDynamic("language", language);
AddCategoryMapping(1, TorznabCatType.MoviesHD);
}
public EpubLibre(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(id: "epublibre",
name: "EpubLibre",
description: "Más libros, Más libres",
link: "https://epublibre.org/",
caps: new TorznabCapabilities
{
BookSearchParams = new List <BookSearchParam>
{
BookSearchParam.Q // TODO: add more book parameters
}
},
configService: configService,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationData())
{
Encoding = Encoding.UTF8;
Language = "es-es";
Type = "public";
AddCategoryMapping(1, TorznabCatType.BooksEbook);
}
public ThePirateBay(
IIndexerConfigurationService configService,
WebClient client,
Logger logger,
IProtectionService p
) : base(
id: "thepiratebay",
name: "The Pirate Bay",
description: "Pirate Bay (TPB) is the galaxy’s most resilient Public BitTorrent site",
link: "https://thepiratebay.org/",
caps: new TorznabCapabilities(),
configService: configService,
client: client,
logger: logger,
p: p,
configData: new ConfigurationData()
)
{
Encoding = Encoding.UTF8;
Language = "en-us";
Type = "public";
AddCategoryMappings();
}
public Yify(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(name: "YIFY",
description: "YIFY is a Public torrent site specialising in HD movies of small size",
link: "https://yifymovie.co/",
caps: new TorznabCapabilities(),
configService: configService,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationData())
{
Encoding = Encoding.GetEncoding("windows-1252");
Language = "en-us";
Type = "public";
TorznabCaps.SupportsImdbSearch = true;
webclient.requestDelay = 2.5; // 0.5 requests per second (2 causes problems)
AddCategoryMapping(1, TorznabCatType.MoviesHD, "Movies/x264/720");
AddCategoryMapping(2, TorznabCatType.MoviesHD, "Movies/x264/1080");
AddCategoryMapping(3, TorznabCatType.MoviesUHD, "Movies/x264/2160");
AddCategoryMapping(4, TorznabCatType.Movies3D, "Movies/x264/3D");
}
public SceneTime(IIndexerConfigurationService configService, WebClient w, Logger l, IProtectionService ps)
: base(name: "SceneTime",
description: "Always on time",
link: "https://www.scenetime.com/",
caps: new TorznabCapabilities(),
configService: configService,
client: w,
logger: l,
p: ps,
configData: new ConfigurationDataSceneTime())
{
Encoding = Encoding.GetEncoding("iso-8859-1");
Language = "en-us";
Type = "private";
//Movies
AddCategoryMapping(1, TorznabCatType.MoviesSD, "Movies/XviD");
AddCategoryMapping(3, TorznabCatType.MoviesDVD, "Movies/DVD-R");
AddCategoryMapping(10, TorznabCatType.XXX, "Movies/XxX");
AddCategoryMapping(47, TorznabCatType.Movies, "Movie/Packs");
AddCategoryMapping(56, TorznabCatType.Movies, "Movies/Anime");
AddCategoryMapping(57, TorznabCatType.MoviesSD, "Movies/SD");
AddCategoryMapping(59, TorznabCatType.MoviesHD, "Movies/HD");
AddCategoryMapping(61, TorznabCatType.Movies, "Movies/Classic");
AddCategoryMapping(64, TorznabCatType.Movies3D, "Movies/3D");
AddCategoryMapping(80, TorznabCatType.MoviesForeign, "Movies/Non-English");
AddCategoryMapping(81, TorznabCatType.MoviesBluRay, "Movies/BluRay");
AddCategoryMapping(82, TorznabCatType.MoviesOther, "Movies/CAM-TS");
AddCategoryMapping(102, TorznabCatType.MoviesOther, "Movies/Remux");
AddCategoryMapping(22, TorznabCatType.MoviesWEBDL, "Movies/Web-Rip/DL");
AddCategoryMapping(105, TorznabCatType.Movies, "Movies/Kids");
AddCategoryMapping(16, TorznabCatType.MoviesUHD, "Movies/4K");
AddCategoryMapping(17, TorznabCatType.MoviesBluRay, "Movies/4K bluray");
//TV
AddCategoryMapping(2, TorznabCatType.TVSD, "TV/XviD");
AddCategoryMapping(43, TorznabCatType.TV, "TV/Packs");
AddCategoryMapping(9, TorznabCatType.TVHD, "TV-HD");
AddCategoryMapping(63, TorznabCatType.TV, "TV/Classic");
AddCategoryMapping(77, TorznabCatType.TVSD, "TV/SD");
AddCategoryMapping(79, TorznabCatType.TVSport, "Sports");
AddCategoryMapping(100, TorznabCatType.TVFOREIGN, "TV/Non-English");
AddCategoryMapping(83, TorznabCatType.TVWEBDL, "TV/Web-Rip");
AddCategoryMapping(8, TorznabCatType.TVOTHER, "TV-Mobile");
AddCategoryMapping(18, TorznabCatType.TVAnime, "TV/Anime");
AddCategoryMapping(19, TorznabCatType.TVHD, "TV-x265");
// Games
AddCategoryMapping(6, TorznabCatType.PCGames, "Games/PC ISO");
AddCategoryMapping(48, TorznabCatType.ConsoleXbox, "Games/XBOX");
AddCategoryMapping(49, TorznabCatType.ConsolePSP, "Games/PSP");
AddCategoryMapping(50, TorznabCatType.ConsolePS3, "Games/PS3");
AddCategoryMapping(51, TorznabCatType.ConsoleWii, "Games/Wii");
AddCategoryMapping(55, TorznabCatType.ConsoleNDS, "Games/Nintendo DS");
AddCategoryMapping(12, TorznabCatType.ConsolePS4, "Games/Ps4");
AddCategoryMapping(13, TorznabCatType.ConsoleOther, "Games/PS1");
AddCategoryMapping(14, TorznabCatType.ConsoleOther, "Games/PS2");
AddCategoryMapping(15, TorznabCatType.ConsoleOther, "Games/Dreamcast");
// Miscellaneous
AddCategoryMapping(5, TorznabCatType.PC0day, "Apps/0DAY");
AddCategoryMapping(7, TorznabCatType.Books, "Books-Mags");
AddCategoryMapping(52, TorznabCatType.PCMac, "Mac");
AddCategoryMapping(65, TorznabCatType.BooksComics, "Books/Comic");
AddCategoryMapping(53, TorznabCatType.PC, "Appz");
AddCategoryMapping(24, TorznabCatType.PCPhoneOther, "Mobile/Appz");
// Music
AddCategoryMapping(4, TorznabCatType.Audio, "Music/Audio");
AddCategoryMapping(11, TorznabCatType.AudioVideo, "Music/Videos");
AddCategoryMapping(116, TorznabCatType.Audio, "Music/Pack");
}
public IPTorrents(IIndexerConfigurationService configService, Utils.Clients.WebClient wc, Logger l, IProtectionService ps)
: base("IPTorrents",
description: "Always a step ahead.",
link: "https://iptorrents.com/",
caps: new TorznabCapabilities
{
SupportsImdbMovieSearch = true,
SupportsImdbTVSearch = true
},
configService: configService,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationDataCookie("For best results, change the 'Torrents per page' option to 100 in the website Settings."))
{
Encoding = Encoding.UTF8;
Language = "en-us";
Type = "private";
AddCategoryMapping(72, TorznabCatType.Movies, "Movies");
AddCategoryMapping(87, TorznabCatType.Movies3D, "Movie/3D");
AddCategoryMapping(77, TorznabCatType.MoviesSD, "Movie/480p");
AddCategoryMapping(101, TorznabCatType.MoviesUHD, "Movie/4K");
AddCategoryMapping(89, TorznabCatType.MoviesHD, "Movie/BD-R");
AddCategoryMapping(90, TorznabCatType.MoviesSD, "Movie/BD-Rip");
AddCategoryMapping(96, TorznabCatType.MoviesSD, "Movie/Cam");
AddCategoryMapping(6, TorznabCatType.MoviesDVD, "Movie/DVD-R");
AddCategoryMapping(48, TorznabCatType.MoviesBluRay, "Movie/HD/Bluray");
AddCategoryMapping(54, TorznabCatType.Movies, "Movie/Kids");
AddCategoryMapping(62, TorznabCatType.MoviesSD, "Movie/MP4");
AddCategoryMapping(38, TorznabCatType.MoviesForeign, "Movie/Non-English");
AddCategoryMapping(68, TorznabCatType.Movies, "Movie/Packs");
AddCategoryMapping(20, TorznabCatType.MoviesHD, "Movie/Web-DL");
AddCategoryMapping(7, TorznabCatType.MoviesSD, "Movie/Xvid");
AddCategoryMapping(100, TorznabCatType.Movies, "Movie/x265");
AddCategoryMapping(73, TorznabCatType.TV, "TV");
AddCategoryMapping(26, TorznabCatType.TVDocumentary, "Documentaries");
AddCategoryMapping(55, TorznabCatType.TVSport, "Sports");
AddCategoryMapping(78, TorznabCatType.TVSD, "TV/480p");
AddCategoryMapping(23, TorznabCatType.TVHD, "TV/BD");
AddCategoryMapping(24, TorznabCatType.TVSD, "TV/DVD-R");
AddCategoryMapping(25, TorznabCatType.TVSD, "TV/DVD-Rip");
AddCategoryMapping(66, TorznabCatType.TVSD, "TV/Mobile");
AddCategoryMapping(82, TorznabCatType.TVFOREIGN, "TV/Non-English");
AddCategoryMapping(65, TorznabCatType.TV, "TV/Packs");
AddCategoryMapping(83, TorznabCatType.TVFOREIGN, "TV/Packs/Non-English");
AddCategoryMapping(79, TorznabCatType.TVSD, "TV/SD/x264");
AddCategoryMapping(22, TorznabCatType.TVWEBDL, "TV/Web-DL");
AddCategoryMapping(5, TorznabCatType.TVHD, "TV/x264");
AddCategoryMapping(99, TorznabCatType.TVHD, "TV/x265");
AddCategoryMapping(4, TorznabCatType.TVSD, "TV/Xvid");
AddCategoryMapping(74, TorznabCatType.Console, "Games");
AddCategoryMapping(2, TorznabCatType.ConsoleOther, "Games/Mixed");
AddCategoryMapping(47, TorznabCatType.ConsoleNDS, "Games/Nintendo DS");
AddCategoryMapping(43, TorznabCatType.PCISO, "Games/PC-ISO");
AddCategoryMapping(45, TorznabCatType.PCGames, "Games/PC-Rip");
AddCategoryMapping(39, TorznabCatType.ConsolePS3, "Games/PS2");
AddCategoryMapping(71, TorznabCatType.ConsolePS3, "Games/PS3");
AddCategoryMapping(40, TorznabCatType.ConsolePSP, "Games/PSP");
AddCategoryMapping(50, TorznabCatType.ConsoleWii, "Games/Wii");
AddCategoryMapping(44, TorznabCatType.ConsoleXbox360, "Games/Xbox-360");
AddCategoryMapping(75, TorznabCatType.Audio, "Music");
AddCategoryMapping(3, TorznabCatType.AudioMP3, "Music/Audio");
AddCategoryMapping(80, TorznabCatType.AudioLossless, "Music/Flac");
AddCategoryMapping(93, TorznabCatType.Audio, "Music/Packs");
AddCategoryMapping(37, TorznabCatType.AudioVideo, "Music/Video");
AddCategoryMapping(21, TorznabCatType.AudioVideo, "Podcast");
AddCategoryMapping(76, TorznabCatType.Other, "Miscellaneous");
AddCategoryMapping(60, TorznabCatType.TVAnime, "Anime");
AddCategoryMapping(1, TorznabCatType.PC0day, "Appz");
AddCategoryMapping(86, TorznabCatType.PC0day, "Appz/Non-English");
AddCategoryMapping(64, TorznabCatType.AudioAudiobook, "AudioBook");
AddCategoryMapping(35, TorznabCatType.Books, "Books");
AddCategoryMapping(94, TorznabCatType.BooksComics, "Comics");
AddCategoryMapping(95, TorznabCatType.BooksOther, "Educational");
AddCategoryMapping(98, TorznabCatType.Other, "Fonts");
AddCategoryMapping(69, TorznabCatType.PCMac, "Mac");
AddCategoryMapping(92, TorznabCatType.BooksMagazines, "Magazines / Newspapers");
AddCategoryMapping(58, TorznabCatType.PCPhoneOther, "Mobile");
AddCategoryMapping(36, TorznabCatType.Other, "Pics/Wallpapers");
AddCategoryMapping(88, TorznabCatType.XXX, "XXX");
AddCategoryMapping(85, TorznabCatType.XXXOther, "XXX/Magazines");
AddCategoryMapping(8, TorznabCatType.XXX, "XXX/Movie");
AddCategoryMapping(81, TorznabCatType.XXX, "XXX/Movie/0Day");
AddCategoryMapping(91, TorznabCatType.XXXPacks, "XXX/Packs");
AddCategoryMapping(84, TorznabCatType.XXXImageset, "XXX/Pics/Wallpapers");
}
public TorrentSyndikat(IIndexerConfigurationService configService, WebClient w, Logger l, IProtectionService ps)
: base(name: "Torrent-Syndikat",
description: "A German general tracker",
link: "https://torrent-syndikat.org/",
caps: new TorznabCapabilities(),
configService: configService,
client: w,
logger: l,
p: ps,
configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
{
Encoding = Encoding.UTF8;
Language = "de-de";
Type = "private";
TorznabCaps.SupportsImdbSearch = true;
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(2, TorznabCatType.PC, "Apps / Windows");
AddCategoryMapping(13, TorznabCatType.PC, "Apps / Linux");
AddCategoryMapping(4, TorznabCatType.PCMac, "Apps / MacOS");
AddCategoryMapping(6, TorznabCatType.PC, "Apps / Misc");
AddCategoryMapping(50, TorznabCatType.PCGames, "Spiele / Windows");
AddCategoryMapping(51, TorznabCatType.PCGames, "Spiele / MacOS");
AddCategoryMapping(52, TorznabCatType.PCGames, "Spiele / Linux");
AddCategoryMapping(8, TorznabCatType.ConsoleOther, "Spiele / Playstation");
AddCategoryMapping(7, TorznabCatType.ConsoleOther, "Spiele / Nintendo");
AddCategoryMapping(32, TorznabCatType.ConsoleOther, "Spiele / XBOX");
AddCategoryMapping(42, TorznabCatType.MoviesUHD, "Filme / 2160p");
AddCategoryMapping(9, TorznabCatType.MoviesHD, "Filme / 1080p");
AddCategoryMapping(20, TorznabCatType.MoviesHD, "Filme / 720p");
AddCategoryMapping(10, TorznabCatType.MoviesSD, "Filme / SD");
AddCategoryMapping(43, TorznabCatType.TVUHD, "Serien / 2160p");
AddCategoryMapping(53, TorznabCatType.TVHD, "Serien / 1080p");
AddCategoryMapping(54, TorznabCatType.TVHD, "Serien / 720p");
AddCategoryMapping(15, TorznabCatType.TVSD, "Serien / SD");
AddCategoryMapping(30, TorznabCatType.TVSport, "Serien / Sport");
AddCategoryMapping(44, TorznabCatType.TVUHD, "Serienpacks / 2160p");
AddCategoryMapping(55, TorznabCatType.TVHD, "Serienpacks / 1080p");
AddCategoryMapping(56, TorznabCatType.TVHD, "Serienpacks / 720p");
AddCategoryMapping(27, TorznabCatType.TVSD, "Serienpacks / SD");
AddCategoryMapping(24, TorznabCatType.AudioLossless, "Audio / Musik / FLAC");
AddCategoryMapping(25, TorznabCatType.AudioMP3, "Audio / Musik / MP3");
AddCategoryMapping(35, TorznabCatType.AudioOther, "Audio / Other");
AddCategoryMapping(18, TorznabCatType.AudioAudiobook, "Audio / aBooks");
AddCategoryMapping(33, TorznabCatType.AudioVideo, "Audio / Videos");
AddCategoryMapping(17, TorznabCatType.Books, "Misc / eBooks");
AddCategoryMapping(5, TorznabCatType.PCPhoneOther, "Misc / Mobile");
AddCategoryMapping(39, TorznabCatType.Other, "Misc / Bildung");
AddCategoryMapping(36, TorznabCatType.TVFOREIGN, "Englisch / Serien");
AddCategoryMapping(57, TorznabCatType.TVFOREIGN, "Englisch / Serienpacks");
AddCategoryMapping(37, TorznabCatType.MoviesForeign, "Englisch / Filme");
AddCategoryMapping(47, TorznabCatType.Books, "Englisch / eBooks");
AddCategoryMapping(48, TorznabCatType.Other, "Englisch / Bildung");
AddCategoryMapping(49, TorznabCatType.TVSport, "Englisch / Sport");
TimeZoneInfo.TransitionTime startTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 3, 0, 0), 3, 5, DayOfWeek.Sunday);
TimeZoneInfo.TransitionTime endTransition = TimeZoneInfo.TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, 4, 0, 0), 10, 5, DayOfWeek.Sunday);
TimeSpan delta = new TimeSpan(1, 0, 0);
TimeZoneInfo.AdjustmentRule adjustment = TimeZoneInfo.AdjustmentRule.CreateAdjustmentRule(new DateTime(1999, 10, 1), DateTime.MaxValue.Date, delta, startTransition, endTransition);
TimeZoneInfo.AdjustmentRule[] adjustments = { adjustment };
germanyTz = TimeZoneInfo.CreateCustomTimeZone("W. Europe Standard Time", new TimeSpan(1, 0, 0), "(GMT+01:00) W. Europe Standard Time", "W. Europe Standard Time", "W. Europe DST Time", adjustments);
}
public Myanonamouse(IIndexerConfigurationService configService, WebClient c, Logger l, IProtectionService ps)
: base(name: "MyAnonamouse",
description: "Friendliness, Warmth and Sharing",
link: "https://www.myanonamouse.net/",
caps: new TorznabCapabilities(TorznabCatType.Books,
TorznabCatType.AudioAudiobook,
TorznabCatType.BooksComics,
TorznabCatType.BooksEbook,
TorznabCatType.BooksMagazines,
TorznabCatType.BooksTechnical),
configService: configService,
client: c,
logger: l,
p: ps,
configData: new ConfigurationDataBasicLogin())
{
Encoding = Encoding.UTF8;
Language = "en-us";
Type = "private";
AddCategoryMapping("61", TorznabCatType.BooksComics);
AddCategoryMapping("91", TorznabCatType.BooksTechnical);
AddCategoryMapping("80", TorznabCatType.BooksTechnical);
AddCategoryMapping("79", TorznabCatType.BooksMagazines);
AddCategoryMapping("39", TorznabCatType.AudioAudiobook);
AddCategoryMapping("49", TorznabCatType.AudioAudiobook);
AddCategoryMapping("50", TorznabCatType.AudioAudiobook);
AddCategoryMapping("83", TorznabCatType.AudioAudiobook);
AddCategoryMapping("51", TorznabCatType.AudioAudiobook);
AddCategoryMapping("97", TorznabCatType.AudioAudiobook);
AddCategoryMapping("40", TorznabCatType.AudioAudiobook);
AddCategoryMapping("41", TorznabCatType.AudioAudiobook);
AddCategoryMapping("106", TorznabCatType.AudioAudiobook);
AddCategoryMapping("42", TorznabCatType.AudioAudiobook);
AddCategoryMapping("52", TorznabCatType.AudioAudiobook);
AddCategoryMapping("98", TorznabCatType.AudioAudiobook);
AddCategoryMapping("54", TorznabCatType.AudioAudiobook);
AddCategoryMapping("55", TorznabCatType.AudioAudiobook);
AddCategoryMapping("43", TorznabCatType.AudioAudiobook);
AddCategoryMapping("99", TorznabCatType.AudioAudiobook);
AddCategoryMapping("84", TorznabCatType.AudioAudiobook);
AddCategoryMapping("44", TorznabCatType.AudioAudiobook);
AddCategoryMapping("56", TorznabCatType.AudioAudiobook);
AddCategoryMapping("137", TorznabCatType.AudioAudiobook);
AddCategoryMapping("45", TorznabCatType.AudioAudiobook);
AddCategoryMapping("57", TorznabCatType.AudioAudiobook);
AddCategoryMapping("85", TorznabCatType.AudioAudiobook);
AddCategoryMapping("87", TorznabCatType.AudioAudiobook);
AddCategoryMapping("119", TorznabCatType.AudioAudiobook);
AddCategoryMapping("88", TorznabCatType.AudioAudiobook);
AddCategoryMapping("58", TorznabCatType.AudioAudiobook);
AddCategoryMapping("59", TorznabCatType.AudioAudiobook);
AddCategoryMapping("46", TorznabCatType.AudioAudiobook);
AddCategoryMapping("47", TorznabCatType.AudioAudiobook);
AddCategoryMapping("53", TorznabCatType.AudioAudiobook);
AddCategoryMapping("89", TorznabCatType.AudioAudiobook);
AddCategoryMapping("100", TorznabCatType.AudioAudiobook);
AddCategoryMapping("108", TorznabCatType.AudioAudiobook);
AddCategoryMapping("48", TorznabCatType.AudioAudiobook);
AddCategoryMapping("111", TorznabCatType.AudioAudiobook);
AddCategoryMapping("60", TorznabCatType.BooksEbook);
AddCategoryMapping("71", TorznabCatType.BooksEbook);
AddCategoryMapping("72", TorznabCatType.BooksEbook);
AddCategoryMapping("90", TorznabCatType.BooksEbook);
AddCategoryMapping("73", TorznabCatType.BooksEbook);
AddCategoryMapping("101", TorznabCatType.BooksEbook);
AddCategoryMapping("62", TorznabCatType.BooksEbook);
AddCategoryMapping("63", TorznabCatType.BooksEbook);
AddCategoryMapping("107", TorznabCatType.BooksEbook);
AddCategoryMapping("64", TorznabCatType.BooksEbook);
AddCategoryMapping("74", TorznabCatType.BooksEbook);
AddCategoryMapping("102", TorznabCatType.BooksEbook);
AddCategoryMapping("76", TorznabCatType.BooksEbook);
AddCategoryMapping("77", TorznabCatType.BooksEbook);
AddCategoryMapping("65", TorznabCatType.BooksEbook);
AddCategoryMapping("103", TorznabCatType.BooksEbook);
AddCategoryMapping("115", TorznabCatType.BooksEbook);
AddCategoryMapping("66", TorznabCatType.BooksEbook);
AddCategoryMapping("78", TorznabCatType.BooksEbook);
AddCategoryMapping("138", TorznabCatType.BooksEbook);
AddCategoryMapping("67", TorznabCatType.BooksEbook);
AddCategoryMapping("92", TorznabCatType.BooksEbook);
AddCategoryMapping("118", TorznabCatType.BooksEbook);
AddCategoryMapping("94", TorznabCatType.BooksEbook);
AddCategoryMapping("120", TorznabCatType.BooksEbook);
AddCategoryMapping("95", TorznabCatType.BooksEbook);
AddCategoryMapping("81", TorznabCatType.BooksEbook);
AddCategoryMapping("82", TorznabCatType.BooksEbook);
AddCategoryMapping("68", TorznabCatType.BooksEbook);
AddCategoryMapping("69", TorznabCatType.BooksEbook);
AddCategoryMapping("75", TorznabCatType.BooksEbook);
AddCategoryMapping("96", TorznabCatType.BooksEbook);
AddCategoryMapping("104", TorznabCatType.BooksEbook);
AddCategoryMapping("109", TorznabCatType.BooksEbook);
AddCategoryMapping("70", TorznabCatType.BooksEbook);
AddCategoryMapping("112", TorznabCatType.BooksEbook);
}
protected BaseCachingWebIndexer(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)
{
}
// minimal constructor used by e.g. cardigann generic indexer
protected BaseWebIndexer(IIndexerConfigurationService configService, WebClient client, Logger logger, IProtectionService p)
: base("", "/", "", configService, logger, null, p)
{
this.webclient = client;
}
public Xthor(IIndexerConfigurationService configService, Utils.Clients.WebClient w, Logger l, IProtectionService ps)
: base(id: "xthor",
name: "Xthor",
description: "General French Private Tracker",
link: "https://xthor.tk/",
caps: new TorznabCapabilities(),
configService: configService,
client: w,
logger: l,
p: ps,
downloadBase: "https://xthor.tk/download.php?torrent=",
configData: new ConfigurationDataXthor())
{
Encoding = Encoding.UTF8;
Language = "fr-fr";
Type = "private";
// Movies
AddCategoryMapping(118, TorznabCatType.MoviesBluRay, "UHD FULL BLURAY");
AddCategoryMapping(119, TorznabCatType.MoviesBluRay, "UHD BLURAY REMUX");
AddCategoryMapping(107, TorznabCatType.MoviesUHD, "UHD 2160P X265");
AddCategoryMapping(1, TorznabCatType.MoviesBluRay, "FULL BLURAY");
AddCategoryMapping(2, TorznabCatType.MoviesBluRay, "BLURAY REMUX");
AddCategoryMapping(100, TorznabCatType.MoviesHD, "HD 1080P X265");
AddCategoryMapping(4, TorznabCatType.MoviesHD, "HD 1080P X264");
AddCategoryMapping(5, TorznabCatType.MoviesHD, "HD 720P X264");
AddCategoryMapping(7, TorznabCatType.MoviesSD, "SD X264");
AddCategoryMapping(8, TorznabCatType.MoviesDVD, "FULL DVD");
AddCategoryMapping(3, TorznabCatType.Movies3D, "3D");
AddCategoryMapping(6, TorznabCatType.MoviesSD, "XVID");
AddCategoryMapping(122, TorznabCatType.MoviesHD, "HDTV");
AddCategoryMapping(94, TorznabCatType.MoviesWEBDL, "WEBDL");
AddCategoryMapping(95, TorznabCatType.MoviesWEBDL, "WEBRIP");
AddCategoryMapping(12, TorznabCatType.TVDocumentary, "DOCS");
AddCategoryMapping(33, TorznabCatType.MoviesOther, "SPECTACLE");
AddCategoryMapping(31, TorznabCatType.MoviesOther, "ANIMATION");
AddCategoryMapping(9, TorznabCatType.MoviesOther, "VOSTFR");
// Series
AddCategoryMapping(104, TorznabCatType.TVOTHER, "BLURAY");
AddCategoryMapping(13, TorznabCatType.TVOTHER, "PACK VF");
AddCategoryMapping(15, TorznabCatType.TVHD, "HD VF");
AddCategoryMapping(14, TorznabCatType.TVSD, "SD VF");
AddCategoryMapping(98, TorznabCatType.TVOTHER, "PACK VOSTFR");
AddCategoryMapping(17, TorznabCatType.TVHD, "HD VF VOSTFR");
AddCategoryMapping(16, TorznabCatType.TVSD, "SD VF VOSTFR");
AddCategoryMapping(101, TorznabCatType.TVAnime, "PACK ANIME");
AddCategoryMapping(32, TorznabCatType.TVAnime, "ANIME VF");
AddCategoryMapping(110, TorznabCatType.TVAnime, "ANIME VOSTFR");
AddCategoryMapping(123, TorznabCatType.TVOTHER, "ANIMATION");
AddCategoryMapping(109, TorznabCatType.TVDocumentary, "DOCS");
AddCategoryMapping(30, TorznabCatType.TVOTHER, "EMISSIONS");
AddCategoryMapping(34, TorznabCatType.TVOTHER, "SPORT");
// Music
AddCategoryMapping(20, TorznabCatType.AudioVideo, "CONCERT");
// Books
AddCategoryMapping(24, TorznabCatType.BooksEbook, "ENOOKS NOVEL");
AddCategoryMapping(96, TorznabCatType.BooksMagazines, "EBOOKS MAGAZINES");
AddCategoryMapping(116, TorznabCatType.BooksEbook, "EBOOKS NOVEL JUNIOR");
AddCategoryMapping(99, TorznabCatType.BooksOther, "EBOOKS BD");
AddCategoryMapping(102, TorznabCatType.BooksComics, "EBOOKS COMICS");
AddCategoryMapping(103, TorznabCatType.BooksOther, "EBOOKS MANGA");
// SOFTWARE
AddCategoryMapping(25, TorznabCatType.PCGames, "PC GAMES");
AddCategoryMapping(27, TorznabCatType.ConsolePS3, "PS GAMES");
AddCategoryMapping(111, TorznabCatType.PCMac, "MAC GAMES");
AddCategoryMapping(112, TorznabCatType.PC, "LINUX GAMES");
AddCategoryMapping(26, TorznabCatType.ConsoleXbox360, "XBOX GAMES");
AddCategoryMapping(28, TorznabCatType.ConsoleWii, "WII GAMES");
AddCategoryMapping(29, TorznabCatType.ConsoleNDS, "NDS GAMES");
AddCategoryMapping(117, TorznabCatType.PC, "ROM");
AddCategoryMapping(21, TorznabCatType.PC, "PC SOFTWARE");
AddCategoryMapping(22, TorznabCatType.PCMac, "MAC SOFTWARE");
AddCategoryMapping(23, TorznabCatType.PCPhoneAndroid, "ANDROID");
// XxX
AddCategoryMapping(36, TorznabCatType.XXX, "XxX / Films");
AddCategoryMapping(105, TorznabCatType.XXX, "XxX / Séries");
AddCategoryMapping(114, TorznabCatType.XXX, "XxX / Lesbiennes");
AddCategoryMapping(115, TorznabCatType.XXX, "XxX / Gays");
AddCategoryMapping(113, TorznabCatType.XXX, "XxX / Hentai");
AddCategoryMapping(120, TorznabCatType.XXX, "XxX / Magazines");
}
public TorrentHeaven(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(name: "TorrentHeaven",
description: "A German general tracker.",
link: "https://torrentheaven.myfqdn.info/",
caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
configService: configService,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationDataCaptchaLogin())
{
Encoding = Encoding.GetEncoding("iso-8859-1");
Language = "de-de";
Type = "private";
AddCategoryMapping(1, TorznabCatType.PCGames); // GAMES/PC
AddCategoryMapping(3, TorznabCatType.Console); // GAMES/Sonstige
AddCategoryMapping(59, TorznabCatType.ConsolePS4); // GAMES/PlayStation
AddCategoryMapping(60, TorznabCatType.ConsolePSP); // GAMES/PSP
AddCategoryMapping(63, TorznabCatType.ConsoleWii); // GAMES/Wii
AddCategoryMapping(67, TorznabCatType.ConsoleXbox360); // GAMES/XBOX 360
AddCategoryMapping(68, TorznabCatType.PCPhoneOther); // GAMES/PDA / Handy
AddCategoryMapping(72, TorznabCatType.ConsoleNDS); // GAMES/NDS
AddCategoryMapping(7, TorznabCatType.MoviesDVD); // MOVIES/DVD
AddCategoryMapping(8, TorznabCatType.MoviesSD); // MOVIES/SD
AddCategoryMapping(37, TorznabCatType.MoviesDVD); // MOVIES/DVD Spezial
AddCategoryMapping(41, TorznabCatType.MoviesForeign); // MOVIES/International
AddCategoryMapping(101, TorznabCatType.MoviesHD); // MOVIES/720p
AddCategoryMapping(102, TorznabCatType.MoviesHD); // MOVIES/1080p
AddCategoryMapping(103, TorznabCatType.MoviesHD); // MOVIES/AVCHD
AddCategoryMapping(104, TorznabCatType.MoviesBluRay); // MOVIES/Bluray
AddCategoryMapping(106, TorznabCatType.Movies3D); // MOVIES/3D
AddCategoryMapping(14, TorznabCatType.Audio); // AUDIO/Musik
AddCategoryMapping(15, TorznabCatType.AudioAudiobook); // AUDIO/Hörbücher
AddCategoryMapping(16, TorznabCatType.AudioAudiobook); // AUDIO/Hörspiele
AddCategoryMapping(36, TorznabCatType.AudioLossless); // AUDIO/Flac
AddCategoryMapping(42, TorznabCatType.AudioOther); // AUDIO/Soundtracks
AddCategoryMapping(58, TorznabCatType.AudioVideo); // AUDIO/Musikvideos
AddCategoryMapping(18, TorznabCatType.TVSD); // TV/Serien SD
AddCategoryMapping(19, TorznabCatType.TVHD); // TV/Serien HD 720p
AddCategoryMapping(20, TorznabCatType.TVHD); // TV/Serien HD 1080p
AddCategoryMapping(49, TorznabCatType.TVSD); // TV/Serien DVD
AddCategoryMapping(51, TorznabCatType.TVDocumentary); // TV/Doku SD
AddCategoryMapping(52, TorznabCatType.TVDocumentary); // TV/Doku HD
AddCategoryMapping(53, TorznabCatType.TV); // TV/Serien Complete Packs
AddCategoryMapping(54, TorznabCatType.TVSport); // TV/Sport
AddCategoryMapping(66, TorznabCatType.TVFOREIGN); // TV/International
AddCategoryMapping(22, TorznabCatType.Books); // MISC/EBooks
AddCategoryMapping(24, TorznabCatType.Other); // MISC/Sonstiges
AddCategoryMapping(25, TorznabCatType.Other); // MISC/Tonspuren
AddCategoryMapping(108, TorznabCatType.TVAnime); // MISC/Anime
AddCategoryMapping(28, TorznabCatType.PC); // APPLICATIONS/PC
AddCategoryMapping(29, TorznabCatType.PCPhoneOther); // APPLICATIONS/Mobile
AddCategoryMapping(30, TorznabCatType.PC); // APPLICATIONS/Sonstige
AddCategoryMapping(70, TorznabCatType.PC); // APPLICATIONS/Linux
AddCategoryMapping(71, TorznabCatType.PCMac); // APPLICATIONS/Mac
webclient.AddTrustedCertificate(new Uri(SiteLink).Host, certificateHash);
}
public RarBG(IIndexerConfigurationService configService, Utils.Clients.WebClient wc, Logger l, IProtectionService ps)
: 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,
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();
}
public XSpeeds(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(id: "xspeeds",
name: "XSpeeds",
description: "XSpeeds (XS) is a Private Torrent Tracker for MOVIES / TV / GENERAL",
link: "https://www.xspeeds.eu/",
caps: new TorznabCapabilities
{
SupportsImdbMovieSearch = true
// SupportsImdbTVSearch = true (supported by the site but disabled due to #8107)
},
configService: configService,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationDataBasicLoginWithRSSAndDisplay())
{
Encoding = Encoding.UTF8;
Language = "en-us";
Type = "private";
AddCategoryMapping(92, TorznabCatType.MoviesUHD, "4K Movies");
AddCategoryMapping(91, TorznabCatType.TVUHD, "4K TV");
AddCategoryMapping(94, TorznabCatType.TVUHD, "4K TV Boxsets");
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(95, TorznabCatType.PCMac, "Mac Games");
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("4K Movies", TorznabCatType.MoviesUHD);
AddCategoryMapping("4K TV", TorznabCatType.TVUHD);
AddCategoryMapping("4K TV Boxsets", TorznabCatType.TVUHD);
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);
}
public TorrentSeeds(IIndexerConfigurationService configService, Utils.Clients.WebClient wc, Logger l,
IProtectionService ps, ICacheService cs)
: base(id: "torrentseeds",
name: "TorrentSeeds",
description: "TorrentSeeds is a Private site for MOVIES / TV / GENERAL",
link: "https://torrentseeds.org/",
caps: new TorznabCapabilities
{
TvSearchParams = new List <TvSearchParam>
{
TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep
},
MovieSearchParams = new List <MovieSearchParam>
{
MovieSearchParam.Q
},
MusicSearchParams = new List <MusicSearchParam>
{
MusicSearchParam.Q
},
BookSearchParams = new List <BookSearchParam>
{
BookSearchParam.Q
}
},
configService: configService,
client: wc,
logger: l,
p: ps,
cacheService: cs,
configData: new ConfigurationDataBasicLoginWithRSSAndDisplay("For best results, change the <b>Torrents per page:</b> setting to <b>100</b> on your account profile."))
{
Encoding = Encoding.UTF8;
Language = "en-US";
Type = "private";
// NOTE: Tracker Category Description must match Type/Category in details page!
AddCategoryMapping(37, TorznabCatType.TVAnime, "Anime/HD");
AddCategoryMapping(9, TorznabCatType.TVAnime, "Anime/SD");
AddCategoryMapping(72, TorznabCatType.TVAnime, "Anime/UHD");
AddCategoryMapping(13, TorznabCatType.PC0day, "Apps/0DAY");
AddCategoryMapping(27, TorznabCatType.Books, "Apps/Bookware");
AddCategoryMapping(1, TorznabCatType.PCISO, "Apps/ISO");
AddCategoryMapping(73, TorznabCatType.AudioAudiobook, "Music/Audiobooks");
AddCategoryMapping(47, TorznabCatType.ConsoleOther, "Console/NSW");
AddCategoryMapping(8, TorznabCatType.ConsolePS3, "Console/PS3");
AddCategoryMapping(30, TorznabCatType.ConsolePS4, "Console/PS4");
AddCategoryMapping(71, TorznabCatType.ConsolePS4, "Console/PS5");
AddCategoryMapping(7, TorznabCatType.ConsolePSP, "Console/PSP");
AddCategoryMapping(70, TorznabCatType.ConsolePSVita, "Console/PSV");
AddCategoryMapping(16, TorznabCatType.ConsoleWii, "Console/WII");
AddCategoryMapping(29, TorznabCatType.ConsoleWiiU, "Console/WIIU");
AddCategoryMapping(17, TorznabCatType.ConsoleXBox360, "Console/XBOX360");
AddCategoryMapping(32, TorznabCatType.BooksEBook, "E-books");
AddCategoryMapping(63, TorznabCatType.ConsoleOther, "Games/DOX");
AddCategoryMapping(2, TorznabCatType.PCGames, "Games/ISO");
AddCategoryMapping(12, TorznabCatType.PCGames, "Games/PC Rips");
AddCategoryMapping(31, TorznabCatType.MoviesBluRay, "Movies/Bluray");
AddCategoryMapping(50, TorznabCatType.MoviesBluRay, "Movies/Bluray-UHD");
AddCategoryMapping(3, TorznabCatType.MoviesDVD, "Movies/DVDR");
AddCategoryMapping(69, TorznabCatType.MoviesForeign, "Movies/DVDR-Foreign");
AddCategoryMapping(19, TorznabCatType.MoviesHD, "Movies/HD");
AddCategoryMapping(39, TorznabCatType.MoviesForeign, "Movies/HD-Foreign");
AddCategoryMapping(74, TorznabCatType.MoviesHD, "Movies/Remuxes");
AddCategoryMapping(25, TorznabCatType.MoviesSD, "Movies/SD");
AddCategoryMapping(62, TorznabCatType.MoviesForeign, "Movies/SD-Foreign");
AddCategoryMapping(49, TorznabCatType.MoviesUHD, "Movies/UHD");
AddCategoryMapping(76, TorznabCatType.MoviesForeign, "Movies/UHD-Foreign");
AddCategoryMapping(33, TorznabCatType.AudioLossless, "Music/FLAC");
AddCategoryMapping(89, TorznabCatType.AudioVideo, "Music/MBluRay");
AddCategoryMapping(28, TorznabCatType.AudioVideo, "Music/MBluRay-Rips");
AddCategoryMapping(34, TorznabCatType.AudioVideo, "Music/MDVDR");
AddCategoryMapping(4, TorznabCatType.AudioMP3, "Music/MP3");
AddCategoryMapping(20, TorznabCatType.AudioVideo, "Music/MVID");
AddCategoryMapping(77, TorznabCatType.TVAnime, "Anime/Packs");
AddCategoryMapping(78, TorznabCatType.BooksEBook, "Books/Packs");
AddCategoryMapping(80, TorznabCatType.MoviesHD, "Movies/HD-Packs");
AddCategoryMapping(81, TorznabCatType.MoviesHD, "Movies/Remux-Packs");
AddCategoryMapping(79, TorznabCatType.MoviesSD, "Movies/SD-Packs");
AddCategoryMapping(68, TorznabCatType.Audio, "Music/Packs");
AddCategoryMapping(67, TorznabCatType.TVHD, "TV/HD-Packs");
AddCategoryMapping(82, TorznabCatType.TVHD, "TV/Remux-Packs");
AddCategoryMapping(65, TorznabCatType.TVSD, "TV/SD-Packs");
AddCategoryMapping(84, TorznabCatType.TVUHD, "TV/UHD-Packs");
AddCategoryMapping(85, TorznabCatType.XXX, "XXX/Packs");
AddCategoryMapping(23, TorznabCatType.TVSD, "TV/DVDR");
AddCategoryMapping(26, TorznabCatType.TVHD, "TV/HD");
AddCategoryMapping(64, TorznabCatType.TVForeign, "TV/HD-Foreign");
AddCategoryMapping(11, TorznabCatType.TVHD, "TV/HD-Retail");
AddCategoryMapping(36, TorznabCatType.TVSport, "TV/HD-Sport");
AddCategoryMapping(18, TorznabCatType.TVSD, "TV/SD");
AddCategoryMapping(86, TorznabCatType.TVForeign, "TV/SD-Foreign");
AddCategoryMapping(24, TorznabCatType.TVSD, "TV/SD-Retail");
AddCategoryMapping(35, TorznabCatType.TVSport, "TV/SD-Sport");
AddCategoryMapping(61, TorznabCatType.TVUHD, "TV/UHD");
AddCategoryMapping(87, TorznabCatType.TVForeign, "TV/UHD-Foreign");
AddCategoryMapping(53, TorznabCatType.XXX, "XXX/HD");
AddCategoryMapping(88, TorznabCatType.XXXImageSet, "XXX/Image-Sets");
AddCategoryMapping(57, TorznabCatType.XXX, "XXX/Paysite");
AddCategoryMapping(6, TorznabCatType.XXXSD, "XXX/SD");
}
public ThePirateBay(IIndexerConfigurationService configService, WebClient client, Logger logger,
IProtectionService ps, ICacheService cs) : base(
id: "thepiratebay",
name: "The Pirate Bay",
description: "Pirate Bay (TPB) is the galaxy’s most resilient Public BitTorrent site",
link: "https://thepiratebay.org/",
caps: new TorznabCapabilities
{
TvSearchParams = new List <TvSearchParam>
{
TvSearchParam.Q, TvSearchParam.Season, TvSearchParam.Ep
},
MovieSearchParams = new List <MovieSearchParam>
{
MovieSearchParam.Q
},
MusicSearchParams = new List <MusicSearchParam>
{
MusicSearchParam.Q
},
BookSearchParams = new List <BookSearchParam>
{
BookSearchParam.Q
}
},
configService: configService,
client: client,
logger: logger,
p: ps,
cacheService: cs,
configData: new ConfigurationData()
)
{
Encoding = Encoding.UTF8;
Language = "en-us";
Type = "public";
// Audio
AddCategoryMapping(100, TorznabCatType.Audio, "Audio");
AddCategoryMapping(101, TorznabCatType.Audio, "Music");
AddCategoryMapping(102, TorznabCatType.AudioAudiobook, "Audio Books");
AddCategoryMapping(103, TorznabCatType.Audio, "Sound Clips");
AddCategoryMapping(104, TorznabCatType.AudioLossless, "FLAC");
AddCategoryMapping(199, TorznabCatType.AudioOther, "Audio Other");
// Video
AddCategoryMapping(200, TorznabCatType.Movies, "Video");
AddCategoryMapping(201, TorznabCatType.Movies, "Movies");
AddCategoryMapping(202, TorznabCatType.Movies, "Movies");
AddCategoryMapping(203, TorznabCatType.AudioVideo, "Music Videos");
AddCategoryMapping(204, TorznabCatType.MoviesOther, "Movie Clips");
AddCategoryMapping(205, TorznabCatType.TV, "TV");
AddCategoryMapping(206, TorznabCatType.TVOther, "Handheld");
AddCategoryMapping(207, TorznabCatType.MoviesHD, "HD - Movies");
AddCategoryMapping(208, TorznabCatType.TVHD, "HD - TV shows");
AddCategoryMapping(209, TorznabCatType.Movies3D, "3D");
AddCategoryMapping(299, TorznabCatType.MoviesOther, "Video Other");
// Applications
AddCategoryMapping(300, TorznabCatType.PC, "Applications");
AddCategoryMapping(301, TorznabCatType.PC, "Windows");
AddCategoryMapping(302, TorznabCatType.PCMac, "Mac");
AddCategoryMapping(303, TorznabCatType.PC, "UNIX");
AddCategoryMapping(304, TorznabCatType.PCMobileOther, "Handheld");
AddCategoryMapping(305, TorznabCatType.PCMobileiOS, "IOS (iPad/iPhone)");
AddCategoryMapping(306, TorznabCatType.PCMobileAndroid, "Android");
AddCategoryMapping(399, TorznabCatType.PC, "Other OS");
// Games
AddCategoryMapping(400, TorznabCatType.Console, "Games");
AddCategoryMapping(401, TorznabCatType.PCGames, "PC");
AddCategoryMapping(402, TorznabCatType.PCMac, "Mac");
AddCategoryMapping(403, TorznabCatType.ConsolePS4, "PSx");
AddCategoryMapping(404, TorznabCatType.ConsoleXBox, "XBOX360");
AddCategoryMapping(405, TorznabCatType.ConsoleWii, "Wii");
AddCategoryMapping(406, TorznabCatType.ConsoleOther, "Handheld");
AddCategoryMapping(407, TorznabCatType.ConsoleOther, "IOS (iPad/iPhone)");
AddCategoryMapping(408, TorznabCatType.ConsoleOther, "Android");
AddCategoryMapping(499, TorznabCatType.ConsoleOther, "Games Other");
// P**n
AddCategoryMapping(500, TorznabCatType.XXX, "P**n");
AddCategoryMapping(501, TorznabCatType.XXX, "Movies");
AddCategoryMapping(502, TorznabCatType.XXXDVD, "Movies DVDR");
AddCategoryMapping(503, TorznabCatType.XXXImageSet, "Pictures");
AddCategoryMapping(504, TorznabCatType.XXX, "Games");
AddCategoryMapping(505, TorznabCatType.XXX, "HD - Movies");
AddCategoryMapping(506, TorznabCatType.XXX, "Movie Clips");
AddCategoryMapping(599, TorznabCatType.XXXOther, "P**n other");
// Other
AddCategoryMapping(600, TorznabCatType.Other, "Other");
AddCategoryMapping(601, TorznabCatType.Books, "E-books");
AddCategoryMapping(602, TorznabCatType.BooksComics, "Comics");
AddCategoryMapping(603, TorznabCatType.Books, "Pictures");
AddCategoryMapping(604, TorznabCatType.Books, "Covers");
AddCategoryMapping(605, TorznabCatType.Books, "Physibles");
AddCategoryMapping(699, TorznabCatType.BooksOther, "Other Other");
}
public TorrentLeech(IIndexerConfigurationService configService, IWebClient wc, Logger l, IProtectionService ps)
: base(name: "TorrentLeech",
description: "This is what happens when you seed",
link: "https://www.torrentleech.org/",
caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
configService: configService,
client: wc,
logger: l,
p: ps,
downloadBase: "https://www.torrentleech.org/download/",
configData: new ConfigurationDataBasicLogin("For best results, change the 'Default Number of Torrents per Page' setting to the maximum in your profile on the TorrentLeech webpage."))
{
Encoding = Encoding.GetEncoding("iso-8859-1");
Language = "en-us";
Type = "private";
AddCategoryMapping(8, TorznabCatType.MoviesSD); // cam
AddCategoryMapping(9, TorznabCatType.MoviesSD); //ts
AddCategoryMapping(10, TorznabCatType.MoviesSD); // Sceener
AddCategoryMapping(11, TorznabCatType.MoviesSD);
AddCategoryMapping(12, TorznabCatType.MoviesSD);
AddCategoryMapping(13, TorznabCatType.MoviesHD);
AddCategoryMapping(14, TorznabCatType.MoviesHD);
AddCategoryMapping(15, TorznabCatType.Movies); // Boxsets
AddCategoryMapping(29, TorznabCatType.TVDocumentary);
AddCategoryMapping(41, TorznabCatType.MoviesHD, "4K Upscaled");
AddCategoryMapping(47, TorznabCatType.MoviesHD, "Real 4K UltraHD HDR");
AddCategoryMapping(36, TorznabCatType.MoviesForeign);
AddCategoryMapping(37, TorznabCatType.MoviesWEBDL);
AddCategoryMapping(43, TorznabCatType.MoviesSD, "Movies/HDRip");
AddCategoryMapping(26, TorznabCatType.TVSD);
AddCategoryMapping(27, TorznabCatType.TV); // Boxsets
AddCategoryMapping(32, TorznabCatType.TVHD);
AddCategoryMapping(44, TorznabCatType.TVFOREIGN, "TV/Foreign");
AddCategoryMapping(17, TorznabCatType.PCGames);
AddCategoryMapping(18, TorznabCatType.ConsoleXbox);
AddCategoryMapping(19, TorznabCatType.ConsoleXbox360);
AddCategoryMapping(40, TorznabCatType.ConsoleXbox, "Games/XBOXONE");
AddCategoryMapping(20, TorznabCatType.ConsolePS3); // PS2
AddCategoryMapping(21, TorznabCatType.ConsolePS3);
AddCategoryMapping(22, TorznabCatType.ConsolePSP);
AddCategoryMapping(28, TorznabCatType.ConsoleWii);
AddCategoryMapping(30, TorznabCatType.ConsoleNDS);
AddCategoryMapping(39, TorznabCatType.ConsolePS4);
AddCategoryMapping(42, TorznabCatType.PCMac, "Games/Mac");
AddCategoryMapping(16, TorznabCatType.AudioVideo);
AddCategoryMapping(31, TorznabCatType.Audio);
AddCategoryMapping(34, TorznabCatType.TVAnime);
AddCategoryMapping(35, TorznabCatType.TV); // Cartoons
AddCategoryMapping(5, TorznabCatType.Books);
AddCategoryMapping(45, TorznabCatType.BooksEbook, "Books/EBooks");
AddCategoryMapping(46, TorznabCatType.BooksComics, "Books/Comics");
AddCategoryMapping(23, TorznabCatType.PCISO);
AddCategoryMapping(24, TorznabCatType.PCMac);
AddCategoryMapping(25, TorznabCatType.PCPhoneOther);
AddCategoryMapping(33, TorznabCatType.PC0day);
AddCategoryMapping(38, TorznabCatType.Other, "Education");
}
public BitSoup(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(name: "BitSoup",
description: "SoupieBits",
link: "https://www.bitsoup.me/",
caps: TorznabUtil.CreateDefaultTorznabTVCaps(),
configService: configService,
client: wc,
logger: l,
p: ps,
configData: new ConfigurationDataBasicLogin())
{
Encoding = Encoding.UTF8;
Language = "en-us";
Type = "private";
//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);
}
public NewRealWorld(IIndexerConfigurationService configService, WebClient wc, Logger l, IProtectionService ps)
: base(name: "New Real World",
description: "A German general tracker.",
link: "https://nrw-tracker.eu/",
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";
AddCategoryMapping(39, TorznabCatType.TVAnime); // Anime: HD|1080p
AddCategoryMapping(38, TorznabCatType.TVAnime); // Anime: HD|720p
AddCategoryMapping(1, TorznabCatType.TVAnime); // Anime: SD
AddCategoryMapping(7, TorznabCatType.PCPhoneOther); // Appz: Handy-PDA
AddCategoryMapping(36, TorznabCatType.PCMac); // Appz: Mac
AddCategoryMapping(18, TorznabCatType.PC); // Appz: Sonstiges
AddCategoryMapping(17, TorznabCatType.PC); // Appz: Win
AddCategoryMapping(15, TorznabCatType.Audio); // Audio: DVD-R
AddCategoryMapping(49, TorznabCatType.AudioLossless); // Audio: Flac
AddCategoryMapping(30, TorznabCatType.AudioAudiobook); // Audio: Hörspiele
AddCategoryMapping(14, TorznabCatType.AudioMP3); // Audio: MP3
AddCategoryMapping(22, TorznabCatType.AudioVideo); // Audio: Videoclip
AddCategoryMapping(19, TorznabCatType.Other); // Diverses: Sonstiges
AddCategoryMapping(43, TorznabCatType.TVDocumentary); // Dokus: HD
AddCategoryMapping(2, TorznabCatType.TVDocumentary); // Dokus: SD
AddCategoryMapping(3, TorznabCatType.Books); // Ebooks: Bücher
AddCategoryMapping(52, TorznabCatType.BooksComics); // Ebooks: Comics
AddCategoryMapping(53, TorznabCatType.BooksMagazines); // Ebooks: Magazine
AddCategoryMapping(55, TorznabCatType.BooksOther); // Ebooks: XXX
AddCategoryMapping(54, TorznabCatType.BooksOther); // Ebooks: Zeitungen
AddCategoryMapping(47, TorznabCatType.PCPhoneOther); // Games: Andere
AddCategoryMapping(32, TorznabCatType.PCMac); // Games: Mac
AddCategoryMapping(41, TorznabCatType.ConsoleNDS); // Games: NDS/3DS
AddCategoryMapping(4, TorznabCatType.PCGames); // Games: PC
AddCategoryMapping(5, TorznabCatType.ConsolePS3); // Games: PS2
AddCategoryMapping(9, TorznabCatType.ConsolePS3); // Games: PS3
AddCategoryMapping(6, TorznabCatType.ConsolePSP); // Games: PSP
AddCategoryMapping(28, TorznabCatType.ConsoleWii); // Games: Wii
AddCategoryMapping(31, TorznabCatType.ConsoleXbox); // Games: XboX
AddCategoryMapping(51, TorznabCatType.Movies3D); // Movies: 3D
AddCategoryMapping(37, TorznabCatType.MoviesBluRay); // Movies: BluRay
AddCategoryMapping(25, TorznabCatType.MoviesHD); // Movies: HD|1080p
AddCategoryMapping(29, TorznabCatType.MoviesHD); // Movies: HD|720p
AddCategoryMapping(11, TorznabCatType.MoviesDVD); // Movies: SD|DVD-R
AddCategoryMapping(8, TorznabCatType.MoviesSD); // Movies: SD|x264
AddCategoryMapping(13, TorznabCatType.MoviesSD); // Movies: SD|XviD
AddCategoryMapping(40, TorznabCatType.MoviesForeign); // Movies: US Movies
AddCategoryMapping(33, TorznabCatType.TV); // Serien: DVD-R
AddCategoryMapping(34, TorznabCatType.TVHD); // Serien: HD
AddCategoryMapping(56, TorznabCatType.TVHD); // Serien: Packs|HD
AddCategoryMapping(44, TorznabCatType.TVSD); // Serien: Packs|SD
AddCategoryMapping(16, TorznabCatType.TVSD); // Serien: SD
AddCategoryMapping(10, TorznabCatType.TVOTHER); // Serien: TV/Shows
AddCategoryMapping(21, TorznabCatType.TVFOREIGN); // Serien: US TV
AddCategoryMapping(24, TorznabCatType.TVSport); // Sport: Diverses
AddCategoryMapping(23, TorznabCatType.TVSport); // Sport: Wrestling
AddCategoryMapping(57, TorznabCatType.Movies); // Tracker - Crew: pmHD
AddCategoryMapping(58, TorznabCatType.MoviesHD); // Ultra-HD: 4K
AddCategoryMapping(46, TorznabCatType.XXXOther); // XXX: Diverses
AddCategoryMapping(50, TorznabCatType.XXX); // XXX: HD
AddCategoryMapping(45, TorznabCatType.XXXPacks); // XXX: Packs
AddCategoryMapping(27, TorznabCatType.XXX); // XXX: SD
}
public HDTorrents(IIndexerConfigurationService configService, WebClient w, Logger l, IProtectionService ps)
: base(id: "hdtorrents",
name: "HD-Torrents",
description: "HD-Torrents is a private torrent website with HD torrents and strict rules on their content.",
link: "https://hdts.ru/", // Domain https://hdts.ru/ seems more reliable
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
}
},
configService: configService,
client: w,
logger: l,
p: ps,
configData: new ConfigurationDataBasicLogin(
"For best results, change the <b>Torrents per page:</b> setting to <b>100</b> on your account profile."))
{
Encoding = Encoding.UTF8;
Language = "en-us";
Type = "private";
// Movie
AddCategoryMapping("70", TorznabCatType.MoviesUHD, "Movie/UHD/Blu-Ray");
AddCategoryMapping("1", TorznabCatType.MoviesHD, "Movie/Blu-Ray");
AddCategoryMapping("71", TorznabCatType.MoviesUHD, "Movie/UHD/Remux");
AddCategoryMapping("2", TorznabCatType.MoviesHD, "Movie/Remux");
AddCategoryMapping("5", TorznabCatType.MoviesHD, "Movie/1080p/i");
AddCategoryMapping("3", TorznabCatType.MoviesHD, "Movie/720p");
AddCategoryMapping("64", TorznabCatType.MoviesUHD, "Movie/2160p");
AddCategoryMapping("63", TorznabCatType.Audio, "Movie/Audio Track");
// TV Show
AddCategoryMapping("72", TorznabCatType.TVUHD, "TV Show/UHD/Blu-ray");
AddCategoryMapping("59", TorznabCatType.TVHD, "TV Show/Blu-ray");
AddCategoryMapping("73", TorznabCatType.TVUHD, "TV Show/UHD/Remux");
AddCategoryMapping("60", TorznabCatType.TVHD, "TV Show/Remux");
AddCategoryMapping("30", TorznabCatType.TVHD, "TV Show/1080p/i");
AddCategoryMapping("38", TorznabCatType.TVHD, "TV Show/720p");
AddCategoryMapping("65", TorznabCatType.TVUHD, "TV Show/2160p");
// Music
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("66", TorznabCatType.AudioVideo, "Music/2160p");
// XXX
AddCategoryMapping("58", TorznabCatType.XXX, "XXX/Blu-ray");
AddCategoryMapping("74", TorznabCatType.XXX, "XXX/UHD/Blu-ray");
AddCategoryMapping("48", TorznabCatType.XXX, "XXX/1080p/i");
AddCategoryMapping("47", TorznabCatType.XXX, "XXX/720p");
AddCategoryMapping("67", TorznabCatType.XXX, "XXX/2160p");
}
