Esempio n. 1
0
func (self *SeriesIndex) AddEpisode(episode *renamer.Episode) (bool, error) {

	// test for all possible series names if they exist in index and take the
	// first matching
ExtractorLoop:
	for _, extractor := range self.nameExtractors {
		names, err := extractor.Names(episode)

		if err != nil {
			fmt.Printf("!!! Error asking extractor for series names: %s", err)
			continue
		}

		for _, possible_series := range names {
			series_name := self.SeriesNameInIndex(possible_series)
			if series_name != "" {
				episode.Series = series_name
				break ExtractorLoop
			}
		}
	}

	series, existing := self.seriesMap[episode.Series]
	if !existing {
		return false, errors.New("Series does not exist in index")
	}

	// Handle episodes where no language is set
	if episode.Language == "" {
		self.GuessEpisodeLanguage(episode, series)
	}

	_, language_exist := series.languageMap[episode.Language]
	if !language_exist {
		return false, errors.New("Series is not watched in this language")
	}

	if self.IsEpisodeInIndex(*episode) {
		return false, errors.New("Episode already exists in Index")
	}

	episode_entry := Episode{Name: episode.CleanedFileName()}

	// find the right EpisodeSet so we can add our new episode to it
	set, exist := series.languageMap[episode.Language]
	if exist {
		set.EpisodeList = append(set.EpisodeList, episode_entry)
		set.BuildUpEpisodeMap()
		return true, nil
	}

	return false,
		errors.New("Episode couldn't be added to index. This shouldn't occur!")
}
Esempio n. 2
0
func (self *SeriesIndex) GuessEpisodeLanguage(episode *renamer.Episode, series *Series) {
	// This methods tries to find the right language for the supplied episode
	// based on several heuristics

	// When there is no language set and the series is only watched in one
	// language we can take this series
	if len(series.languageMap) == 1 {
		for k, _ := range series.languageMap {
			episode.Language = k
			break
		}
	}

	// Find the language which is most likely the right language
	if len(series.languageMap) > 1 {
		possible_languages := []string{}

		// when episode has not been watched in only one of the languages
		for lang, _ := range series.languageMap {
			episode.Language = lang
			if !self.IsEpisodeInIndex(*episode) {
				possible_languages = append(possible_languages, lang)
			}

			episode.Language = ""
		}

		if len(possible_languages) == 1 {
			episode.Language = possible_languages[0]

		} else if len(possible_languages) > 1 {
			// take the language where the previous episode exist
			previous_existing := []string{}

			for _, lang := range possible_languages {
				epi := *episode
				epi.Language = lang
				if (epi.Episode - 1) > 0 {
					epi.Episode -= 1
				}

				if self.IsEpisodeInIndex(epi) {
					previous_existing = append(previous_existing, lang)
				}
			}

			if len(previous_existing) == 1 {
				episode.Language = previous_existing[0]
			}
		}
	}
}
Esempio n. 3
0
func (s *MySuite) TestEpisodeExistanceCheckWithExactSeriesName(c *C) {
	episode := renamer.Episode{Series: "Shameless US", Season: 1, Episode: 1,
		Language: "de"}
	c.Assert(s.index.IsEpisodeInIndex(episode), Equals, true)

	episode.Language = "en"
	c.Assert(s.index.IsEpisodeInIndex(episode), Equals, true)

	episode.Language = "fr"
	c.Assert(s.index.IsEpisodeInIndex(episode), Equals, false)

	episode.Season = 100
	c.Assert(s.index.IsEpisodeInIndex(episode), Equals, false)
}