Example #1
0
        private void setSubtitleText(VideoInfo video, ITrackingInfo it)
        {
            ISubtitleDownloader sd = (ISubtitleDownloader)sdObject;
            List <Subtitle>     results;

            if (it.VideoKind == VideoKind.Movie)
            {
                SearchQuery qu = new SearchQuery(it.Title);
                qu.Year          = (int)it.Year;
                qu.LanguageCodes = languagePrios.Keys.ToArray();
                results          = sd.SearchSubtitles(qu);
            }
            else
            {
                EpisodeSearchQuery qu = new EpisodeSearchQuery(it.Title, (int)it.Season, (int)it.Episode, null);
                qu.LanguageCodes = languagePrios.Keys.ToArray();
                results          = sd.SearchSubtitles(qu);
            }
            Log.Debug("Subtitles found:" + results.Count.ToString());
            if (results.Count > 0)
            {
                int      minValue = int.MaxValue;
                Subtitle minSub   = results[0];

                foreach (Subtitle sub in results)
                {
                    Log.Debug("Subtitle " + sub.ProgramName + " " + sub.LanguageCode);
                    if (languagePrios.ContainsKey(sub.LanguageCode))
                    {
                        int prio = languagePrios[sub.LanguageCode];
                        if (prio < minValue)
                        {
                            minValue = prio;
                            minSub   = sub;
                        }
                    }
                }

                List <FileInfo> subtitleFiles = sd.SaveSubtitle(minSub);
                if (subtitleFiles.Count > 0)
                {
                    string s = File.ReadAllText(subtitleFiles[0].FullName, System.Text.Encoding.UTF8);
                    if (s.IndexOf('�') != -1)
                    {
                        video.SubtitleText = File.ReadAllText(subtitleFiles[0].FullName, System.Text.Encoding.Default);
                    }
                    else
                    {
                        video.SubtitleText = s;
                    }
                }
                foreach (FileInfo fi in subtitleFiles)
                {
                    fi.Delete();
                }
            }
        }
 public void TestDailySubsSearch()
 {
     var dailySubsSubtitleDownloader = new DailySubsSubtitleDownloader.DailySubsSubtitleDownloader();
     var episodeSearchQuery = new EpisodeSearchQuery("the big bang theory", 1, 1, null)
     {
         LanguageCodes = new[] {"eng"}
     };
     var searchSubtitles = dailySubsSubtitleDownloader.SearchSubtitles(episodeSearchQuery);
     Assert.IsNotNull(searchSubtitles);
 }
Example #3
0
        public List <Subtitle> SearchSubtitles(EpisodeSearchQuery query)
        {
            string text = string.Concat(new object[]
            {
                this.searchUrlBase,
                "&sK=",
                query.SerieTitle,
                "&sTS=",
                query.Season,
                "&sTE=",
                query.Episode
            });

            return(this.Search(text, query));
        }
        public List <Subtitle> SearchSubtitles(EpisodeSearchQuery query)
        {
            if (!IsProviderActive())
            {
                throw new Exception("Could not use Sratim.co.il. Unable to validate credentials");
            }

            var languageList = ConvertThreeLetterToTwoLetterLanguageCodes(query.LanguageCodes);

            var subtitles = SearchSubtitles(null, 0, query.SerieTitle,
                                            query.Season.ToString(CultureInfo.InvariantCulture),
                                            query.Episode.ToString(CultureInfo.InvariantCulture), languageList, false);

            return(subtitles.Select(subtitle => new Subtitle(subtitle.SubtitleId, query.SerieTitle, subtitle.Filename, Languages.GetLanguageCode(subtitle.LanguageName))).ToList());
        }
