public static void Populate(this TvDB_Episode episode, TvDbSharper.Dto.EpisodeRecord apiEpisode)
{
episode.Id = apiEpisode.Id;
episode.SeriesID = int.Parse(apiEpisode.SeriesId);
episode.SeasonID = 0;
episode.SeasonNumber = apiEpisode.AiredSeason ?? 0;
episode.EpisodeNumber = apiEpisode.AiredEpisodeNumber ?? 0;
int flag = 0;
if (apiEpisode.Filename != string.Empty)
{
flag = 1;
}
episode.EpImgFlag = flag;
episode.AbsoluteNumber = apiEpisode.AbsoluteNumber ?? 0;
episode.EpisodeName = apiEpisode.EpisodeName ?? string.Empty;
episode.Overview = apiEpisode.Overview;
episode.Filename = apiEpisode.Filename ?? string.Empty;
episode.AirsAfterSeason = apiEpisode.AirsAfterSeason;
episode.AirsBeforeEpisode = apiEpisode.AirsBeforeEpisode;
episode.AirsBeforeSeason = apiEpisode.AirsBeforeSeason;
if (apiEpisode.SiteRating != null)
{
episode.Rating = (int)Math.Round(apiEpisode.SiteRating.Value);
}
if (!string.IsNullOrEmpty(apiEpisode.FirstAired))
{
episode.AirDate = DateTime.ParseExact(apiEpisode.FirstAired, "yyyy-MM-dd", DateTimeFormatInfo.InvariantInfo);
}
}
public void DownloadTvDBEpisode(TvDB_Episode episode, bool forceDownload)
{
if (string.IsNullOrEmpty(episode.Filename))
{
return;
}
try
{
ImageDownloadRequest req = new ImageDownloadRequest(ImageEntityType.TvDB_Episode, episode, forceDownload);
// check if this file has already been downloaded and exists
if (!req.ForceDownload)
{
// check to make sure the file actually exists
if (!File.Exists(episode.GetFullImagePathPlain()))
{
imagesToDownload.Add(req);
OnQueueUpdateEvent(new QueueUpdateEventArgs(QueueCount));
return;
}
// the file exists so don't download it again
return;
}
imagesToDownload.Add(req);
OnQueueUpdateEvent(new QueueUpdateEventArgs(QueueCount));
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
}
public static string GetFullImagePathPlain(this TvDB_Episode tvDbEpisodeVm)
{
if (String.IsNullOrEmpty(tvDbEpisodeVm.Filename))
{
return(String.Empty);
}
return(Path.Combine(Utils.GetTvDBImagePath(), tvDbEpisodeVm.Filename.Replace("/", @"\")));
}
public static string GenPoster(this TvDB_Episode ep, IProvider prov)
{
if ((ep == null) || (ep.TvDB_EpisodeID == 0))
{
return(prov.ConstructSupportImageLink("plex_404.png"));
}
return(prov.ConstructThumbLink((int)ImageEntityType.TvDB_Episode, ep.TvDB_EpisodeID));
}
public static string GenPoster(this TvDB_Episode ep)
{
if ((ep == null) || (ep.TvDB_EpisodeID == 0))
{
return(Helper.ConstructSupportImageLink("plex_404.png"));
}
return(Helper.ConstructThumbLink((int)JMMImageType.TvDB_Episode, ep.TvDB_EpisodeID));
}
public static string GetOnlineImagePath(this TvDB_Episode tvDbEpisodeVm)
{
if (String.IsNullOrEmpty(tvDbEpisodeVm.Filename))
{
return("");
}
return(string.Format(Constants.URLS.TvDB_Images, tvDbEpisodeVm.Filename));
}
public TvDB_Episode GetByTvDBID(int id)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
TvDB_Episode cr = session
.CreateCriteria(typeof(TvDB_Episode))
.Add(Restrictions.Eq("Id", id))
.UniqueResult <TvDB_Episode>();
return(cr);
}
}
public LinkingEpisode(TvDB_Episode e, LinkingProvider prov)
{
Id = e.TvDB_EpisodeID.ToString();
Title = e.EpisodeName;
Season = e.SeasonNumber;
Number = e.EpisodeNumber;
AirDate = e.AirDate;
SeriesId = e.SeriesID.ToString();
Original = e;
_provider = prov;
}
public static string GetFullImagePath(this TvDB_Episode episode)
{
if (String.IsNullOrEmpty(episode.Filename))
{
return("");
}
string fname = episode.Filename;
fname = episode.Filename.Replace("/", @"\");
return(System.IO.Path.Combine(ImageUtils.GetTvDBImagePath(), fname));
}
public static string GetFullImagePath(this TvDB_Episode episode)
{
if (String.IsNullOrEmpty(episode.Filename))
{
return(string.Empty);
}
string fname = episode.Filename;
fname = episode.Filename.Replace("/", $"{System.IO.Path.DirectorySeparatorChar}");
return(System.IO.Path.Combine(ImageUtils.GetTvDBImagePath(), fname));
}
public void Save(TvDB_Episode obj)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
}
public static void Populate(this TvDB_Episode episode, XmlNode node)
{
// used when getting information from full series info
// http://thetvdb.com/api/B178B8940CAF4A2C/series/84187/all/en.xml
episode.Id = Int32.Parse(TryGetProperty(node, "id"));
episode.SeriesID = Int32.Parse(TryGetProperty(node, "seriesid"));
episode.SeasonID = Int32.Parse(TryGetProperty(node, "seasonid"));
episode.SeasonNumber = Int32.Parse(TryGetProperty(node, "SeasonNumber"));
episode.EpisodeNumber = Int32.Parse(TryGetProperty(node, "EpisodeNumber"));
if (Int32.TryParse(TryGetProperty(node, "EpImgFlag"), out int flag))
{
episode.EpImgFlag = flag;
}
if (Int32.TryParse(TryGetProperty(node, "absolute_number"), out int abnum))
{
episode.AbsoluteNumber = abnum;
}
episode.EpisodeName = TryGetProperty(node, "EpisodeName");
episode.Overview = TryGetProperty(node, "Overview");
episode.Filename = TryGetProperty(node, "filename");
//this.FirstAired = TryGetProperty(node, "FirstAired");
if (Int32.TryParse(TryGetProperty(node, "airsafter_season"), out int aas))
{
episode.AirsAfterSeason = aas;
}
else
{
episode.AirsAfterSeason = null;
}
if (Int32.TryParse(TryGetProperty(node, "airsbefore_episode"), out int abe))
{
episode.AirsBeforeEpisode = abe;
}
else
{
episode.AirsBeforeEpisode = null;
}
if (Int32.TryParse(TryGetProperty(node, "airsbefore_season"), out int abs))
{
episode.AirsBeforeSeason = abs;
}
else
{
episode.AirsBeforeSeason = null;
}
}
public static string GetFileURL(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case ImageEntityType.TvDB_Episode:
TvDB_Episode ep = req.ImageData as TvDB_Episode;
return(string.Format(Constants.URLS.TvDB_Images, ep.Filename));
case ImageEntityType.TvDB_FanArt:
TvDB_ImageFanart fanart = req.ImageData as TvDB_ImageFanart;
if (thumbNailOnly)
{
return(string.Format(Constants.URLS.TvDB_Images, fanart.ThumbnailPath));
}
else
{
return(string.Format(Constants.URLS.TvDB_Images, fanart.BannerPath));
}
case ImageEntityType.TvDB_Cover:
TvDB_ImagePoster poster = req.ImageData as TvDB_ImagePoster;
return(string.Format(Constants.URLS.TvDB_Images, poster.BannerPath));
case ImageEntityType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = req.ImageData as TvDB_ImageWideBanner;
return(string.Format(Constants.URLS.TvDB_Images, wideBanner.BannerPath));
case ImageEntityType.MovieDB_Poster:
MovieDB_Poster moviePoster = req.ImageData as MovieDB_Poster;
return(string.Format(Constants.URLS.MovieDB_Images, moviePoster.URL));
case ImageEntityType.MovieDB_FanArt:
MovieDB_Fanart movieFanart = req.ImageData as MovieDB_Fanart;
return(string.Format(Constants.URLS.MovieDB_Images, movieFanart.URL));
case ImageEntityType.AniDB_Cover:
SVR_AniDB_Anime anime = req.ImageData as SVR_AniDB_Anime;
return(string.Format(Constants.URLS.AniDB_Images, anime.Picname));
case ImageEntityType.AniDB_Character:
AniDB_Character chr = req.ImageData as AniDB_Character;
return(string.Format(Constants.URLS.AniDB_Images, chr.PicName));
case ImageEntityType.AniDB_Creator:
AniDB_Seiyuu creator = req.ImageData as AniDB_Seiyuu;
return(string.Format(Constants.URLS.AniDB_Images, creator.PicName));
default:
return(string.Empty);
}
}
/// <summary>
/// Get TVDB info from Anime Episode
/// </summary>
/// <param name="episode">Anime Episode reference</param>
/// <param name="seriesid">TVDB Series ID</param>
/// <param name="seasonidx">TVDB Season Number</param>
/// <param name="episodeidx">TVDB Episode Number</param>
/// <returns></returns>
public static bool GetTVDBEpisodeInfo(AnimeEpisode episode, out string seriesid, out int seasonidx, out int episodeidx)
{
seriesid = null;
seasonidx = 0;
episodeidx = 0;
if (episode.Series == null)
{
return(false);
}
seriesid = episode.Series.TvDB_ID.HasValue ? episode.Series.TvDB_ID.ToString() : null;
if (seriesid == null)
{
return(false);
}
// get air date in valid tvdb form
string episodeAirDate = episode.AniDB_Episode.AirDateAsDate.ToString("yyyy-MM-dd");
TvDB_Episode tvdbEpisode = null;
List <TvDB_Episode> tvdbEpisodes = episode.Series.TvDB_Episodes;
// episode Number is not absolute in some case e.g. multiple animeseries mapped to the same tvdb series
if (episode.Series.TvDB_SeasonNumber == null || episode.Series.TvDB_SeasonNumber == 1)
{
// first try absolute episode order
tvdbEpisode = tvdbEpisodes.FirstOrDefault(e => e.Absolute_number == episode.EpisodeNumber);
}
// try title / airdate matching, this should support specials
if (tvdbEpisode == null)
{
tvdbEpisode = tvdbEpisodes.FirstOrDefault(e => e.EpisodeName == episode.EpisodeName || e.FirstAired == episodeAirDate);
// try My Anime's helper, doesn't support specials
if (tvdbEpisode == null)
{
tvdbEpisode = episode.GetTvDBEpisode();
}
}
if (tvdbEpisode == null)
{
return(false);
}
seasonidx = tvdbEpisode.SeasonNumber;
episodeidx = tvdbEpisode.EpisodeNumber;
return(true);
}
private string GetFileName(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case ImageEntityType.AniDB_Cover:
SVR_AniDB_Anime anime = req.ImageData as SVR_AniDB_Anime;
return(anime.PosterPath);
case ImageEntityType.TvDB_Episode:
TvDB_Episode ep = req.ImageData as TvDB_Episode;
return(ep.GetFullImagePath());
case ImageEntityType.TvDB_FanArt:
TvDB_ImageFanart fanart = req.ImageData as TvDB_ImageFanart;
if (thumbNailOnly)
{
return(fanart.GetFullThumbnailPath());
}
else
{
return(fanart.GetFullImagePath());
}
case ImageEntityType.TvDB_Cover:
TvDB_ImagePoster poster = req.ImageData as TvDB_ImagePoster;
return(poster.GetFullImagePath());
case ImageEntityType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = req.ImageData as TvDB_ImageWideBanner;
return(wideBanner.GetFullImagePath());
case ImageEntityType.MovieDB_Poster:
MovieDB_Poster moviePoster = req.ImageData as MovieDB_Poster;
return(moviePoster.GetFullImagePath());
case ImageEntityType.MovieDB_FanArt:
MovieDB_Fanart movieFanart = req.ImageData as MovieDB_Fanart;
return(movieFanart.GetFullImagePath());
case ImageEntityType.AniDB_Character:
AniDB_Character chr = req.ImageData as AniDB_Character;
return(chr.GetPosterPath());
case ImageEntityType.AniDB_Creator:
AniDB_Seiyuu creator = req.ImageData as AniDB_Seiyuu;
return(creator.GetPosterPath());
default:
return(string.Empty);
}
}
private static TvDB_Episode GetTvDBEpisodeFromAniDB(ISession session, AniDB_Episode aep, CrossRef_AniDB_TvDBV2 xref_tvdb2)
{
int epnumber = (aep.EpisodeNumber + xref_tvdb2.TvDBStartEpisodeNumber - 1) -
(xref_tvdb2.AniDBStartEpisodeNumber - 1);
TvDB_Episode tvep = null;
int season = xref_tvdb2.TvDBSeasonNumber;
List <TvDB_Episode> tvdb_eps = RepoFactory.TvDB_Episode.GetBySeriesIDAndSeasonNumber(xref_tvdb2.TvDBID, season);
tvep = tvdb_eps.Find(a => a.EpisodeNumber == epnumber);
if (tvep != null)
{
return(tvep);
}
int lastSeason = RepoFactory.TvDB_Episode.getLastSeasonForSeries(xref_tvdb2.TvDBID);
int previousSeasonsCount = 0;
// we checked once, so increment the season
season++;
previousSeasonsCount += tvdb_eps.Count;
do
{
if (season == 0)
{
break; // Specials will often be wrong
}
if (season > lastSeason)
{
break;
}
if (epnumber - previousSeasonsCount <= 0)
{
break;
}
// This should be 1 or 0, hopefully 1
tvdb_eps = RepoFactory.TvDB_Episode.GetBySeriesIDAndSeasonNumber(xref_tvdb2.TvDBID, season);
tvep = tvdb_eps.Find(a => a.EpisodeNumber == epnumber - previousSeasonsCount);
AddCrossRef_AniDB_TvDBV2(session, aep.AnimeID, previousSeasonsCount + 1, xref_tvdb2.TvDBID, season, xref_tvdb2.GetTvDBSeries()?.SeriesName ?? "");
if (tvep != null)
{
break;
}
previousSeasonsCount += tvdb_eps.Count;
season++;
} while (true);
return(tvep);
}
public static int GetAbsoluteEpisodeNumber(this TvDB_Episode ep)
{
if (ep.SeasonNumber == 1 || ep.SeasonNumber == 0)
{
return(ep.EpisodeNumber);
}
int number = ep.EpisodeNumber;
for (int season = 1; season < RepoFactory.TvDB_Episode.getLastSeasonForSeries(ep.SeriesID); season++)
{
number += RepoFactory.TvDB_Episode.GetNumberOfEpisodesForSeason(ep.SeriesID, ep.SeasonNumber);
}
return(number);
}
public static void Populate(this TvDB_Episode episode, int seriesId, TvDbSharper.Clients.Series.Json.BasicEpisode apiEpisode)
{
// used when getting information from episode info
// http://thetvdb.com/api/B178B8940CAF4A2C/episodes/306542/en.xml
episode.Id = apiEpisode.Id;
episode.SeriesID = seriesId;
episode.SeasonID = 0;
episode.SeasonNumber = apiEpisode.AiredSeason ?? 0;
episode.EpisodeNumber = apiEpisode.AiredEpisodeNumber ?? 0;
episode.EpImgFlag = 0;
episode.AbsoluteNumber = apiEpisode.AbsoluteNumber ?? 0;
episode.EpisodeName = apiEpisode.EpisodeName;
episode.Overview = apiEpisode.Overview;
}
public void Delete(int id)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
TvDB_Episode cr = GetByID(id);
if (cr != null)
{
session.Delete(cr);
transaction.Commit();
}
}
}
}
public static (int season, int episodeNumber) GetPreviousEpisode(this TvDB_Episode ep)
{
// check bounds and exit
if (ep.SeasonNumber == 1 && ep.EpisodeNumber == 1)
{
return(0, 0);
}
// self explanatory
if (ep.EpisodeNumber > 1)
{
return(ep.SeasonNumber, ep.EpisodeNumber - 1);
}
// episode number is 1
// get the last episode of last season
int epsInSeason = RepoFactory.TvDB_Episode.GetNumberOfEpisodesForSeason(ep.SeriesID, ep.SeasonNumber - 1);
return(ep.SeasonNumber - 1, epsInSeason);
}
public static string GetFullImagePath(this TvDB_Episode tvDbEpisodeVm)
{
if (String.IsNullOrEmpty(tvDbEpisodeVm.GetFullImagePathPlain()))
{
return(tvDbEpisodeVm.GetFullImagePathPlain());
}
if (!File.Exists(tvDbEpisodeVm.GetFullImagePathPlain()))
{
ImageDownloadRequest req = new ImageDownloadRequest(ImageEntityType.TvDB_Episode, tvDbEpisodeVm, false);
MainWindow.imageHelper.DownloadImage(req);
if (File.Exists(tvDbEpisodeVm.GetFullImagePathPlain()))
{
return(tvDbEpisodeVm.GetFullImagePathPlain());
}
}
return(tvDbEpisodeVm.GetFullImagePathPlain());
}
public static (int season, int episodeNumber) GetNextEpisode(this TvDB_Episode ep)
{
if (ep == null)
{
return(0, 0);
}
int epsInSeason = RepoFactory.TvDB_Episode.GetNumberOfEpisodesForSeason(ep.SeriesID, ep.SeasonNumber);
if (ep.EpisodeNumber == epsInSeason)
{
int numberOfSeasons = RepoFactory.TvDB_Episode.getLastSeasonForSeries(ep.SeriesID);
if (ep.SeasonNumber == numberOfSeasons)
{
return(0, 0);
}
return(ep.SeasonNumber + 1, 1);
}
return(ep.SeasonNumber, ep.EpisodeNumber + 1);
}
public static void LinkAniDBTvDBEpisode(int aniDBID, int tvDBID)
{
AniDB_Episode ep = Repo.Instance.AniDB_Episode.GetByEpisodeID(aniDBID);
TvDB_Episode tvep = Repo.Instance.TvDB_Episode.GetByID(tvDBID);
using (var upd = Repo.Instance.CrossRef_AniDB_Provider.BeginAddOrUpdate(() => Repo.Instance.CrossRef_AniDB_Provider.GetByAnimeIdAndProvider(CrossRefType.TvDB, ep.AnimeID, tvep.SeriesID.ToString())))
{
upd.Entity.EpisodesListOverride.AddOrUpdate(aniDBID, tvDBID.ToString(), tvep.SeasonNumber, ep.EpisodeNumber, ep.GetEpisodeTypeEnum(), MatchRating.UserVerified);
if (upd.Entity.EpisodesListOverride.NeedPersitance)
{
upd.Commit();
}
}
using (var upd = Repo.Instance.AnimeEpisode.BeginAddOrUpdate(() => Repo.Instance.AnimeEpisode.GetByAniDBEpisodeID(aniDBID)))
{
SVR_AniDB_Anime.UpdateStatsByAnimeID(ep.AnimeID);
upd.Commit();
}
logger.Trace($"Changed tvdb episode association: {aniDBID}");
}
public TvDB(TvDB_Episode tvDBEpisode)
{
Rating rating = tvDBEpisode.Rating == null ? null : new Rating
{
MaxValue = 10,
Value = tvDBEpisode.Rating.Value,
Source = "TvDB",
};
ID = tvDBEpisode.Id;
Season = tvDBEpisode.SeasonNumber;
Number = tvDBEpisode.EpisodeNumber;
AbsoluteNumber = tvDBEpisode.AbsoluteNumber ?? 0;
Title = tvDBEpisode.EpisodeName;
Description = tvDBEpisode.Overview;
AirDate = tvDBEpisode.AirDate;
Rating = rating;
AirsAfterSeason = tvDBEpisode.AirsAfterSeason ?? 0;
AirsBeforeSeason = tvDBEpisode.AirsBeforeSeason ?? 0;
AirsBeforeEpisode = tvDBEpisode.AirsBeforeEpisode ?? 0;
Thumbnail = (new Image(tvDBEpisode.Id, ImageEntityType.TvDB_Episode, true));
}
public static void Populate(this TvDB_Episode episode, TvDbSharper.Clients.Episodes.Json.EpisodeRecord apiEpisode)
{
episode.Id = apiEpisode.Id;
episode.SeriesID = Int32.Parse(apiEpisode.SeriesId);
episode.SeasonID = 0;
episode.SeasonNumber = apiEpisode.AiredSeason ?? 0;
episode.EpisodeNumber = apiEpisode.AiredEpisodeNumber ?? 0;
int flag = 0;
if (apiEpisode.Filename != String.Empty)
{
flag = 1;
}
episode.EpImgFlag = flag;
episode.AbsoluteNumber = apiEpisode.AbsoluteNumber ?? 0;
episode.EpisodeName = apiEpisode.EpisodeName;
episode.Overview = apiEpisode.Overview;
episode.Filename = apiEpisode.Filename;
episode.AirsAfterSeason = apiEpisode.AirsAfterSeason;
episode.AirsBeforeEpisode = apiEpisode.AirsBeforeEpisode;
episode.AirsBeforeSeason = apiEpisode.AirsBeforeSeason;
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_DownloadImage: {0}", EntityID);
string downloadURL = "";
try
{
ImageDownloadRequest req = null;
switch (EntityTypeEnum)
{
case JMMImageType.AniDB_Cover:
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByID(EntityID);
if (anime == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, anime, ForceDownload);
break;
case JMMImageType.TvDB_Episode:
TvDB_EpisodeRepository repTvEp = new TvDB_EpisodeRepository();
TvDB_Episode ep = repTvEp.GetByID(EntityID);
if (ep == null)
{
return;
}
if (string.IsNullOrEmpty(ep.Filename))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, ep, ForceDownload);
break;
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanartRepository repFanart = new TvDB_ImageFanartRepository();
TvDB_ImageFanart fanart = repFanart.GetByID(EntityID);
if (fanart == null)
{
return;
}
if (string.IsNullOrEmpty(fanart.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, fanart, ForceDownload);
break;
case JMMImageType.TvDB_Cover:
TvDB_ImagePosterRepository repPoster = new TvDB_ImagePosterRepository();
TvDB_ImagePoster poster = repPoster.GetByID(EntityID);
if (poster == null)
{
return;
}
if (string.IsNullOrEmpty(poster.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, poster, ForceDownload);
break;
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBannerRepository repBanners = new TvDB_ImageWideBannerRepository();
TvDB_ImageWideBanner wideBanner = repBanners.GetByID(EntityID);
if (wideBanner == null)
{
return;
}
if (string.IsNullOrEmpty(wideBanner.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, wideBanner, ForceDownload);
break;
case JMMImageType.MovieDB_Poster:
MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
MovieDB_Poster moviePoster = repMoviePosters.GetByID(EntityID);
if (moviePoster == null)
{
return;
}
if (string.IsNullOrEmpty(moviePoster.URL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, moviePoster, ForceDownload);
break;
case JMMImageType.MovieDB_FanArt:
MovieDB_FanartRepository repMovieFanart = new MovieDB_FanartRepository();
MovieDB_Fanart movieFanart = repMovieFanart.GetByID(EntityID);
if (movieFanart == null)
{
return;
}
if (string.IsNullOrEmpty(movieFanart.URL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, movieFanart, ForceDownload);
break;
case JMMImageType.Trakt_Poster:
Trakt_ImagePosterRepository repTraktPosters = new Trakt_ImagePosterRepository();
Trakt_ImagePoster traktPoster = repTraktPosters.GetByID(EntityID);
if (traktPoster == null)
{
return;
}
if (string.IsNullOrEmpty(traktPoster.ImageURL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktPoster, ForceDownload);
break;
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanartRepository repTraktFanarts = new Trakt_ImageFanartRepository();
Trakt_ImageFanart traktFanart = repTraktFanarts.GetByID(EntityID);
if (traktFanart == null)
{
return;
}
if (string.IsNullOrEmpty(traktFanart.ImageURL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktFanart, ForceDownload);
break;
case JMMImageType.Trakt_Friend:
Trakt_FriendRepository repFriends = new Trakt_FriendRepository();
Trakt_Friend friend = repFriends.GetByID(EntityID);
if (friend == null)
{
return;
}
if (string.IsNullOrEmpty(friend.Avatar))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, friend, ForceDownload);
break;
case JMMImageType.Trakt_Episode:
Trakt_EpisodeRepository repTraktEpisodes = new Trakt_EpisodeRepository();
Trakt_Episode traktEp = repTraktEpisodes.GetByID(EntityID);
if (traktEp == null)
{
return;
}
if (string.IsNullOrEmpty(traktEp.EpisodeImage))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktEp, ForceDownload);
break;
case JMMImageType.AniDB_Character:
AniDB_CharacterRepository repChars = new AniDB_CharacterRepository();
AniDB_Character chr = repChars.GetByID(EntityID);
if (chr == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, chr, ForceDownload);
break;
case JMMImageType.AniDB_Creator:
AniDB_SeiyuuRepository repCreator = new AniDB_SeiyuuRepository();
AniDB_Seiyuu creator = repCreator.GetByID(EntityID);
if (creator == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, creator, ForceDownload);
break;
}
if (req == null)
{
return;
}
List <string> fileNames = new List <string>();
List <string> downloadURLs = new List <string>();
string fileNameTemp = GetFileName(req, false);
string downloadURLTemp = GetFileURL(req, false);
fileNames.Add(fileNameTemp);
downloadURLs.Add(downloadURLTemp);
if (req.ImageType == JMMImageType.TvDB_FanArt)
{
fileNameTemp = GetFileName(req, true);
downloadURLTemp = GetFileURL(req, true);
fileNames.Add(fileNameTemp);
downloadURLs.Add(downloadURLTemp);
}
for (int i = 0; i < fileNames.Count; i++)
{
string fileName = fileNames[i];
downloadURL = downloadURLs[i];
bool downloadImage = true;
bool fileExists = File.Exists(fileName);
if (fileExists)
{
if (!req.ForceDownload)
{
downloadImage = false;
}
else
{
downloadImage = true;
}
}
else
{
downloadImage = true;
}
if (downloadImage)
{
string tempName = Path.Combine(ImageUtils.GetImagesTempFolder(), Path.GetFileName(fileName));
if (File.Exists(tempName))
{
File.Delete(tempName);
}
try
{
if (fileExists)
{
File.Delete(fileName);
}
}
catch (Exception ex)
{
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(ServerSettings.Culture);
string msg = string.Format(JMMServer.Properties.Resources.Command_DeleteError, fileName,
ex.Message);
logger.Warn(msg);
return;
}
// download image
using (WebClient client = new WebClient())
{
client.Headers.Add("user-agent", "JMM");
//OnImageDownloadEvent(new ImageDownloadEventArgs("", req, ImageDownloadEventType.Started));
//BaseConfig.MyAnimeLog.Write("ProcessImages: Download: {0} *** to *** {1}", req.URL, fullName);
if (downloadURL.Length > 0)
{
client.DownloadFile(downloadURL, tempName);
string extension = "";
string contentType = client.ResponseHeaders["Content-type"].ToLower();
if (contentType.IndexOf("gif") >= 0)
{
extension = ".gif";
}
if (contentType.IndexOf("jpg") >= 0)
{
extension = ".jpg";
}
if (contentType.IndexOf("jpeg") >= 0)
{
extension = ".jpg";
}
if (contentType.IndexOf("bmp") >= 0)
{
extension = ".bmp";
}
if (contentType.IndexOf("png") >= 0)
{
extension = ".png";
}
if (extension.Length > 0)
{
string newFile = Path.ChangeExtension(tempName, extension);
if (!newFile.ToLower().Equals(tempName.ToLower()))
{
try
{
System.IO.File.Delete(newFile);
}
catch
{
//BaseConfig.MyAnimeLog.Write("DownloadedImage:Download() Delete failed:{0}", newFile);
}
System.IO.File.Move(tempName, newFile);
tempName = newFile;
}
}
}
}
// move the file to it's final location
// check that the final folder exists
string fullPath = Path.GetDirectoryName(fileName);
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
System.IO.File.Move(tempName, fileName);
logger.Info("Image downloaded: {0}", fileName);
}
}
}
catch (Exception ex)
{
logger.Warn("Error processing CommandRequest_DownloadImage: {0} ({1}) - {2}", downloadURL, EntityID,
ex.Message);
return;
}
}
private string GetFileName(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = req.ImageData as AniDB_Anime;
return(anime.PosterPath);
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = req.ImageData as TvDB_Episode;
return(ep.FullImagePath);
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = req.ImageData as TvDB_ImageFanart;
if (thumbNailOnly)
{
return(fanart.FullThumbnailPath);
}
else
{
return(fanart.FullImagePath);
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = req.ImageData as TvDB_ImagePoster;
return(poster.FullImagePath);
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = req.ImageData as TvDB_ImageWideBanner;
return(wideBanner.FullImagePath);
case JMMImageType.MovieDB_Poster:
MovieDB_Poster moviePoster = req.ImageData as MovieDB_Poster;
return(moviePoster.FullImagePath);
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart movieFanart = req.ImageData as MovieDB_Fanart;
return(movieFanart.FullImagePath);
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster traktPoster = req.ImageData as Trakt_ImagePoster;
return(traktPoster.FullImagePath);
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart traktFanart = req.ImageData as Trakt_ImageFanart;
return(traktFanart.FullImagePath);
case JMMImageType.Trakt_Friend:
Trakt_Friend traktFriend = req.ImageData as Trakt_Friend;
return(traktFriend.FullImagePath);
case JMMImageType.Trakt_Episode:
Trakt_Episode traktEp = req.ImageData as Trakt_Episode;
return(traktEp.FullImagePath);
case JMMImageType.AniDB_Character:
AniDB_Character chr = req.ImageData as AniDB_Character;
return(chr.PosterPath);
case JMMImageType.AniDB_Creator:
AniDB_Seiyuu creator = req.ImageData as AniDB_Seiyuu;
return(creator.PosterPath);
default:
return("");
}
}
public System.IO.Stream GetImage(string ImageType, string ImageID)
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
TvDB_ImagePosterRepository repPosters = new TvDB_ImagePosterRepository();
TvDB_EpisodeRepository repEpisodes = new TvDB_EpisodeRepository();
TvDB_ImageFanartRepository repFanart = new TvDB_ImageFanartRepository();
TvDB_ImageWideBannerRepository repWideBanners = new TvDB_ImageWideBannerRepository();
MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
MovieDB_FanartRepository repMovieFanart = new MovieDB_FanartRepository();
Trakt_ImageFanartRepository repTraktFanart = new Trakt_ImageFanartRepository();
Trakt_ImagePosterRepository repTraktPosters = new Trakt_ImagePosterRepository();
Trakt_EpisodeRepository repTraktEpisodes = new Trakt_EpisodeRepository();
Trakt_FriendRepository repTraktFriends = new Trakt_FriendRepository();
JMMImageType imageType = (JMMImageType)int.Parse(ImageType);
switch (imageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = repAnime.GetByAnimeID(int.Parse(ImageID));
if (anime == null)
{
return(null);
}
if (File.Exists(anime.PosterPath))
{
FileStream fs = File.OpenRead(anime.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Cover image: {0}", anime.PosterPath);
return(BlankImage());
}
case JMMImageType.AniDB_Character:
AniDB_CharacterRepository repChar = new AniDB_CharacterRepository();
AniDB_Character chr = repChar.GetByID(int.Parse(ImageID));
if (chr == null)
{
return(null);
}
if (File.Exists(chr.PosterPath))
{
FileStream fs = File.OpenRead(chr.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Character image: {0}", chr.PosterPath);
return(BlankImage());
}
case JMMImageType.AniDB_Creator:
AniDB_SeiyuuRepository repCreator = new AniDB_SeiyuuRepository();
AniDB_Seiyuu creator = repCreator.GetByID(int.Parse(ImageID));
if (creator == null)
{
return(null);
}
if (File.Exists(creator.PosterPath))
{
FileStream fs = File.OpenRead(creator.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Creator image: {0}", creator.PosterPath);
return(BlankImage());
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = repPosters.GetByID(int.Parse(ImageID));
if (poster == null)
{
return(null);
}
if (File.Exists(poster.FullImagePath))
{
FileStream fs = File.OpenRead(poster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Cover image: {0}", poster.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = repWideBanners.GetByID(int.Parse(ImageID));
if (wideBanner == null)
{
return(null);
}
if (File.Exists(wideBanner.FullImagePath))
{
FileStream fs = File.OpenRead(wideBanner.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Banner image: {0}", wideBanner.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = repEpisodes.GetByID(int.Parse(ImageID));
if (ep == null)
{
return(null);
}
if (File.Exists(ep.FullImagePath))
{
FileStream fs = File.OpenRead(ep.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Episode image: {0}", ep.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = repFanart.GetByID(int.Parse(ImageID));
if (fanart == null)
{
return(null);
}
if (File.Exists(fanart.FullImagePath))
{
FileStream fs = File.OpenRead(fanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.MovieDB_Poster:
MovieDB_Poster mPoster = repMoviePosters.GetByID(int.Parse(ImageID));
if (mPoster == null)
{
return(null);
}
// now find only the original size
mPoster = repMoviePosters.GetByOnlineID(mPoster.URL);
if (mPoster == null)
{
return(null);
}
if (File.Exists(mPoster.FullImagePath))
{
FileStream fs = File.OpenRead(mPoster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find MovieDB_Poster image: {0}", mPoster.FullImagePath);
return(BlankImage());
}
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart mFanart = repMovieFanart.GetByID(int.Parse(ImageID));
if (mFanart == null)
{
return(null);
}
mFanart = repMovieFanart.GetByOnlineID(mFanart.URL);
if (mFanart == null)
{
return(null);
}
if (File.Exists(mFanart.FullImagePath))
{
FileStream fs = File.OpenRead(mFanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find MovieDB_FanArt image: {0}", mFanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart tFanart = repTraktFanart.GetByID(int.Parse(ImageID));
if (tFanart == null)
{
return(null);
}
if (File.Exists(tFanart.FullImagePath))
{
FileStream fs = File.OpenRead(tFanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Fanart image: {0}", tFanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster tPoster = repTraktPosters.GetByID(int.Parse(ImageID));
if (tPoster == null)
{
return(null);
}
if (File.Exists(tPoster.FullImagePath))
{
FileStream fs = File.OpenRead(tPoster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Poster image: {0}", tPoster.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Episode:
case JMMImageType.Trakt_WatchedEpisode:
Trakt_Episode tEpisode = repTraktEpisodes.GetByID(int.Parse(ImageID));
if (tEpisode == null)
{
return(null);
}
if (File.Exists(tEpisode.FullImagePath))
{
FileStream fs = File.OpenRead(tEpisode.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Episode image: {0}", tEpisode.FullImagePath);
return(BlankImage());
}
default:
return(BlankImage());
}
}
public string GetImagePath(string ImageType, string ImageID, bool thumnbnailOnly)
{
JMMImageType imageType = (JMMImageType)int.Parse(ImageType);
switch (imageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(int.Parse(ImageID));
if (anime == null)
{
return(null);
}
if (File.Exists(anime.PosterPath))
{
return(anime.PosterPath);
}
else
{
logger.Trace("Could not find AniDB_Cover image: {0}", anime.PosterPath);
return("");
}
case JMMImageType.AniDB_Character:
AniDB_Character chr = RepoFactory.AniDB_Character.GetByID(int.Parse(ImageID));
if (chr == null)
{
return(null);
}
if (File.Exists(chr.PosterPath))
{
return(chr.PosterPath);
}
else
{
logger.Trace("Could not find AniDB_Character image: {0}", chr.PosterPath);
return("");
}
case JMMImageType.AniDB_Creator:
AniDB_Seiyuu creator = RepoFactory.AniDB_Seiyuu.GetByID(int.Parse(ImageID));
if (creator == null)
{
return("");
}
if (File.Exists(creator.PosterPath))
{
return(creator.PosterPath);
}
else
{
logger.Trace("Could not find AniDB_Creator image: {0}", creator.PosterPath);
return("");
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = RepoFactory.TvDB_ImagePoster.GetByID(int.Parse(ImageID));
if (poster == null)
{
return(null);
}
if (File.Exists(poster.FullImagePath))
{
return(poster.FullImagePath);
}
else
{
logger.Trace("Could not find TvDB_Cover image: {0}", poster.FullImagePath);
return("");
}
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = RepoFactory.TvDB_ImageWideBanner.GetByID(int.Parse(ImageID));
if (wideBanner == null)
{
return(null);
}
if (File.Exists(wideBanner.FullImagePath))
{
return(wideBanner.FullImagePath);
}
else
{
logger.Trace("Could not find TvDB_Banner image: {0}", wideBanner.FullImagePath);
return("");
}
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = RepoFactory.TvDB_Episode.GetByID(int.Parse(ImageID));
if (ep == null)
{
return(null);
}
if (File.Exists(ep.FullImagePath))
{
return(ep.FullImagePath);
}
else
{
logger.Trace("Could not find TvDB_Episode image: {0}", ep.FullImagePath);
return("");
}
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = RepoFactory.TvDB_ImageFanart.GetByID(int.Parse(ImageID));
if (fanart == null)
{
return(null);
}
if (thumnbnailOnly)
{
if (File.Exists(fanart.FullThumbnailPath))
{
return(fanart.FullThumbnailPath);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullThumbnailPath);
return("");
}
}
else
{
if (File.Exists(fanart.FullImagePath))
{
return(fanart.FullImagePath);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullImagePath);
return("");
}
}
case JMMImageType.MovieDB_Poster:
MovieDB_Poster mPoster = RepoFactory.MovieDB_Poster.GetByID(int.Parse(ImageID));
if (mPoster == null)
{
return(null);
}
// now find only the original size
mPoster = RepoFactory.MovieDB_Poster.GetByOnlineID(mPoster.URL);
if (mPoster == null)
{
return(null);
}
if (File.Exists(mPoster.FullImagePath))
{
return(mPoster.FullImagePath);
}
else
{
logger.Trace("Could not find MovieDB_Poster image: {0}", mPoster.FullImagePath);
return("");
}
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart mFanart = RepoFactory.MovieDB_Fanart.GetByID(int.Parse(ImageID));
if (mFanart == null)
{
return(null);
}
mFanart = RepoFactory.MovieDB_Fanart.GetByOnlineID(mFanart.URL);
if (mFanart == null)
{
return(null);
}
if (File.Exists(mFanart.FullImagePath))
{
return(mFanart.FullImagePath);
}
else
{
logger.Trace("Could not find MovieDB_FanArt image: {0}", mFanart.FullImagePath);
return("");
}
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart tFanart = RepoFactory.Trakt_ImageFanart.GetByID(int.Parse(ImageID));
if (tFanart == null)
{
return(null);
}
if (File.Exists(tFanart.FullImagePath))
{
return(tFanart.FullImagePath);
}
else
{
logger.Trace("Could not find Trakt_Fanart image: {0}", tFanart.FullImagePath);
return("");
}
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster tPoster = RepoFactory.Trakt_ImagePoster.GetByID(int.Parse(ImageID));
if (tPoster == null)
{
return(null);
}
if (File.Exists(tPoster.FullImagePath))
{
return(tPoster.FullImagePath);
}
else
{
logger.Trace("Could not find Trakt_Poster image: {0}", tPoster.FullImagePath);
return("");
}
case JMMImageType.Trakt_Episode:
case JMMImageType.Trakt_WatchedEpisode:
Trakt_Episode tEpisode = RepoFactory.Trakt_Episode.GetByID(int.Parse(ImageID));
if (tEpisode == null)
{
return(null);
}
if (File.Exists(tEpisode.FullImagePath))
{
return(tEpisode.FullImagePath);
}
else
{
logger.Trace("Could not find Trakt_Episode image: {0}", tEpisode.FullImagePath);
return("");
}
default:
return("");
}
}
internal static Episode GenerateFromAnimeEpisode(NancyContext ctx, SVR_AnimeEpisode aep, int uid, int level)
{
Episode ep = new Episode
{
id = aep.AnimeEpisodeID,
eptype = aep.EpisodeTypeEnum.ToString(),
art = new ArtCollection()
};
var userrating = aep.UserRating;
if (userrating > 0)
{
ep.userrating = userrating.ToString(CultureInfo.InvariantCulture);
}
if (double.TryParse(ep.rating, out double rating))
{
// 0.1 should be the absolute lowest rating
if (rating > 10)
{
ep.rating = (rating / 100).ToString(CultureInfo.InvariantCulture);
}
}
CL_AnimeEpisode_User cae = aep.GetUserContract(uid);
if (cae != null)
{
ep.name = cae.AniDB_EnglishName;
ep.summary = cae.Description;
ep.year = cae.AniDB_AirDate?.Year.ToString(CultureInfo.InvariantCulture);
ep.air = cae.AniDB_AirDate?.ToPlexDate();
ep.votes = cae.AniDB_Votes;
ep.rating = cae.AniDB_Rating;
ep.view = cae.IsWatched() ? 1 : 0;
ep.epnumber = cae.EpisodeNumber;
}
TvDB_Episode tvep = aep.TvDBEpisode;
if (tvep != null)
{
if (!string.IsNullOrEmpty(tvep.EpisodeName))
{
ep.name = tvep.EpisodeName;
}
if (Misc.IsImageValid(tvep.GetFullImagePath()))
{
ep.art.thumb.Add(new Art
{
index = 0,
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.TvDB_Episode,
tvep.TvDB_EpisodeID)
});
}
var fanarts = aep.GetAnimeSeries()?.GetAnime()?.Contract?.AniDBAnime?.Fanarts;
if (fanarts != null && fanarts.Count > 0)
{
var cont_image =
fanarts[new Random().Next(fanarts.Count)];
ep.art.fanart.Add(new Art()
{
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, cont_image.ImageType,
cont_image.AniDB_Anime_DefaultImageID),
index = 0
});
}
else
{
ep.art.fanart.Add(new Art
{
index = 0,
url = APIHelper.ConstructImageLinkFromTypeAndId(ctx, (int)ImageEntityType.TvDB_Episode,
tvep.TvDB_EpisodeID)
});
}
if (!string.IsNullOrEmpty(tvep.Overview))
{
ep.summary = tvep.Overview;
}
int zeroPadding = tvep.EpisodeNumber.ToString().Length;
string episodeNumber = tvep.EpisodeNumber.ToString().PadLeft(zeroPadding, '0');
zeroPadding = tvep.SeasonNumber.ToString().Length;
string seasonNumber = tvep.SeasonNumber.ToString().PadLeft(zeroPadding, '0');
ep.season = $"{seasonNumber}x{episodeNumber}";
var airdate = tvep.AirDate;
if (airdate != null)
{
ep.air = airdate.Value.ToPlexDate();
ep.year = airdate.Value.Year.ToString(CultureInfo.InvariantCulture);
}
}
if (string.IsNullOrEmpty(ep.summary))
{
ep.summary = string.Intern("Episode Overview not Available");
}
if (ep.art.thumb.Count == 0)
{
ep.art.thumb.Add(
new Art {
index = 0, url = APIHelper.ConstructSupportImageLink(ctx, "plex_404.png")
});
ep.art.fanart.Add(new Art
{
index = 0,
url = APIHelper.ConstructSupportImageLink(ctx, "plex_404.png")
});
}
if (string.IsNullOrEmpty(ep.year))
{
ep.year = aep.GetAnimeSeries().AirDate.Year.ToString(CultureInfo.InvariantCulture);
}
if (level > 0)
{
List <SVR_VideoLocal> vls = aep.GetVideoLocals();
if (vls.Count > 0)
{
ep.files = new List <RawFile>();
foreach (SVR_VideoLocal vl in vls)
{
RawFile file = new RawFile(ctx, vl, (level - 1), uid);
ep.files.Add(file);
}
}
}
return(ep);
}
