public static List <Tag> GetTags(HttpContext ctx, SVR_AniDB_Anime anime, TagFilter.Filter filter, bool excludeDescriptions = false)
{
var tags = new List <Tag>();
var allTags = anime.GetAniDBTags().DistinctBy(a => a.TagName).ToList();
var filteredTags = TagFilter.ProcessTags(filter, allTags, tag => tag.TagName);
foreach (AniDB_Tag tag in filteredTags)
{
var toAPI = new Tag
{
Name = tag.TagName
};
var animeXRef = RepoFactory.AniDB_Anime_Tag.GetByTagID(tag.TagID).FirstOrDefault();
if (animeXRef != null)
{
toAPI.Weight = animeXRef.Weight;
}
if (!excludeDescriptions)
{
toAPI.Description = tag.TagDescription;
}
tags.Add(toAPI);
}
return(tags);
}
public static List <Tag> GetTags(HttpContext ctx, SVR_AniDB_Anime anime, TagFilter.Filter filter, bool excludeDescriptions = false)
{
// TODO This is probably slow. Make it faster.
var tags = new List <Tag>();
var allTags = anime.GetAniDBTags().DistinctBy(a => a.TagName).ToDictionary(a => a.TagName, a => a);
var filteredTags = TagFilter.ProcessTags(filter, allTags.Keys.ToList());
foreach (string filteredTag in filteredTags)
{
AniDB_Tag tag = allTags.ContainsKey(filteredTag)
? allTags[filteredTag]
: RepoFactory.AniDB_Tag.GetByName(filteredTag).FirstOrDefault();
if (tag == null)
{
tags.Add(new Tag {
Name = filteredTag
});
continue;
}
var toAPI = new Tag
{
Name = tag.TagName
};
if (!excludeDescriptions)
{
toAPI.Description = tag.TagDescription;
}
tags.Add(toAPI);
}
return(tags);
}
public void TestFullListInverted()
{
TagFilter.Filter filter = TagFilter.Filter.Invert | TagFilter.Filter.Source | TagFilter.Filter.Genre | TagFilter.Filter.Setting;
var actual = TagFilter.String.ProcessTags(filter, Input);
var expected = new List <string>
{
"comedy",
"horror",
"18 restricted",
"japan",
"violence",
"manga",
"fantasy",
"shounen",
"alternative past",
};
_console.WriteLine(
"AniDB Internal: {0}, Art Style: {1}, Genre: {2}, Inverted: {3}, Misc: {4}, Plot: {5}, Programming: {6}, Setting: {7}, Source: {8}", filter.HasFlag(TagFilter.Filter.AnidbInternal), filter.HasFlag(TagFilter.Filter.ArtStyle),
filter.HasFlag(TagFilter.Filter.Genre), filter.HasFlag(TagFilter.Filter.Invert), filter.HasFlag(TagFilter.Filter.Misc), filter.HasFlag(TagFilter.Filter.Plot), filter.HasFlag(TagFilter.Filter.Programming),
filter.HasFlag(TagFilter.Filter.Setting), filter.HasFlag(TagFilter.Filter.Source)
);
_console.WriteLine("Expected: [{0}]", string.Join(", ", expected));
_console.WriteLine("Actual: [{0}]", string.Join(", ", actual));
Assert.Equal(expected, actual);
}
public ActionResult <List <Tag> > GetSeriesTags(int id, TagFilter.Filter filter)
{
var ser = RepoFactory.AnimeSeries.GetByID(id);
if (ser == null)
{
return(BadRequest("No Series with ID"));
}
var anime = ser.GetAnime();
if (anime == null)
{
return(BadRequest("No AniDB_Anime for Series"));
}
return(Series.GetTags(HttpContext, anime, filter));
}
public static Serie GenerateFromBookmark(HttpContext ctx, BookmarkedAnime bookmark, int uid, bool nocast, bool notag, int level, bool all, bool allpics, int pic, TagFilter.Filter tagfilter)
{
var series = Repo.Instance.AnimeSeries.GetByAnimeID(bookmark.AnimeID);
if (series != null)
{
return(GenerateFromAnimeSeries(ctx, series, uid, nocast, notag, level, all, allpics, pic, tagfilter));
}
SVR_AniDB_Anime aniDB_Anime = Repo.Instance.AniDB_Anime.GetByID(bookmark.AnimeID);
if (aniDB_Anime == null)
{
CommandQueue.Queue.Instance.Add(new CmdAniDBGetAnimeHTTP(bookmark.AnimeID, true, false));
Serie empty_serie = new Serie
{
id = -1,
name = "GetAnimeInfoHTTP",
aid = bookmark.AnimeID
};
return(empty_serie);
}
return(GenerateFromAniDB_Anime(ctx, aniDB_Anime, nocast, notag, allpics, pic, tagfilter));
}
public static Serie GenerateFromVideoLocal(NancyContext ctx, SVR_VideoLocal vl, int uid, bool nocast, bool notag, int level, bool all, bool allpics, int pic, TagFilter.Filter tagfilter)
{
Serie sr = new Serie();
if (vl == null)
{
return(sr);
}
var ser = vl.GetAnimeEpisodes().FirstOrDefault()?.GetAnimeSeries();
if (ser == null)
{
return(sr);
}
sr = GenerateFromAnimeSeries(ctx, ser, uid, nocast, notag, level, all, allpics, pic, tagfilter);
return(sr);
}
public static Serie GenerateFromBookmark(NancyContext ctx, BookmarkedAnime bookmark, int uid, bool nocast, bool notag, int level, bool all, bool allpics, int pic, TagFilter.Filter tagfilter)
{
var series = RepoFactory.AnimeSeries.GetByAnimeID(bookmark.AnimeID);
if (series != null)
{
return(GenerateFromAnimeSeries(ctx, series, uid, nocast, notag, level, all, allpics, pic, tagfilter));
}
SVR_AniDB_Anime aniDB_Anime = RepoFactory.AniDB_Anime.GetByAnimeID(bookmark.AnimeID);
if (aniDB_Anime == null)
{
Commands.CommandRequest_GetAnimeHTTP cr_anime = new Commands.CommandRequest_GetAnimeHTTP(bookmark.AnimeID, true, false);
cr_anime.Save();
Serie empty_serie = new Serie
{
id = -1,
name = "GetAnimeInfoHTTP",
aid = bookmark.AnimeID
};
return(empty_serie);
}
return(GenerateFromAniDB_Anime(ctx, aniDB_Anime, nocast, notag, allpics, pic, tagfilter));
}
public static Serie GenerateFromAniDB_Anime(NancyContext ctx, SVR_AniDB_Anime anime, bool nocast, bool notag, bool allpics, int pic, TagFilter.Filter tagfilter)
{
Serie sr = new Serie
{
// 0 will load all
id = -1,
aid = anime.AnimeID,
summary = anime.Description,
rating = Math.Round(anime.Rating / 100D, 1)
.ToString(CultureInfo.InvariantCulture),
votes = anime.VoteCount.ToString(),
name = anime.MainTitle,
ismovie = anime.AnimeType == (int)AnimeType.Movie ? 1 : 0
};
if (anime.AirDate != null)
{
sr.year = anime.AirDate.Value.Year.ToString();
var airdate = anime.AirDate.Value;
if (airdate != DateTime.MinValue)
{
sr.air = airdate.ToPlexDate();
}
}
AniDB_Vote vote = RepoFactory.AniDB_Vote.GetByEntityAndType(anime.AnimeID, AniDBVoteType.Anime) ??
RepoFactory.AniDB_Vote.GetByEntityAndType(anime.AnimeID, AniDBVoteType.AnimeTemp);
if (vote != null)
{
sr.userrating = Math.Round(vote.VoteValue / 100D, 1).ToString(CultureInfo.InvariantCulture);
}
sr.titles = anime.GetTitles().Select(title =>
new AnimeTitle {
Language = title.Language, Title = title.Title, Type = title.TitleType
}).ToList();
PopulateArtFromAniDBAnime(ctx, anime, sr, allpics, pic);
if (!nocast)
{
var xref_animestaff = RepoFactory.CrossRef_Anime_Staff.GetByAnimeIDAndRoleType(anime.AnimeID,
StaffRoleType.Seiyuu);
foreach (var xref in xref_animestaff)
{
if (xref.RoleID == null)
{
continue;
}
var character = RepoFactory.AnimeCharacter.GetByID(xref.RoleID.Value);
if (character == null)
{
continue;
}
var staff = RepoFactory.AnimeStaff.GetByID(xref.StaffID);
if (staff == null)
{
continue;
}
var role = new Role
{
character = character.Name,
character_image = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.Character,
xref.RoleID.Value),
staff = staff.Name,
staff_image = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.Staff,
xref.StaffID),
role = xref.Role,
type = ((StaffRoleType)xref.RoleType).ToString()
};
if (sr.roles == null)
{
sr.roles = new List <Role>();
}
sr.roles.Add(role);
}
}
if (!notag)
{
var tags = anime.GetAllTags();
if (tags != null)
{
sr.tags = TagFilter.ProcessTags(tagfilter, tags.ToList());
}
}
return(sr);
}
public static Serie GenerateFromAnimeSeries(NancyContext ctx, SVR_AnimeSeries ser, int uid, bool nocast, bool notag, int level, bool all, bool allpics, int pic, TagFilter.Filter tagfilter)
{
Serie sr = GenerateFromAniDB_Anime(ctx, ser.GetAnime(), nocast, notag, allpics, pic, tagfilter);
List <SVR_AnimeEpisode> ael = ser.GetAnimeEpisodes();
var contract = ser.Contract;
if (contract == null)
{
ser.UpdateContract();
}
sr.id = ser.AnimeSeriesID;
sr.name = ser.GetSeriesName();
GenerateSizes(sr, ael, uid);
int?season = ael.FirstOrDefault(a =>
a.AniDB_Episode.EpisodeType == (int)EpisodeType.Episode && a.AniDB_Episode.EpisodeNumber == 1)
?.TvDBEpisode?.SeasonNumber;
if (season != null)
{
sr.season = season.Value.ToString();
}
var tvdbseriesID = ael.Select(a => a.TvDBEpisode).Where(a => a != null).GroupBy(a => a.SeriesID)
.MaxBy(a => a.Count()).FirstOrDefault()?.Key;
if (tvdbseriesID != null)
{
var tvdbseries = RepoFactory.TvDB_Series.GetByTvDBID(tvdbseriesID.Value);
if (tvdbseries != null)
{
var title = new AnimeTitle {
Language = "EN", Title = tvdbseries.SeriesName, Type = "TvDB"
};
sr.titles.Add(title);
}
}
if (level > 0)
{
if (ael.Count > 0)
{
sr.eps = new List <Episode>();
foreach (SVR_AnimeEpisode ae in ael)
{
if (!all && (ae?.GetVideoLocals()?.Count ?? 0) == 0)
{
continue;
}
Episode new_ep = Episode.GenerateFromAnimeEpisode(ctx, ae, uid, (level - 1), pic);
if (new_ep == null)
{
continue;
}
sr.eps.Add(new_ep);
if (level - 1 <= 0)
{
continue;
}
foreach (RawFile file in new_ep.files)
{
sr.filesize += file.size;
}
}
sr.eps = sr.eps.OrderBy(a => a.epnumber).ToList();
}
}
return(sr);
}
internal new static Filter GenerateFromGroupFilter(HttpContext ctx, SVR_GroupFilter gf, int uid, bool nocast, bool notag, int level,
bool all, bool allpic, int pic, TagFilter.Filter tagfilter)
{
List <Group> groups = new List <Group>();
Filter filter = new Filter
{
name = gf.GroupFilterName,
id = gf.GroupFilterID,
size = 0
};
if (gf.GroupsIds.ContainsKey(uid))
{
HashSet <int> groupsh = gf.GroupsIds[uid];
if (groupsh.Count != 0)
{
filter.size = groupsh.Count;
// Populate Random Art
List <SVR_AnimeGroup> groupsList;
List <SVR_AnimeSeries> arts = null;
if (gf.SeriesIds.ContainsKey(uid))
{
var seriesList = gf.SeriesIds[uid].Select(Repo.Instance.AnimeSeries.GetByID).ToList();
groupsList = seriesList.Select(a => a.AnimeGroupID).Distinct()
.Select(Repo.Instance.AnimeGroup.GetByID).ToList();
if (pic == 1)
{
arts = seriesList.Where(SeriesHasCompleteArt).Where(a => a != null).ToList();
if (arts.Count == 0)
{
arts = seriesList.Where(SeriesHasMostlyCompleteArt).Where(a => a != null).ToList();
}
if (arts.Count == 0)
{
arts = seriesList;
}
}
}
else
{
groupsList = new List <SVR_AnimeGroup>();
}
if (arts?.Count > 0)
{
Random rand = new Random();
var anime = arts[rand.Next(arts.Count)];
var fanarts = GetFanartFromSeries(anime);
if (fanarts.Any())
{
var fanart = fanarts[rand.Next(fanarts.Count)];
filter.art.fanart.Add(new Art
{
index = 0,
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.TvDB_FanArt,
fanart.TvDB_ImageFanartID)
});
}
var banners = GetBannersFromSeries(anime);
if (banners.Any())
{
var banner = banners[rand.Next(banners.Count)];
filter.art.banner.Add(new Art()
{
index = 0,
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.TvDB_Banner,
banner.TvDB_ImageWideBannerID)
});
}
filter.art.thumb.Add(new Art()
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.AniDB_Cover,
anime.AniDB_ID),
index = 0
});
}
Dictionary <CL_AnimeGroup_User, Group> order = new Dictionary <CL_AnimeGroup_User, Group>();
if (level > 0)
{
foreach (SVR_AnimeGroup ag in groupsList)
{
Group group =
Group.GenerateFromAnimeGroup(ctx, ag, uid, nocast, notag, (level - 1), all,
filter.id, allpic, pic, tagfilter);
groups.Add(group);
order.Add(ag.GetUserContract(uid), group);
}
}
if (groups.Count > 0)
{
// Proper Sorting!
IEnumerable <CL_AnimeGroup_User> grps = order.Keys;
grps = gf.SortCriteriaList.Count != 0
? GroupFilterHelper.Sort(grps, gf)
: grps.OrderBy(a => a.GroupName);
groups = grps.Select(a => order[a]).ToList();
filter.groups = groups;
}
}
}
filter.viewed = 0;
filter.url = APIHelper.ConstructFilterIdUrl(ctx, filter.id);
return(filter);
}
public static Group GenerateFromAnimeGroup(HttpContext ctx, SVR_AnimeGroup ag, int uid, bool nocast, bool notag, int level,
bool all, int filterid, bool allpic, int pic, TagFilter.Filter tagfilter)
{
Group g = new Group
{
name = ag.GroupName,
id = ag.AnimeGroupID,
//g.videoqualities = ag.VideoQualities; <-- deadly trap
added = ag.DateTimeCreated,
edited = ag.DateTimeUpdated
};
SVR_GroupFilter filter = null;
if (filterid > 0)
{
filter = Repo.Instance.GroupFilter.GetByID(filterid);
if (filter?.ApplyToSeries == 0)
{
filter = null;
}
}
List <SVR_AniDB_Anime> animes;
if (filter != null)
{
animes = filter.SeriesIds[uid].Select(id => Repo.Instance.AnimeSeries.GetByID(id))
.Where(ser => ser?.AnimeGroupID == ag.AnimeGroupID).Select(ser => ser.GetAnime())
.Where(a => a != null).OrderBy(a => a.BeginYear).ThenBy(a => a.AirDate ?? DateTime.MaxValue)
.ToList();
}
else
{
animes = ag.Anime?.OrderBy(a => a.BeginYear).ThenBy(a => a.AirDate ?? DateTime.MaxValue).ToList();
}
if (animes != null && animes.Count > 0)
{
var anime = animes.FirstOrDefault(a => a != null);
if (anime == null)
{
return(g);
}
PopulateArtFromAniDBAnime(ctx, animes, g, allpic, pic);
List <SVR_AnimeEpisode> ael;
if (filter != null && filter.SeriesIds.ContainsKey(uid))
{
var series = filter.SeriesIds[uid].Select(id => Repo.Instance.AnimeSeries.GetByID(id))
.Where(ser => (ser?.AnimeGroupID ?? 0) == ag.AnimeGroupID).ToList();
ael = series.SelectMany(ser => ser?.GetAnimeEpisodes()).Where(a => a != null)
.ToList();
g.size = series.Count;
}
else
{
var series = ag.GetAllSeries();
ael = series.SelectMany(a => a?.GetAnimeEpisodes()).Where(a => a != null).ToList();
g.size = series.Count;
}
GenerateSizes(g, ael, uid);
g.air = anime.AirDate?.ToPlexDate() ?? string.Empty;
g.rating = Math.Round(ag.AniDBRating / 100, 1).ToString(CultureInfo.InvariantCulture);
g.summary = anime.Description ?? string.Empty;
g.titles = anime.GetTitles().Select(s => new Shoko.Models.PlexAndKodi.AnimeTitle()
{
Type = s.TitleType,
Language = s.Language,
Title = s.Language
}).ToList();//.ToAPIContract();
g.year = anime.BeginYear.ToString();
if (!notag && ag.Contract.Stat_AllTags != null)
{
g.tags = TagFilter.ProcessTags(tagfilter, ag.Contract.Stat_AllTags.ToList());
}
if (!nocast)
{
var xref_animestaff =
Repo.Instance.CrossRef_Anime_Staff.GetByAnimeIDAndRoleType(anime.AnimeID, StaffRoleType.Seiyuu);
foreach (var xref in xref_animestaff)
{
if (xref.RoleID == null)
{
continue;
}
var character = Repo.Instance.AnimeCharacter.GetByID(xref.RoleID.Value);
if (character == null)
{
continue;
}
var staff = Repo.Instance.AnimeStaff.GetByID(xref.StaffID);
if (staff == null)
{
continue;
}
var role = new Role
{
character = character.Name,
character_image = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.Character,
xref.RoleID.Value),
staff = staff.Name,
staff_image = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.Staff,
xref.StaffID),
role = xref.Role,
type = ((StaffRoleType)xref.RoleType).ToString()
};
if (g.roles == null)
{
g.roles = new List <Role>();
}
g.roles.Add(role);
}
}
}
if (level > 0)
{
List <int> series = null;
if (filter?.SeriesIds.ContainsKey(uid) == true)
{
series = filter.SeriesIds[uid].ToList();
}
foreach (SVR_AnimeSeries ada in ag.GetSeries())
{
if (series != null && series.Count > 0 && !series.Contains(ada.AnimeSeriesID))
{
continue;
}
g.series.Add(Serie.GenerateFromAnimeSeries(ctx, ada, uid, nocast, notag, (level - 1), all, allpic,
pic, tagfilter));
}
// This should be faster
g.series.Sort();
}
return(g);
}
internal static Filters GenerateFromGroupFilter(NancyContext ctx, SVR_GroupFilter gf, int uid, bool nocast, bool notag, int level,
bool all, bool allpic, int pic, TagFilter.Filter tagfilter)
{
Filters f = new Filters
{
id = gf.GroupFilterID,
name = gf.GroupFilterName
};
var _ = new List <string>();
var gfs = RepoFactory.GroupFilter.GetByParentID(f.id).AsParallel()
// Not invisible in clients
.Where(a => a.InvisibleInClients == 0 &&
// and Has groups or is a directory
((a.GroupsIds.ContainsKey(uid) && a.GroupsIds[uid].Count > 0) ||
(a.FilterType & (int)GroupFilterType.Directory) == (int)GroupFilterType.Directory) &&
// and is not a blacklisted tag
!((a.FilterType & (int)GroupFilterType.Tag) != 0 &&
TagFilter.IsTagBlackListed(a.GroupFilterName, tagfilter, ref _)));
if (_.Count > 0)
{
gfs = gfs.Concat(_.Select(tag => RepoFactory.GroupFilter.GetAll().FirstOrDefault(a =>
{
if (a.FilterType != (int)GroupFilterType.Tag)
{
return(false);
}
if (tag.Equals("Original Work"))
{
return(a.GroupFilterName.Equals("new"));
}
return(a.GroupFilterName.Equals(tag, StringComparison.InvariantCultureIgnoreCase));
})).AsParallel());
}
if (level > 0)
{
var filters = gfs.Select(cgf =>
Filter.GenerateFromGroupFilter(ctx, cgf, uid, nocast, notag, level - 1, all, allpic, pic,
tagfilter)).ToList();
if (gf.FilterType == ((int)GroupFilterType.Season | (int)GroupFilterType.Directory))
{
f.filters = filters.OrderBy(a => a.name, new SeasonComparator()).Cast <Filters>().ToList();
}
else
{
f.filters = filters.OrderByNatural(a => a.name).Cast <Filters>().ToList();
}
f.size = filters.Count;
}
else
{
f.size = gfs.Count();
}
f.url = APIHelper.ConstructFilterIdUrl(ctx, f.id);
return(f);
}
public static Group GenerateFromAnimeGroup(NancyContext ctx, SVR_AnimeGroup ag, int uid, bool nocast, bool notag, int level,
bool all, int filterid, bool allpic, int pic, TagFilter.Filter tagfilter)
{
Group g = new Group
{
name = ag.GroupName,
id = ag.AnimeGroupID,
//g.videoqualities = ag.VideoQualities; <-- deadly trap
added = ag.DateTimeCreated,
edited = ag.DateTimeUpdated
};
SVR_GroupFilter filter = null;
if (filterid > 0)
{
filter = RepoFactory.GroupFilter.GetByID(filterid);
if (filter?.ApplyToSeries == 0)
{
filter = null;
}
}
List <SVR_AniDB_Anime> animes;
if (filter != null)
{
animes = filter.SeriesIds[uid].Select(id => RepoFactory.AnimeSeries.GetByID(id))
.Where(ser => ser?.AnimeGroupID == ag.AnimeGroupID).Select(ser => ser.GetAnime())
.Where(a => a != null).OrderBy(a => a.BeginYear).ThenBy(a => a.AirDate ?? DateTime.MaxValue)
.ToList();
}
else
{
animes = ag.Anime?.OrderBy(a => a.BeginYear).ThenBy(a => a.AirDate ?? DateTime.MaxValue).ToList();
}
if (animes != null && animes.Count > 0)
{
var anime = animes.FirstOrDefault();
Random rand = new Random();
if (allpic || pic > 1)
{
if (allpic)
{
pic = 999;
}
int pic_index = 0;
foreach (var ani in animes)
{
foreach (var cont_image in ani.AllPosters)
{
if (pic_index < pic)
{
g.art.thumb.Add(new Art
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, cont_image.ImageType,
cont_image.AniDB_Anime_DefaultImageID),
index = pic_index
});
pic_index++;
}
else
{
break;
}
}
pic_index = 0;
foreach (var cont_image in ani.Contract.AniDBAnime.Fanarts)
{
if (pic_index < pic)
{
g.art.fanart.Add(new Art
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, cont_image.ImageType,
cont_image.AniDB_Anime_DefaultImageID),
index = pic_index
});
pic_index++;
}
else
{
break;
}
}
pic_index = 0;
foreach (var cont_image in ani.Contract.AniDBAnime.Banners)
{
if (pic_index < pic)
{
g.art.banner.Add(new Art
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, cont_image.ImageType,
cont_image.AniDB_Anime_DefaultImageID),
index = pic_index
});
pic_index++;
}
else
{
break;
}
}
}
}
else
{
g.art.thumb.Add(new Art
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.AniDB_Cover,
anime.AnimeID),
index = 0
});
var fanarts = anime.Contract.AniDBAnime.Fanarts;
if (fanarts != null && fanarts.Count > 0)
{
var art = fanarts[rand.Next(fanarts.Count)];
g.art.fanart.Add(new Art
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, art.ImageType,
art.AniDB_Anime_DefaultImageID),
index = 0
});
}
fanarts = anime.Contract.AniDBAnime.Banners;
if (fanarts != null && fanarts.Count > 0)
{
var art = fanarts[rand.Next(fanarts.Count)];
g.art.banner.Add(new Art
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, art.ImageType,
art.AniDB_Anime_DefaultImageID),
index = 0
});
}
}
List <SVR_AnimeEpisode> ael;
if (filter != null)
{
ael = filter.SeriesIds[uid].Select(id => RepoFactory.AnimeSeries.GetByID(id))
.Where(ser => ser?.AnimeGroupID == ag.AnimeGroupID).SelectMany(ser => ser.GetAnimeEpisodes())
.ToList();
}
else
{
ael = ag.GetAllSeries().SelectMany(a => a.GetAnimeEpisodes()).ToList();
}
GenerateSizes(g, ael, uid);
g.air = anime.AirDate?.ToPlexDate() ?? string.Empty;
g.rating = Math.Round(ag.AniDBRating / 100, 1).ToString(CultureInfo.InvariantCulture);
g.summary = anime.Description ?? string.Empty;
g.titles = anime.GetTitles().ToAPIContract();
g.year = anime.BeginYear.ToString();
if (!notag && ag.Contract.Stat_AllTags != null)
{
g.tags = TagFilter.ProcessTags(tagfilter, ag.Contract.Stat_AllTags.ToList());
}
if (!nocast)
{
var xref_animestaff =
RepoFactory.CrossRef_Anime_Staff.GetByAnimeIDAndRoleType(anime.AnimeID, StaffRoleType.Seiyuu);
foreach (var xref in xref_animestaff)
{
if (xref.RoleID == null)
{
continue;
}
var character = RepoFactory.AnimeCharacter.GetByID(xref.RoleID.Value);
if (character == null)
{
continue;
}
var staff = RepoFactory.AnimeStaff.GetByID(xref.StaffID);
if (staff == null)
{
continue;
}
var role = new Role
{
character = character.Name,
character_image = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.Character,
xref.RoleID.Value),
staff = staff.Name,
staff_image = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.Staff,
xref.StaffID),
role = xref.Role,
type = ((StaffRoleType)xref.RoleType).ToString()
};
if (g.roles == null)
{
g.roles = new List <Role>();
}
g.roles.Add(role);
}
}
}
if (level > 0)
{
List <int> series = null;
if (filter?.SeriesIds.ContainsKey(uid) == true)
{
series = filter.SeriesIds[uid].ToList();
}
foreach (SVR_AnimeSeries ada in ag.GetSeries())
{
if (series != null && series.Count > 0 && !series.Contains(ada.AnimeSeriesID))
{
continue;
}
g.series.Add(Serie.GenerateFromAnimeSeries(ctx, ada, uid, nocast, notag, (level - 1), all, allpic,
pic, (TagFilter.Filter)tagfilter));
}
// This should be faster
g.series.Sort();
}
return(g);
}
public static SearchResult GenerateFromAnimeSeries(HttpContext ctx, SVR_AnimeSeries ser, int uid, bool nocast, bool notag,
int level,
bool all, string match, bool allpic, int pic, TagFilter.Filter tagfilter)
{
Serie serie = GenerateFromAnimeSeries(ctx, ser, uid, nocast, notag, level, all, allpic, pic, tagfilter);
return(new SearchResult(serie, match));
}
public List <Tag> GetTopTags([FromQuery] int pageSize = 10, [FromQuery] int page = 0, [FromQuery] TagFilter.Filter filter = TagFilter.Filter.AnidbInternal | TagFilter.Filter.Misc | TagFilter.Filter.Source)
{
var tags = RepoFactory.AniDB_Anime_Tag.GetAllForLocalSeries().GroupBy(a => a.TagID)
.ToDictionary(a => a.Key, a => a.Count()).OrderByDescending(a => a.Value)
.Select(a => RepoFactory.AniDB_Tag.GetByTagID(a.Key))
.Where(a => a != null && !User.GetHideCategories().Contains(a.TagName)).Select(a => new Tag
{
Name = a.TagName,
Description = a.TagDescription,
Weight = 0
}).ToList();
if (pageSize <= 0)
{
return(new TagFilter <Tag>(tag => new Tag(tag), tag => tag.Name).ProcessTags(filter, tags).ToList());
}
if (page <= 0)
{
page = 0;
}
return(new TagFilter <Tag>(tag => new Tag(tag), tag => tag.Name).ProcessTags(filter, tags)
.Skip(pageSize * page).Take(pageSize).ToList());
}
public List <Tag> GetTopTagsObsolete(int number = 10, [FromQuery] TagFilter.Filter filter = TagFilter.Filter.AnidbInternal | TagFilter.Filter.Misc | TagFilter.Filter.Source) => GetTopTags(number, 0, filter);
public static Serie GenerateFromAniDB_Anime(NancyContext ctx, SVR_AniDB_Anime anime, int uid, bool nocast, bool notag, int level, bool all, bool allpics, int pic, TagFilter.Filter tagfilter)
{
SVR_AnimeSeries ser = RepoFactory.AnimeSeries.GetByAnimeID(anime.AnimeID) ?? anime.CreateAnimeSeriesAndGroup();
var sr = GenerateFromAnimeSeries(ctx, ser, uid, nocast, notag, level, all, allpics, pic, tagfilter);
return(sr);
}
internal static Filters GenerateFromGroupFilter(NancyContext ctx, SVR_GroupFilter gf, int uid, bool nocast, bool notag, bool all,
int level, bool allpic, int pic, TagFilter.Filter tagfilter)
{
Filters f = new Filters
{
id = gf.GroupFilterID,
name = gf.GroupFilterName
};
List <SVR_GroupFilter> allGfs = RepoFactory.GroupFilter.GetByParentID(f.id)
.Where(a => a.InvisibleInClients == 0 &&
((a.GroupsIds.ContainsKey(uid) && a.GroupsIds[uid].Count > 0) ||
(a.FilterType & (int)GroupFilterType.Directory) == (int)GroupFilterType.Directory))
.ToList();
List <Filter> filters = allGfs
.Where(cgf =>
(cgf.FilterType & (int)GroupFilterType.Tag) != (int)GroupFilterType.Tag ||
TagFilter.ProcessTags(tagfilter, new List <string> {
cgf.GroupFilterName
}, false).Count != 0)
.Select(cgf =>
Filter.GenerateFromGroupFilter(ctx, cgf, uid, nocast, notag, level - 1, all, allpic, pic,
tagfilter)).ToList();
if (gf.FilterType == ((int)GroupFilterType.Season | (int)GroupFilterType.Directory))
{
f.filters = filters.OrderBy(a => a.name, new SeasonComparator()).ToList();
}
else
{
f.filters = filters.OrderByNatural(a => a.name).ToList();
}
f.size = f.filters.Count();
f.url = APIHelper.ConstructFilterIdUrl(ctx, f.id);
return(f);
}
/// <summary>
/// Search for series with given query in name or tag
/// </summary>
/// <param name="query">target string</param>
/// <param name="userID">user id</param>
/// <param name="limit">The number of results to return</param>
/// <param name="flags">The SearchFlags to determine the type of search</param>
/// <returns>
/// <see cref="List{SearchResult}" />
/// </returns>
public static List <SearchResult> Search(int userID, string query, int limit, SearchFlags flags, TagFilter.Filter tagFilter = TagFilter.Filter.None)
{
query = query.ToLowerInvariant();
SVR_JMMUser user = RepoFactory.JMMUser.GetByID(userID);
if (user == null)
{
throw new Exception("User not found");
}
ParallelQuery <SVR_AnimeSeries> allSeries =
RepoFactory.AnimeSeries.GetAll().AsParallel().Where(a =>
a?.GetAnime() != null && (a.GetAnime().GetAllTags().Count == 0 || !a.GetAnime().GetAllTags().FindInEnumerable(user.GetHideCategories())));
ParallelQuery <AniDB_Tag> allTags = RepoFactory.AniDB_Tag.GetAll().AsParallel()
.Where(a =>
{
List <string> _ = new List <string>();
return(!user.GetHideCategories().Contains(a.TagName) &&
!TagFilter.IsTagBlackListed(a.TagName, tagFilter, ref _));
});
//search by anime id
if (int.TryParse(query, out int aid))
{
var aidResults = SearchTitlesByAnimeID(aid, allSeries);
if (aidResults.Count > 0)
{
return(aidResults);
}
}
#region Search_TitlesOnly
switch (flags)
{
case SearchFlags.Titles:
return(SearchTitlesIndexOf(query, limit, allSeries));
case SearchFlags.Fuzzy | SearchFlags.Titles:
return(SearchTitlesFuzzy(query, limit, allSeries));
case SearchFlags.Tags:
return(SearchTagsEquals(query, limit, user, allTags));
case SearchFlags.Fuzzy | SearchFlags.Tags:
return(SearchTagsFuzzy(query, limit, user, allTags));
case SearchFlags.Tags | SearchFlags.Titles:
List <SearchResult> titleResult = SearchTitlesIndexOf(query, limit, allSeries);
int tagLimit = limit - titleResult.Count;
if (tagLimit <= 0)
{
return(titleResult);
}
titleResult.AddRange(SearchTagsEquals(query, tagLimit, user, allTags));
return(titleResult);
case SearchFlags.Fuzzy | SearchFlags.Tags | SearchFlags.Titles:
List <SearchResult> titles = SearchTitlesFuzzy(query, limit, allSeries);
int tagLimit2 = limit - titles.Count;
if (tagLimit2 <= 0)
{
return(titles);
}
titles.AddRange(SearchTagsFuzzy(query, tagLimit2, user, allTags));
return(titles);
}
#endregion
return(new List <SearchResult>());
}
public static Serie GenerateFromAnimeSeries(NancyContext ctx, SVR_AnimeSeries ser, int uid, bool nocast, bool notag, int level, bool all, bool allpics, int pic, TagFilter.Filter tagfilter)
{
Serie sr = new Serie();
List <SVR_AnimeEpisode> ael = ser.GetAnimeEpisodes();
var contract = ser.Contract;
if (contract == null)
{
ser.UpdateContract();
}
sr.id = ser.AnimeSeriesID;
sr.summary = contract.AniDBAnime.AniDBAnime.Description;
sr.year = contract.AniDBAnime.AniDBAnime.BeginYear.ToString();
var airdate = ser.AirDate;
if (airdate != DateTime.MinValue)
{
sr.air = airdate.ToPlexDate();
}
GenerateSizes(sr, ael, uid);
sr.rating = Math.Round(contract.AniDBAnime.AniDBAnime.Rating / 100D, 1)
.ToString(CultureInfo.InvariantCulture);
AniDB_Vote vote = RepoFactory.AniDB_Vote.GetByEntityAndType(ser.AniDB_ID, AniDBVoteType.Anime) ??
RepoFactory.AniDB_Vote.GetByEntityAndType(ser.AniDB_ID, AniDBVoteType.AnimeTemp);
if (vote != null)
{
sr.userrating = Math.Round(vote.VoteValue / 100D, 1).ToString(CultureInfo.InvariantCulture);
}
sr.titles = ser.GetAnime().GetTitles().Select(title =>
new AnimeTitle {
Language = title.Language, Title = title.Title, Type = title.TitleType
}).ToList();
sr.name = ser.GetSeriesNameFromContract(contract);
var ls = contract.CrossRefAniDBTvDBV2?.OrderBy(a => a.TvDBSeasonNumber).FirstOrDefault();
if ((ls?.TvDBSeasonNumber ?? 0) != 0)
{
sr.season = ls.TvDBSeasonNumber.ToString();
}
if (contract.AniDBAnime.AniDBAnime.AnimeType == (int)AnimeType.Movie)
{
sr.ismovie = 1;
}
#region Images
var anime = ser.GetAnime();
if (anime != null)
{
Random rand = new Random();
if (allpics || pic > 1)
{
if (allpics)
{
pic = 999;
}
int pic_index = 0;
if (anime.AllPosters != null)
{
foreach (var cont_image in anime.AllPosters)
{
if (pic_index < pic)
{
sr.art.thumb.Add(new Art()
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, cont_image.ImageType,
cont_image.AniDB_Anime_DefaultImageID),
index = pic_index
});
pic_index++;
}
else
{
break;
}
}
}
pic_index = 0;
if (anime.Contract.AniDBAnime.Fanarts != null)
{
foreach (var cont_image in anime.Contract.AniDBAnime.Fanarts)
{
if (pic_index < pic)
{
sr.art.fanart.Add(new Art()
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, cont_image.ImageType,
cont_image.AniDB_Anime_DefaultImageID),
index = pic_index
});
pic_index++;
}
else
{
break;
}
}
}
pic_index = 0;
if (anime.Contract.AniDBAnime.Banners != null)
{
foreach (var cont_image in anime.Contract.AniDBAnime.Banners)
{
if (pic_index < pic)
{
sr.art.banner.Add(new Art()
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, cont_image.ImageType,
cont_image.AniDB_Anime_DefaultImageID),
index = pic_index
});
pic_index++;
}
else
{
break;
}
}
}
}
else
{
sr.art.thumb.Add(new Art()
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.AniDB_Cover,
anime.AnimeID),
index = 0
});
var fanarts = anime.Contract.AniDBAnime.Fanarts;
if (fanarts != null && fanarts.Count > 0)
{
var art = fanarts[rand.Next(fanarts.Count)];
sr.art.fanart.Add(new Art()
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, art.ImageType,
art.AniDB_Anime_DefaultImageID),
index = 0
});
}
fanarts = anime.Contract.AniDBAnime.Banners;
if (fanarts != null && fanarts.Count > 0)
{
var art = fanarts[rand.Next(fanarts.Count)];
sr.art.banner.Add(new Art()
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, art.ImageType,
art.AniDB_Anime_DefaultImageID),
index = 0
});
}
}
}
#endregion
if (!nocast)
{
var xref_animestaff = RepoFactory.CrossRef_Anime_Staff.GetByAnimeIDAndRoleType(ser.AniDB_ID,
StaffRoleType.Seiyuu);
foreach (var xref in xref_animestaff)
{
if (xref.RoleID == null)
{
continue;
}
var character = RepoFactory.AnimeCharacter.GetByID(xref.RoleID.Value);
if (character == null)
{
continue;
}
var staff = RepoFactory.AnimeStaff.GetByID(xref.StaffID);
if (staff == null)
{
continue;
}
var role = new Role
{
character = character.Name,
character_image = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.Character,
xref.RoleID.Value),
staff = staff.Name,
staff_image = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.Staff,
xref.StaffID),
role = xref.Role,
type = ((StaffRoleType)xref.RoleType).ToString()
};
if (sr.roles == null)
{
sr.roles = new List <Role>();
}
sr.roles.Add(role);
}
}
if (!notag)
{
var tags = ser.Contract.AniDBAnime.AniDBAnime.GetAllTags();
if (tags != null)
{
sr.tags = TagFilter.ProcessTags(tagfilter, tags.ToList());
}
}
if (level > 0)
{
if (ael.Count > 0)
{
sr.eps = new List <Episode>();
foreach (SVR_AnimeEpisode ae in ael)
{
if (!all && (ae?.GetVideoLocals()?.Count ?? 0) == 0)
{
continue;
}
Episode new_ep = Episode.GenerateFromAnimeEpisode(ctx, ae, uid, (level - 1));
if (new_ep != null)
{
sr.eps.Add(new_ep);
}
if (level - 1 > 0)
{
foreach (RawFile file in new_ep.files)
{
sr.filesize += file.size;
}
}
}
sr.eps = sr.eps.OrderBy(a => a.epnumber).ToList();
}
}
return(sr);
}