Example #5
0
        public List <Subtitle> SearchSubtitles(EpisodeSearchQuery query)
        {
            this.CreateConnectionAndLogin();
            if (this.searchTimeout > 0)
            {
                this.openSubtitlesProxy.Timeout = this.searchTimeout * 1000;
            }
            string str1   = "e" + string.Format("{0:00}", (object)query.Episode);
            string str2   = "s" + string.Format("{0:00}", (object)query.Season);
            string query1 = query.SerieTitle + " " + str2 + str1;

            return(this.PerformSearch(new subInfo[1]
            {
                new subInfo(this.GetLanguageCodes((SubtitleSearchQuery)query), "", new int?(), new int?(), query1)
            }, new int?()));
        }
        public void TestDailySubsDownloadLanguage()
        {
            var dailySubsSubtitleDownloader = new DailySubsSubtitleDownloader.DailySubsSubtitleDownloader();
            var episodeSearchQuery = new EpisodeSearchQuery("castle 2009", 7, 13, null)
            {
                LanguageCodes = new[] { "eng" }
            };
            var searchSubtitles = dailySubsSubtitleDownloader.SearchSubtitles(episodeSearchQuery);

            // make sure there are resuts
            Assert.IsNotNull(searchSubtitles);

            // check result
            var saveSubtitle = dailySubsSubtitleDownloader.SaveSubtitle(searchSubtitles[0]);
            Assert.AreNotEqual(null, saveSubtitle);
            Assert.AreNotEqual(0, saveSubtitle.Count);
        }
 /// <summary>
 /// Search for subtitles by episode.
 /// </summary>
 /// <returns>List of available subtitles</returns>
 public Task <List <SubtitleDownloaderResult> > SearchSeriesSubtitlesAsync(string series, int season, int episode, int?tvdbid, params string[] languages)
 {
     try
     {
         if (_episodeSearchSupport)
         {
             EpisodeSearchQuery query = new EpisodeSearchQuery(series, season, episode, tvdbid);
             query.LanguageCodes = languages;
             List <Subtitle> results = _downloader.SearchSubtitles(query);
             return(Task.FromResult(results.Select(s => new SubtitleDownloaderResult(s)).ToList()));
         }
     }
     catch (NotSupportedException)
     {
         _episodeSearchSupport = false;
     }
     return(Task.FromResult(new List <SubtitleDownloaderResult>()));
 }
        public void TestSeriesSearchWithCleanName()
        {
            var downloader = new SubsCenterOrgDownloader();
            var query      = new EpisodeSearchQuery("The Office (us)", 5, 6, null)
            {
                LanguageCodes = new[] { "heb" }
            };
            var results = downloader.SearchSubtitles(query);

            // make sure there are resuts
            Assert.IsNotNull(results);
            Assert.IsTrue(results.Count > 0);

            // check first result
            var subtitleFiles = downloader.SaveSubtitle(results[0]);

            Assert.AreNotEqual(null, subtitleFiles);
            Assert.AreNotEqual(0, subtitleFiles.Count);
        }
        public void TestSeriesSearchWithCleanNameNoConfFile()
        {
            var downloader = new SubsCenterOrgDownloader();
            var query      = new EpisodeSearchQuery("house", 6, 16, null)
            {
                LanguageCodes = new[] { "heb" }
            };
            var results = downloader.SearchSubtitles(query);

            // todo - after implementing loop over all result pages, this test should work without comments

            // make sure there are resuts
//    Assert.IsNotNull(results);
//    Assert.IsTrue(results.Count > 0);

            // check first result
//    var subtitleFiles = downloader.SaveSubtitle(results[0]);
//    Assert.AreNotEqual(null, subtitleFiles);
//    Assert.AreNotEqual(0, subtitleFiles.Count);
        }
        private void setSubtitleText(VideoInfo video, ITrackingInfo it)
        {
            ISubtitleDownloader sd = (ISubtitleDownloader)sdObject;
            List<Subtitle> results;
            if (it.VideoKind == VideoKind.Movie)
            {
                SearchQuery qu = new SearchQuery(it.Title);
                qu.Year = (int)it.Year;
                qu.LanguageCodes = languagePrios.Keys.ToArray();
                results = sd.SearchSubtitles(qu);
            }
            else
            {
                EpisodeSearchQuery qu = new EpisodeSearchQuery(it.Title, (int)it.Season, (int)it.Episode, null);
                qu.LanguageCodes = languagePrios.Keys.ToArray();
                results = sd.SearchSubtitles(qu);
            }
            Log.Debug("Subtitles found:" + results.Count.ToString());
            if (results.Count > 0)
            {
                int minValue = int.MaxValue;
                Subtitle minSub = results[0];

                foreach (Subtitle sub in results)
                {
                    Log.Debug("Subtitle " + sub.ProgramName + " " + sub.LanguageCode);
                    if (languagePrios.ContainsKey(sub.LanguageCode))
                    {
                        int prio = languagePrios[sub.LanguageCode];
                        if (prio < minValue)
                        {
                            minValue = prio;
                            minSub = sub;
                        }
                    }
                }

                List<FileInfo> subtitleFiles = sd.SaveSubtitle(minSub);
                if (subtitleFiles.Count > 0)
                {
                    string s = File.ReadAllText(subtitleFiles[0].FullName, System.Text.Encoding.UTF8);
                    if (s.IndexOf('�') != -1)
                        video.SubtitleText = File.ReadAllText(subtitleFiles[0].FullName, System.Text.Encoding.Default);
                    else
                        video.SubtitleText = s;
                }
                foreach (FileInfo fi in subtitleFiles)
                    fi.Delete();
            }
        }
