示例#1
0
        public async Task <IActionResult> GetTorrentsAsync(
            [FromQuery][Required] ICollection <string> urls,
            [FromQuery][Required] Sorting sortOrder,
            [FromQuery][Required] TorrentCategory category,
            [FromQuery][Required] string searchValue,
            [FromQuery][Required] int page)
        {
            if (page <= 0)
            {
                return(BadRequest(ErrorResponse(new ResponseMessage(message: "Invalid page number", value: page.ToString()))));
            }

            var validUrls = ValidUrls(urls).ToArray();

            if (!validUrls.Any())
            {
                return(BadRequest(ErrorResponse(new ResponseMessage(message: "Provided urls are invalid"))));
            }

            var mappedUrls     = MapValidUrls(validUrls);
            var torrentResults = await ExecuteTorrentSearch(mappedUrls, searchValue, category, sortOrder, page);

            return(Ok(new TorrentSearchResult
            {
                Torrents = torrentResults,
                Warnings = urls.Except(validUrls).Select(u => new ResponseMessage(message: "Invalid Url", value: u))
            }));
        }
 public Torrent[] Search(string query, TorrentCategory category, TorrentSortOrder sortOrder = TorrentSortOrder.Title,
     TorrentSortOptions sortOptions = TorrentSortOptions.Ascending)
 {
     var url = BuildSearchUrl(query, category, sortOrder, sortOptions);
     var html = GetHtmlData(url);
     return ParseHtmlData(html);
 }
 public Torrent[] Search(string query, TorrentCategory category, TorrentSortOrder sortOrder = TorrentSortOrder.Title,
     TorrentSortOptions sortOptions = TorrentSortOptions.Ascending)
 {
     var url = BuildSearchUrl(query, category, sortOrder, sortOptions, 1);
     Debug.WriteLine("URL = " + url);
     var searchResults = GetSearchResults(url);
     return searchResults.Select(GetTorrent).Cast<Torrent>().ToArray();
 }
        public Torrent[] Search(string query, TorrentCategory category, TorrentSortOrder sortOrder = TorrentSortOrder.Title,
            TorrentSortOptions sortOptions = TorrentSortOptions.Ascending)
        {
            var url = BuildUrlString(query, category, sortOrder, sortOptions);
            Debug.WriteLine("URL = " + url);
            var xmlStream = PerformKickassRequest(url);
            var xmlSerializer = new XmlSerializer(typeof(KickassRssContainer));
            var torrents = (KickassRssContainer)xmlSerializer.Deserialize(xmlStream);
            xmlStream.Close();

            return torrents.Channel.Torrents;
        }
