public async Task Identify(EpisodeInfo info)
{
if (info.ProviderIds.ContainsKey(ProviderNames.AniDb) && !Plugin.Instance.CheckForceRefreshFlag())
{
return;
}
var inspectSeason = info.ParentIndexNumber == null ||
(info.ParentIndexNumber < 2 && PluginConfiguration.Instance().UseAnidbOrderingWithSeasons);
var series = info.SeriesProviderIds.GetOrDefault(ProviderNames.AniDb);
if (!string.IsNullOrEmpty(series) && inspectSeason && info.IndexNumber != null)
{
string type = null;
if (info.ParentIndexNumber != null)
{
type = info.ParentIndexNumber == 0 ? "S" : null;
}
var id = new AnidbEpisodeIdentity(series, info.IndexNumber.Value, info.IndexNumberEnd, type);
info.ProviderIds.Remove(ProviderNames.AniDb);
info.ProviderIds.Add(ProviderNames.AniDb, id.ToString());
}
}
public async Task <bool> Convert(EpisodeInfo info)
{
var anidb = info.ProviderIds.GetOrDefault(ProviderNames.AniDb);
var tvdb = info.ProviderIds.GetOrDefault("Tvdb-Full");
if (string.IsNullOrEmpty(anidb) && !string.IsNullOrEmpty(tvdb))
{
var converted = TvdbToAnidb(tvdb);
if (converted != null)
{
info.ProviderIds.Add(ProviderNames.AniDb, converted);
return(true);
}
}
var overrideTvdb = string.IsNullOrEmpty(tvdb) ||
info.ParentIndexNumber == null ||
(info.ParentIndexNumber < 2 && PluginConfiguration.Instance().UseAnidbOrderingWithSeasons);
if (!string.IsNullOrEmpty(anidb) && overrideTvdb)
{
var converted = AnidbToTvdb(anidb);
if (converted != null && converted != tvdb)
{
info.ProviderIds["Tvdb-Full"] = converted;
return(tvdb != converted);
}
}
return(false);
}
public async Task <MetadataResult <Series> > GetMetadata(SeriesInfo info, CancellationToken cancellationToken)
{
var result = new MetadataResult <Series>();
var aid = info.ProviderIds.GetOrDefault(ProviderNames.AniList);
if (string.IsNullOrEmpty(aid))
{
return(result);
}
if (!string.IsNullOrEmpty(aid))
{
result.Item = new Series();
result.HasMetadata = true;
result.Item.ProviderIds.Add(ProviderNames.AniList, aid);
var anime = await _api.GetAnime(aid);
result.Item.Name = SelectName(anime, PluginConfiguration.Instance().TitlePreference, info.MetadataLanguage ?? "en");
result.Item.Overview = anime.description;
DateTime start;
if (DateTime.TryParse(anime.start_date, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out start))
{
result.Item.PremiereDate = start;
}
DateTime end;
if (DateTime.TryParse(anime.end_date, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out end))
{
result.Item.EndDate = end;
}
if (anime.genres != null)
{
foreach (var genre in anime.genres)
{
result.Item.AddGenre(genre);
}
GenreHelper.CleanupGenres(result.Item);
GenreHelper.RemoveDuplicateTags(result.Item);
}
if (!string.IsNullOrEmpty(anime.image_url_lge))
{
StoreImageUrl(aid, anime.image_url_lge, "image");
}
if (!string.IsNullOrEmpty(anime.image_url_banner))
{
StoreImageUrl(aid, anime.image_url_banner, "banner");
}
}
return(result);
}
private void ParseAdditionalEpisodeXml(FileInfo xml, Episode episode, string metadataLanguage)
{
var settings = new XmlReaderSettings
{
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
using (var streamReader = xml.OpenText())
using (var reader = XmlReader.Create(streamReader, settings))
{
reader.MoveToContent();
var titles = new List <Title>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "length":
var length = reader.ReadElementContentAsString();
if (!string.IsNullOrEmpty(length))
{
long duration;
if (long.TryParse(length, out duration))
{
episode.RunTimeTicks += TimeSpan.FromMinutes(duration).Ticks;
}
}
break;
case "title":
var language = reader.GetAttribute("xml:lang");
var name = reader.ReadElementContentAsString();
titles.Add(new Title
{
Language = language,
Type = "main",
Name = name
});
break;
}
}
}
var title = titles.Localize(PluginConfiguration.Instance().TitlePreference, metadataLanguage).Name;
if (!string.IsNullOrEmpty(title))
{
episode.Name += ", " + title;
}
}
}
public static void CleanupGenres(Series series)
{
PluginConfiguration config = PluginConfiguration.Instance();
if (config.TidyGenreList)
{
series.Genres = RemoveRedundantGenres(series.Genres)
.Distinct()
.ToList();
TidyGenres(series);
}
var max = config.MaxGenres;
if (config.AddAnimeGenre)
{
series.Genres.Remove("Animation");
series.Genres.Remove("Anime");
max = Math.Max(max - 1, 0);
}
if (config.MaxGenres > 0)
{
if (config.MoveExcessGenresToTags)
{
foreach (string genre in series.Genres.Skip(max))
{
if (!series.Tags.Contains(genre))
{
series.Tags.Add(genre);
}
}
}
series.Genres = series.Genres.Take(max).ToList();
}
if (!series.Genres.Contains("Anime") && config.AddAnimeGenre)
{
if (series.Genres.Contains("Animation"))
{
series.Genres.Remove("Animation");
}
series.AddGenre("Anime");
}
series.Genres.Sort();
}
public static void TidyGenres(Series series)
{
var config = PluginConfiguration.Instance != null?PluginConfiguration.Instance() : new PluginConfiguration();
var genres = new HashSet <string>();
var tags = new HashSet <string>(series.Tags);
foreach (string genre in series.Genres)
{
string mapped;
if (GenreMappings.TryGetValue(genre, out mapped))
{
genres.Add(mapped);
}
else
{
if (config.MoveExcessGenresToTags)
{
tags.Add(genre);
}
else
{
genres.Add(genre);
}
}
if (GenresAsTags.Contains(genre))
{
if (config.MoveExcessGenresToTags)
{
tags.Add(genre);
}
else if (!genres.Contains(genre))
{
genres.Add(genre);
}
}
}
series.Genres = genres.ToList();
series.Tags = tags.ToList();
}
private RemoteSearchResult ToSearchResult(Anime anime)
{
var result = new RemoteSearchResult
{
Name = SelectName(anime, PluginConfiguration.Instance().TitlePreference, "en")
};
result.ImageUrl = anime.image_url_lge;
result.SetProviderId(ProviderNames.AniList, anime.id.ToString());
result.SearchProviderName = Name;
DateTime start;
if (DateTime.TryParse(anime.start_date, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out start))
{
result.PremiereDate = start;
}
return(result);
}
private string ParseTitle(XmlReader reader, string preferredMetadataLangauge)
{
var titles = new List <Title>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "title")
{
var language = reader.GetAttribute("xml:lang");
var type = reader.GetAttribute("type");
var name = reader.ReadElementContentAsString();
titles.Add(new Title
{
Language = language,
Type = type,
Name = name
});
}
}
return(titles.Localize(PluginConfiguration.Instance().TitlePreference, preferredMetadataLangauge).Name);
}
private void ParseEpisodeXml(FileInfo xml, Episode episode, string preferredMetadataLanguage)
{
var settings = new XmlReaderSettings
{
CheckCharacters = false,
IgnoreProcessingInstructions = true,
IgnoreComments = true,
ValidationType = ValidationType.None
};
using (var streamReader = xml.OpenText())
using (var reader = XmlReader.Create(streamReader, settings))
{
reader.MoveToContent();
var titles = new List <Title>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "length":
var length = reader.ReadElementContentAsString();
if (!string.IsNullOrEmpty(length))
{
long duration;
if (long.TryParse(length, out duration))
{
episode.RunTimeTicks = TimeSpan.FromMinutes(duration).Ticks;
}
}
break;
case "airdate":
var airdate = reader.ReadElementContentAsString();
if (!string.IsNullOrEmpty(airdate))
{
DateTime date;
if (DateTime.TryParse(airdate, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out date))
{
episode.PremiereDate = date;
}
}
break;
case "rating":
int count;
float rating;
if (int.TryParse(reader.GetAttribute("count"), NumberStyles.Any, CultureInfo.InvariantCulture, out count) &&
float.TryParse(reader.ReadElementContentAsString(), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out rating))
{
episode.VoteCount = count;
episode.CommunityRating = rating;
}
break;
case "title":
var language = reader.GetAttribute("xml:lang");
var name = reader.ReadElementContentAsString();
titles.Add(new Title
{
Language = language,
Type = "main",
Name = name
});
break;
}
}
}
var title = titles.Localize(PluginConfiguration.Instance().TitlePreference, preferredMetadataLanguage).Name;
if (!string.IsNullOrEmpty(title))
{
episode.Name = title;
}
}
}