Example #11
0
        static bool ProcessFile(string fileName)
        {
            var path = Path.GetDirectoryName(fileName);
            var ext = Path.GetExtension(fileName);
            if (ext != ".avi" && ext != ".mkv" && ext != ".mp4")
                return true;
            var file = Path.GetFileNameWithoutExtension(fileName);
            string targetSubtitleFile = Path.Combine(path, file) + ".srt";
            string targetNoSubtitleFile = Path.Combine(path, file) + ".nosrt";
            if (File.Exists(targetSubtitleFile) || File.Exists(targetNoSubtitleFile))
                return true;

            string name,group;
            int season,episode;
            if (ParseEpisodeInfo(Path.GetFileNameWithoutExtension(fileName), out name, out season, out episode, out group))
            {
                if (ignoreShows.ContainsKey(name.ToLowerInvariant()))
                {
                    Log("Ignoring {0}", fileName);
                    return true;
                }

                Log("Processing file {0}...", fileName);

                EpisodeSearchQuery query = new EpisodeSearchQuery(name, season, episode, null);
                query.LanguageCodes = new string[] { language };

                foreach (ISubtitleDownloader downloader in downloaders)
                    try
                    {
                        foreach (Subtitle subtitle in downloader.SearchSubtitles(query))
                        {
                            string compareName, compareGroup;
                            int compareSeason, compareEpisode;
                            ParseEpisodeInfo(subtitle.FileName, out compareName, out compareSeason, out compareEpisode, out compareGroup);
                            if (name.ToLowerInvariant() == compareName.ToLowerInvariant() &&
                                season == compareSeason &&
                                episode == compareEpisode &&
                                group.ToLowerInvariant() == compareGroup.ToLowerInvariant())
                            {
                                Log("Downloading subtitles from {0}...", downloader.GetName());
                                try
                                {
                                    List<FileInfo> subtitleFiles = downloader.SaveSubtitle(subtitle);
                                    FileInfo subtitleFile = subtitleFiles[0];
                                    Log("Renaming from {0} to {1}...", subtitleFile.FullName, targetSubtitleFile);
                                    File.Delete(targetSubtitleFile);
                                    File.Move(subtitleFile.FullName, targetSubtitleFile);
                                }
                                catch (Exception)
                                {
                                    continue;
                                }
                                return true;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Log("Downloader {0} failed: {1}", downloader.GetName(), e.Message);
                    }
            }
            return false;
        }
        public List <Subtitle> SearchSubtitles(EpisodeSearchQuery query)
        {
            var gotMatch = false;
            var retries  = 0;
            var web      = new HtmlWeb();

            // If needed - use configuration XML file to replace received title with a different value
            var title = SubsCenterOrgDownloaderConfiguration.Instance.OverrideTitleFromConfiguration(query.SerieTitle);

            // clean title
            var cleanTitle = CleanTitleName(title);

            // try guessing exact episode url
            var exactSeriesUrl  = ExactSeriesUrl + title.Replace(" ", "-");
            var exactEpisodeUrl = exactSeriesUrl + "/" + query.Season + "/" + query.Episode;

            //  download "exact" pages
            var mainSeriesPage = web.Load(exactSeriesUrl);
            var episodePage    = web.Load(exactEpisodeUrl);

            // if page not found and can clean title name - use clean name
            if (!cleanTitle.Equals(title) && (IsPageNotFound(mainSeriesPage) || IsPageNotFound(episodePage)))
            {
                // try guessing exact episode url again
                exactSeriesUrl  = ExactSeriesUrl + cleanTitle.Replace(" ", "-");
                exactEpisodeUrl = exactSeriesUrl + "/" + query.Season + "/" + query.Episode;
                //  download "exact" pages again
                mainSeriesPage = web.Load(exactSeriesUrl);
                episodePage    = web.Load(exactEpisodeUrl);
            }

            // handle "Error 404" - page not found
            if (IsPageNotFound(episodePage) || !TitleSeasonEpisodeMatch(mainSeriesPage, episodePage, title, cleanTitle, query.Season, query.Episode))
            {
                // todo - get number of result pages and loop
                // search url
                var queryUrl  = SearchUrlBase + "q=" + cleanTitle;
                var queryPage = web.Load(queryUrl);

                var htmlNodeCollection = queryPage.DocumentNode.SelectNodes("//a");
                foreach (var node in htmlNodeCollection)
                {
                    var attributeValue = node.GetAttributeValue("href", string.Empty);
                    if (attributeValue.StartsWith(SeriesSubtitlePath))
                    {
                        // todo - before downloading page - check title from attribute
                        // download new pages
                        mainSeriesPage = web.Load(BaseUrl + attributeValue + "/" + query.Season + "/" + query.Episode);
                        episodePage    = web.Load(BaseUrl + attributeValue + "/" + query.Season + "/" + query.Episode);
                        if (TitleSeasonEpisodeMatch(mainSeriesPage, episodePage, title, cleanTitle, query.Season, query.Episode))
                        {
                            gotMatch = true;
                            break;
                        }
                        if (++retries >= 3)
                        {
                            break;
                        }
                    }
                }
            }
            else
            {
                gotMatch = true;
            }

            // verify
            if (gotMatch)
            {
                return(Search(episodePage, query));
            }
            return(new List <Subtitle>());
        }
        public List<Subtitle> SearchSubtitles(EpisodeSearchQuery query)
        {
            _logger.Info("Searching for subtitles for " + query.SerieTitle + " season " + query.Season + " episode " + query.Episode);

            // Convert language codes to their english name
            //var languages = query.LanguageCodes.Select(DailySubsLanguageUtils.TryGetLanguageNameFromCode).Select(languageName => languageName.EnglishName).ToList();
            //_logger.Info("Languages: " + string.Join("; ", languages));
            var languages = string.Join(",", query.LanguageCodes);

            // Search subtitles
            var subtitles = SearchSubtitles(query.SerieTitle, query.Season.ToString(CultureInfo.InvariantCulture), query.Episode.ToString(CultureInfo.InvariantCulture), languages);
            var subtitleDatas = subtitles as IList<SubtitleData> ?? subtitles.ToList();
            _logger.Info("Found: " + subtitleDatas.Count() + " subtitle" + (subtitleDatas.Count() > 1 ? "s" : "") + (subtitleDatas.Any() ? "\n" : "") +
                string.Join("; ", subtitleDatas.Select(i => i.Filename).ToList()));

            // Choose only relevant languages
            var filteredSubtitles = subtitleDatas.Where(subtitle => languages.Contains(subtitle.LanguageName));
            var filteredSubtitlesDatas = filteredSubtitles as IList<SubtitleData> ?? filteredSubtitles.ToList();
            _logger.Info("After filtering: " + filteredSubtitlesDatas.Count() + " subtitle" + (filteredSubtitlesDatas.Count() > 1 ? "s" : "") + (filteredSubtitlesDatas.Any() ? "\n" : "") +
                string.Join("; ", filteredSubtitlesDatas.Select(i => i.Filename).ToList()));

            // Convert list of SubtitleData to list of Subtitle
            return filteredSubtitlesDatas.Select(subtitle => new Subtitle(subtitle.SubtitleUrl, query.SerieTitle, subtitle.Filename, Languages.GetLanguageCode(subtitle.LanguageName))).ToList();
        }