示例#5
0
 public static string ToThePirateBayCategory(TorrentCategory category)
 {
     return(category switch
     {
         TorrentCategory.Applications => "300",
         TorrentCategory.Games => "400",
         TorrentCategory.Movies => "201,202,207",
         TorrentCategory.Music => "101",
         TorrentCategory.TV => "205,208",
         TorrentCategory.XXX => "500",
         _ => throw new ArgumentException($"Unexpected torrent category: {category}")
     });
示例#6
0
 public X1337XTorrent(string title, string url, uint seed, uint leech, ulong size, string uploader, string magnetLink, uint downloads, TorrentCategory category, uint age, string torrentFile, string id)
 {
     Title = title;
     Seeders = seed;
     Leechers = leech;
     Size = size;
     Uploader = uploader;
     Magnet = magnetLink;
     Downloads = downloads;
     Category = category;
     Age = age;
     PageLink = url;
     TorrentFile = torrentFile;
     Id = id;
 }
示例#7
0
        private List <Torrent> GetTorrentsList(CQ trs, TorrentCategory torrentCategory)
        {
            var torrents = new List <Torrent>(100);

            foreach (var tr in trs.Skip(1))
            {
                var cq         = tr.Cq();
                var dateString = cq.Find("td:eq(0)")
                                 .Select(x => x.InnerText)
                                 .FirstOrDefault();
                var sizeSelector = cq.Find("td:eq(1)")
                                   .Select(x => x.GetAttribute("colspan"))
                                   .FirstOrDefault() == "2" ? "td:eq(2)" : "td:eq(3)";
                var size = cq.Find(sizeSelector)
                           .Select(x => x.InnerText)
                           .FirstOrDefault();
                var href = cq.Find("a:eq(2)")
                           .Select(x => x.GetAttribute("href"))
                           .FirstOrDefault() ?? string.Empty;
                var infoHashHref = cq.Find("a:eq(1)")
                                   .Select(x => x.GetAttribute("href"))
                                   .FirstOrDefault() ?? string.Empty;
                var infoHashMatch = _magnetRegex.Match(infoHashHref);

                var regex  = new Regex(@"/torrent/(\d+)");
                var result = regex.Match(href);

                if (result.Success)
                {
                    var date = ParseDate(dateString);

                    var torrent = new Torrent
                    {
                        Created  = date,
                        Title    = cq.Find("a:eq(2)").Select(x => x.InnerText).FirstOrDefault(),
                        SiteID   = int.Parse(result.Groups[1].Value),
                        Size     = ParseSize(size),
                        InfoHash = infoHashMatch.Success ? infoHashMatch.Groups[1].Value : string.Empty,
                        Category = torrentCategory
                    };

                    torrents.Add(torrent);
                }
            }

            return(torrents);
        }
 private static string BuildUrlString(string query, TorrentCategory category, TorrentSortOrder sortOrder,
     TorrentSortOptions sortOptions)
 {
     string sortOpt = null, sortOrd = null;
     switch (sortOrder)
     {
         case TorrentSortOrder.Title:        sortOrd = "name"; break;
         case TorrentSortOrder.Size:         sortOrd = "size"; break;
         case TorrentSortOrder.Seeders:      sortOrd = "seeders"; break;
         case TorrentSortOrder.Leechers:     sortOrd = "leechers"; break;
         case TorrentSortOrder.Files:        sortOrd = "files_count"; break;
         case TorrentSortOrder.Age:          sortOrd = "time_add"; break;
     }
     switch (sortOptions)
     {
         case TorrentSortOptions.Ascending:  sortOpt = "asc"; break;
         case TorrentSortOptions.Decending:  sortOpt = "desc"; break;
     }
     return String.Format("{0}{1} category:{2}/?field={3}&sorder={4}&rss=1", BaseUrl, query, category.ToString().ToLower(), sortOrd, sortOpt);
 }
        private static string BuildSearchUrl(string query, TorrentCategory category, TorrentSortOrder sortOrder,
            TorrentSortOptions sortOptions)
        {
            query = query.Replace(' ', '+');
            int iht;
            switch (category)
            {
                case TorrentCategory.All:           iht = 0; break;
                case TorrentCategory.Adult:         iht = 4; break;
                case TorrentCategory.Anime:         iht = 1; break;
                case TorrentCategory.Application:   iht = 2; break;
                case TorrentCategory.Book:          iht = 9; break;
                case TorrentCategory.Game:          iht = 3; break;
                case TorrentCategory.Movie:         iht = 5; break;
                case TorrentCategory.Music:         iht = 6; break;
                case TorrentCategory.Tv:            iht = 8; break;
                default:                            goto case TorrentCategory.All;
            }
            string opt;
            switch (sortOptions)
            {
                case TorrentSortOptions.Ascending: opt = "asc"; break;
                case TorrentSortOptions.Decending: opt = "desc"; break;
                default: goto case TorrentSortOptions.Ascending;
            }
            string so;
            switch (sortOrder)
            {
                case TorrentSortOrder.Age:          so = "&Torrent_sort=created_at." + opt; break;
                case TorrentSortOrder.Files:        goto default;
                case TorrentSortOrder.Leechers:     so = "&Torrent_sort=leechers." + opt; break;
                case TorrentSortOrder.Seeders:      so = "&Torrent_sort=seeders." + opt; break;
                case TorrentSortOrder.Size:         so = "&Torrent_sort=size." + opt; break;
                case TorrentSortOrder.Title:        so = ""; break;
                default:                            goto case TorrentSortOrder.Title;
            }

            return string.Format("{0}search.php?q={1}{2}&iht={3}", OpenBayUrl, query, so, iht);
        }
        private string BuildSearchUrl(string query, TorrentCategory category, TorrentSortOrder sortOrder, TorrentSortOptions sortOptions, int pageNum)
        {
            string sortUrl;
            switch (sortOrder)
            {
                case TorrentSortOrder.Age: sortUrl = "{0}sort-search/{1}/time/{2}/{3}/"; break;
                case TorrentSortOrder.Leechers: sortUrl = "{0}sort-search/{1}/leechers/{2}/{3}/"; break;
                case TorrentSortOrder.Seeders: sortUrl = "{0}sort-search/{1}/seeders/{2}/{3}/"; break;
                case TorrentSortOrder.Size: sortUrl = "{0}sort-search/{1}/size/{2}/{3}/"; break;
                case TorrentSortOrder.Title: sortUrl = "{0}search/{1}/{3}/"; break;
                default: goto case  TorrentSortOrder.Title;
            }

            string sortOrd;
            switch (sortOptions)
            {
                case TorrentSortOptions.Ascending: sortOrd = "asc"; break;
                case TorrentSortOptions.Decending: sortOrd = "desc"; break;
                default: goto case TorrentSortOptions.Ascending;
            }

            query = query.Replace(' ', '+');
            return string.Format(sortUrl, BaseUrl, query, sortOrd, pageNum);
        }
        public async Task <TorrentQueryResult> GetTorrentsByCategoryAsync(string searchFor, int page, Sorting sorting, TorrentCategory category)
        {
            var mappedSortOption = SortingMapper.SortingToRargbSorting(sorting);
            var mappedCategory   = TorrentCategoryMapper.ToRargbCategory(category);

            var fullUrl = Path.Combine(_searchEndpoint, page.ToString(), $"?search={searchFor}&category[]={mappedCategory}&order={mappedSortOption.Order}&by={mappedSortOption.By}");

            var contents = await UrlGetResponseString(fullUrl);

            return(await _parser.ParsePageForTorrentEntriesAsync(contents));
        }
示例#12
0
        public async Task <TorrentQueryResult> GetTorrentsByCategoryAsync(string searchFor, int page, Sorting sorting, TorrentCategory category)
        {
            var mappedSortOption = SortingMapper.SortingToKickassSorting(sorting);
            var mappedCategory   = TorrentCategoryMapper.ToKickassCategory(category);

            var fullUrl = Path.Combine(_searchEndpoint, searchFor, $"category/{mappedCategory}", page.ToString(), $"?sortby={mappedSortOption.SortBy}&sort={mappedSortOption.Sort}");

            var response = await HttpGetAsync(fullUrl);

            return(await _parser.ParsePageForTorrentEntriesAsync(response.Content));
        }
示例#13
0
        public async Task <TorrentQueryResult> GetTorrentsByCategoryAsync(string searchFor, int page, Sorting sorting, TorrentCategory category)
        {
            var mapperSorting  = SortingMapper.SortingToLeetxSorting(sorting);
            var mappedCategory = TorrentCategoryMapper.ToLeetxCategory(category);

            var fullUrl  = Path.Combine(_categorySearchEndpoint, searchFor, mappedCategory, mapperSorting.SortedBy, mapperSorting.Order, page.ToString()) + Path.DirectorySeparatorChar;
            var contents = await UrlGetResponseString(fullUrl);

            return(await _parser.ParsePageForTorrentEntriesAsync(contents));
        }
        public async Task <TorrentQueryResult> GetTorrentsByCategoryAsync(string searchFor, int page, Sorting sorting, TorrentCategory category)
        {
            var mappedSortOption     = SortingMapper.SortingToThePirateBaySorting(sorting);
            var mappedCategorySearch = TorrentCategoryMapper.ToThePirateBayCategory(category);
            var fullUrl = Path.Combine(_searchEndpoint, searchFor, page.ToString(), mappedSortOption.ToString(), mappedCategorySearch);

            var contents = await UrlGetResponseString(fullUrl);

            return(await _parser.ParsePageForTorrentEntriesAsync(contents));
        }
示例#15
0
        private async Task <IEnumerable <TorrentQueryResult> > ExecuteTorrentSearch(IEnumerable <KeyValuePair <TorrentSource, string> > mappedUrls,
                                                                                    string searchValue, TorrentCategory category, Sorting sortOrder, int page)
        {
            var res = new List <TorrentQueryResult>();

            foreach (var url in mappedUrls)
            {
                var source = _helper.Sources()[url.Key];

                source.UpdateUsedSource(url.Value);//TODO: refactor how searching works

                var torrents = category == TorrentCategory.All
                    ? await source.GetTorrentsAsync(searchValue, page, sortOrder)
                    : await source.GetTorrentsByCategoryAsync(searchValue, page, sortOrder, category);

                res.Add(torrents);
            }
            return(res);
        }