public TvSeriesModel Get(int season)
{
try
{
Logger.Trace("Begin => Get");
Logger.DebugFormat("Parameters [season={0}]", season);
TvSeries result = _tvSeriesRepository.Get(season);
if (result == null)
{
Logger.DebugFormat("Season season={0} not found", season);
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return TvSeriesModel.CopyFrom(result);
}
catch (Exception err)
{
Logger.Error("Error in Get", err);
throw;
}
finally
{
Logger.Trace("End => Get");
}
}
/// <summary>
/// returns true if the media file and tv series are compatible. to check this we
/// condense the titles for both objects, removing whitespace and removing periods , underscores and dashes.
/// if the two titles are the same after that, they are considered compatible.
/// </summary>
/// <param name="mfi"></param>
/// <param name="series"></param>
/// <returns>true if the media file and tv series are compatible, otherwise false</returns>
private bool IsCompatible(MediaFile mfi, TvSeries series)
{
string condensedMfiTitle = mfi.Title.ToLower().Replace(" ", "").Replace(".", "").Replace("_", "").Replace("-", "").Replace(":", "").Replace("'", "").Replace("(", "").Replace(")", "");
string condensedSeriesTitle = series.Title.ToLower().Replace(" ", "").Replace(".", "").Replace("_", "").Replace("-", "").Replace(":", "").Replace("'", "").Replace("(", "").Replace(")", "");
return(condensedMfiTitle.Equals(condensedSeriesTitle));
}
public IEnumerable<TvSeries> FindTvSeries(string name)
{
var series = new List<TvSeries>();
var url = $"http://thetvdb.com/api/GetSeries.php?seriesname={name}";
var client = WebRequest.Create(url);
var xmlDoc = new XmlDocument();
try
{
xmlDoc.Load(client.GetResponse().GetResponseStream());
}
catch (WebException ex)
{
_logger.ErrorException($"Failed to connect to {url}", ex);
}
foreach (XmlNode node in xmlDoc.SelectNodes("Data/Series"))
{
if (node["FirstAired"] == null) continue;
var overview = node["Overview"]?.InnerText ?? string.Empty;
var tvSeries = new TvSeries()
{
TvDbSeriesId = node["id"].InnerText,
Name = node["SeriesName"].InnerText,
FirstAired = Convert.ToDateTime(node["FirstAired"].InnerText),
Summary = overview
};
series.Add(tvSeries);
}
return series;
}
public static TvSeriesModel CopyFrom(TvSeries series)
{
return(new TvSeriesModel()
{
Name = series.Name
});
}
private TvSeries UserSelectSeries(WmcItem episode, IList <TvSeries> tvSeries)
{
Console.WriteLine("Multiple series matches for {0}", episode.Series.WmcName);
TvSeries tvs = null;
for (int i = 0; i < tvSeries.Count; i++)
{
Console.WriteLine("{0}: {1}", i + 1, tvSeries[i].TvDbName);
}
while (tvs == null)
{
Console.Write("Select Series (0 to skip): ");
string s = Console.ReadLine();
if (int.TryParse(s, out int x))
{
x--;
if (x == -1)
{
break;
}
if (x >= 0 && x < tvSeries.Count)
{
tvs = tvSeries[x];
}
}
}
return(tvs);
}
private async Task <Tuple <bool, TvSeries> > UserSearchSeries(WmcItem wmcItem, string seriesUrl, ILog logger)
{
bool cont = true;
Console.WriteLine("No series matches for {0}", wmcItem.Series.WmcName);
Console.Write("Search for series (0 to skip): ");
string s = Console.ReadLine();
TvSeries series = null;
if (int.TryParse(s, out int x) && x == 0)
{
cont = false;
}
else
{
series = await GetSeriesInfo(seriesUrl, wmcItem, s, logger);
if (series != null)
{
cont = false;
}
}
return(new Tuple <bool, TvSeries>(cont, series));
}
public TvSeries Get(int season)
{
try
{
Logger.Trace("Begin -> Get");
Logger.DebugFormat("Parameters [season={0}]", season);
using (IGraphClient client = DatabaseFactory.CreateReader())
{
TvSeries result = client.Cypher
.Match(
"(series:TvSeries {name: {name} })")
.WithParams(new Dictionary <string, object>
{
{ "name", string.Format("Season {0}", season) }
})
.Return(series => series.As <TvSeries>())
.OrderBy(new[] { "series.name" })
.Results.FirstOrDefault();
Logger.Trace("End -> Get");
return(result);
}
}
catch (Exception err)
{
Logger.Error("Error in Get", err);
throw;
}
}
private async Task <TvSeries> GetSeriesInfo(string seriesUrl, WmcItem episode, string searchName, ILog logger)
{
TvSeries tvSeries = null;
string url = string.Format(seriesUrl, WebUtility.UrlEncode(searchName));
XDocument xdoc = await GetXmlDoc(url, logger);
IEnumerable <TvSeries> series = (xdoc.Descendants("Series").Select
(items => new TvSeries
{
WmcName = episode.Series.WmcName,
TvDbId = items.Element("id")?.Value,
TvDbName = items.Element("SeriesName")?.Value
}));
IList <TvSeries> tvs = series as IList <TvSeries> ?? series.ToList();
if (tvs.Count == 1 && episode.Series.WmcName == tvs[0].TvDbName)
{
tvSeries = tvs[0];
}
else if (tvs.Count >= 1)
{
tvSeries = UserSelectSeries(episode, tvs);
}
return(tvSeries);
}
public ActionResult DeleteConfirmed(int id)
{
TvSeries tvseries = db.Series.Find(id);
db.Series.Remove(tvseries);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "ID,Title,Genre,Season,Episode")] TvSeries tvseries)
{
if (ModelState.IsValid)
{
db.Entry(tvseries).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tvseries));
}
public ActionResult Create([Bind(Include = "ID,Title,Genre,Season,Episode")] TvSeries tvseries)
{
if (ModelState.IsValid)
{
db.Series.Add(tvseries);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tvseries));
}
public void GetEpisodeBySeriesName_ReturnsEpisode()
{
var episode = new TvEpisode()
{
Season = 5, EpisodeNumber = 12, Title = "Some Title"
};
var series = new TvSeries()
{
Name = "The Walking Dead"
};
series.Episodes.Add(episode);
var episodeQueryable = new List <TvEpisode> {
episode
}.AsQueryable();
var seriesList = new List <TvSeries> {
series
};
var seriesSet = new Mock <MockableDbSetWithExtensions <TvSeries> >();
seriesSet.Setup(ss => ss.SqlQuery(It.IsAny <string>(), It.IsAny <object[]>()))
.Returns <string, object[]>((sql, param) =>
{
var sqlQueryMock = new Mock <DbSqlQuery <TvSeries> >();
sqlQueryMock.Setup(m => m.AsNoTracking())
.Returns(sqlQueryMock.Object);
sqlQueryMock.Setup(m => m.GetEnumerator())
.Returns(seriesList.GetEnumerator());
return(sqlQueryMock.Object);
});
var episodeSet = new Mock <MockableDbSetWithExtensions <TvEpisode> >();
episodeSet.As <IQueryable <TvEpisode> >().Setup(m => m.Provider).Returns(episodeQueryable.Provider);
episodeSet.As <IQueryable <TvEpisode> >().Setup(m => m.Expression).Returns(episodeQueryable.Expression);
episodeSet.As <IQueryable <TvEpisode> >().Setup(m => m.ElementType).Returns(episodeQueryable.ElementType);
episodeSet.As <IQueryable <TvEpisode> >().Setup(m => m.GetEnumerator()).Returns(episodeQueryable.GetEnumerator());
var context = new Mock <ITvContext>();
context.Setup(c => c.Set <TvSeries>()).Returns(seriesSet.Object);
context.Setup(c => c.TvEpisodes).Returns(episodeSet.Object);
var tvService = new TvService(context.Object);
var result = tvService.GetEpisodeBySeriesName("The Walking Dead", 5, 12, false);
Assert.That(result, Is.Not.Null);
Assert.That(result.Title, Is.EqualTo("Some Title"));
}
private void PrintTvSeriesUri(TvSeries tvSeries)
{
var printString = new StringBuilder();
foreach (var season in tvSeries.SeasonList)
{
foreach (var series in season.EpisodeList)
{
printString.AppendLine(series.FileUri.ToString());
}
}
tbUriList.Text = printString.ToString();
}
public ActionResult Create([Bind(Include = "Id,Title,Genre,AirDate,Season,Episode,Rating")] TvSeries tvseries)
{
if (ModelState.IsValid)
{
var id = User.Identity.GetUserId();
tvseries.ApplicationUserId = db.Users.Find(id);
db.TvSeries.Add(tvseries);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tvseries));
}
public void HandleSearchTvSeries(dynamic dynamicObject, HttpListenerContext context)
{
try
{
if (dynamicObject != null)
{
if (MainWindowViewModel != null)
{
JValue textObject = dynamicObject.Text;
var strText = textObject.Value as string;
if (strText == null)
{
MainWindowViewModel.LogManager.PrintWarningMessage("Text field (to search) is empty!");
return;
}
dynamic sendFlexible = new ExpandoObject();
var tvSeriesList = new List <TvSeries>();
foreach (var tvSeries in MainWindowViewModel.MainDBEntities.TV_Series)
{
if (tvSeries.Name.ToLower().Contains(strText.ToLower()))
{
var newTvSeries = new TvSeries
{
Name = tvSeries.Name,
SeriesImagePath = tvSeries.SeriesImagePath,
Hits = tvSeries.Hits
};
tvSeriesList.Add(newTvSeries);
tvSeries.Hits++;
}
}
sendFlexible.TvSeriesResults = tvSeriesList;
SendMessage(context, sendFlexible);
}
}
}
catch (Exception exception)
{
if (MainWindowViewModel != null)
{
MainWindowViewModel.LogManager.PrintErrorMessage("Message has exception: " + exception.Message + ". InnerMessage: " + exception.InnerException);
}
}
}
// GET: /TvSeries/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TvSeries tvseries = db.Series.Find(id);
if (tvseries == null)
{
return(HttpNotFound());
}
return(View(tvseries));
}
public static int SaveFavoriteTv <T>(string sql, TvSeries data, int userId)
{
using var cnn = new NpgsqlConnection(Startup.Db);
{
cnn.Open();
var cmd = new NpgsqlCommand(sql, cnn);
cmd.Parameters.AddWithValue("id", data.Id);
cmd.Parameters.AddWithValue("posterPath", data.Poster_path);
cmd.Parameters.AddWithValue("title", data.Original_name);
cmd.Parameters.AddWithValue("voteAverage", data.Vote_average);
cmd.Parameters.AddWithValue("userId", userId);
return(cmd.ExecuteNonQuery());
}
}
private void api_TvSeriesGetInfoCompleted(object sender, TvSeriesGetInfoCompletedEventArgs e)
{
TvSeries alTvSeries = e.TvSeries;
int tvSeriesCode = e.TvSeriesCode;
//textBox1.AppendText("\r\n\r\n\r\n//Retrieve the details about the TvSeries 'Lost' - EVENT");
if (alTvSeries.Error != null)
{
AppendText("\r\n" + tvSeriesCode + "\t" + alTvSeries.Error.Value);
}
else
{
AppendText("\r\n" + alTvSeries.Code + "\t" + alTvSeries.OriginalTitle + "\t" + alTvSeries.Title);
}
}
public static int CreateFavoriteTv(int id, string posterPath, string originalName, double voteAverage,
int userId)
{
var data = new TvSeries
{
Id = id,
Poster_path = posterPath,
Original_name = originalName,
Vote_average = voteAverage
};
var sql =
$"INSERT INTO tv (external_id, poster_path, original_name, vote_average, user_id) " +
$"VALUES (@id, @posterPath, @title, @voteAverage, @userId);";
return(SqlDataAccess.SaveFavoriteTv <string>(sql, data, userId));
}
public int AddFavoriteTv(int?id, [FromBody] TvSeries model)
{
if (!ModelState.IsValid)
{
return(0);
}
if (id == null)
{
return(0);
}
var userId = (int)id;
var recordsCreated = CreateFavoriteTv(model.Id, model.Poster_path, model.Original_name, model.Vote_average, userId);
return(recordsCreated);
}
/// <summary>
/// Reads from the specified media item.
/// </summary>
/// <param name="item">The item.</param>
public void ReadFrom(MediaItem item)
{
if (item is TvSeries)
{
showDetails = (TvSeries)item;
}
allSeasons = null;
lstSeasons.Items.Clear();
grdEpisodes.DataSource = null;
foreach (MediaItem child in item.Children)
{
if (child is ISeason)
{
lstSeasons.Items.Add(child);
}
}
}
public Entry ConvertTvSeries(TvShow tmdbSeries)
{
// checks
if (tmdbSeries == null)
{
return(DefaultEntry.Instance);
}
if (string.IsNullOrEmpty(tmdbSeries.Name))
{
return(DefaultEntry.Instance);
}
if (!tmdbSeries.FirstAirDate.HasValue || tmdbSeries.FirstAirDate.Value < new DateTime(1930, 1, 1))
{
return(DefaultEntry.Instance);
}
if (string.IsNullOrEmpty(tmdbSeries.PosterPath))
{
return(DefaultEntry.Instance);
}
if (tmdbSeries.Popularity < MinPopularity)
{
return(DefaultEntry.Instance);
}
// build basic values
var id = Id.FromTvSeriesNumber(tmdbSeries.Id);
var tv = new TvSeries(id)
{
FirstAirDate = tmdbSeries.FirstAirDate.Value,
MainImagePath = tmdbSeries.PosterPath,
Name = tmdbSeries.Name,
Popularity = tmdbSeries.Popularity,
};
// TODO: create the connections
return(tv);
}
public void TvSeriesDefaultCtor_ObjectCreation_AllFildsNotNull()
{
// Arrange
List <Uri> uriList = new List <Uri>()
{
new Uri("https://test.com"),
new Uri("https://test.com")
};
var tvSeries = new TvSeries(new Uri("https://test.com"), uriList);
// Act
var seasonList = tvSeries.SeasonList;
var seasonUriList = tvSeries.SeasonUriList;
var tvSeriesAddress = tvSeries.Uri;
// Assert
Assert.IsNotNull(seasonList);
Assert.IsNotNull(seasonUriList);
Assert.IsNotNull(tvSeriesAddress);
}
private async Task <TvSeries> GetSeriesInfo(WmcItem episode, string searchName)
{
TvSeries tvSeries = null;
var doc = await _tvDbClient.SearchSeries(searchName);
//IList<TvSeries> tvs = series as IList<TvSeries> ?? series.ToList();
//if (tvs.Count == 1 && episode.Series.WmcName == tvs[0].TvDbName)
//{
// tvSeries = tvs[0];
//}
//else if (tvs.Count >= 1)
//{
// tvSeries = UserSelectSeries(episode, tvs);
//}
return(tvSeries);
}
private void makeTvSeriesDisplayable(TvSeries tv)
{
tv.backdrop_path = "https://image.tmdb.org/t/p/w500" + tv.backdrop_path;
this.FirstEpisodeDate = "Első rész megjelenés: " + tv.first_air_date;
this.Genres = "Műfaj:";
int counter = 0;
foreach (var genre in tv.genres)
{
if (counter == 0)
{
this.Genres = this.Genres + " " + genre;
}
else
{
this.Genres = this.Genres + " ," + genre;
}
}
this.LastEpisodeDate = tv.last_air_date ?? "Utolsó epizód megjelenés: " + tv.last_air_date;
this.Rating = $"{tv.vote_average}/10, {tv.vote_count} értékelésből";
this.Status = "Jelenleg: " + tv.status;
}
public IEnumerable <TvSeries> FindTvSeries(string name)
{
var series = new List <TvSeries>();
var url = $"http://thetvdb.com/api/GetSeries.php?seriesname={name}";
var client = WebRequest.Create(url);
var xmlDoc = new XmlDocument();
try
{
xmlDoc.Load(client.GetResponse().GetResponseStream());
}
catch (WebException ex)
{
_logger.ErrorException($"Failed to connect to {url}", ex);
}
foreach (XmlNode node in xmlDoc.SelectNodes("Data/Series"))
{
if (node["FirstAired"] == null)
{
continue;
}
var overview = node["Overview"]?.InnerText ?? string.Empty;
var tvSeries = new TvSeries()
{
TvDbSeriesId = node["id"].InnerText,
Name = node["SeriesName"].InnerText,
FirstAired = Convert.ToDateTime(node["FirstAired"].InnerText),
Summary = overview
};
series.Add(tvSeries);
}
return(series);
}
public void SaveTvSeries(TvSeries tvSeries)
{
_validationContext.ValidateAnnotations(tvSeries);
_validationContext.ThrowIfHasErrors();
// Episodes[0].Title : StringLength - The field Ttile must be a string with a maximum length of 40
// Episodes[1].Title : NonUniqueTitle - Episode 1 has non unique Title field
_dbContext.Series.Add(tvSeries);
for (int i = 0; i < tvSeries.Episodes.Count; i++)
{
using (_validationContext.WithPrefix($"Episodes[{i}]"))
{
SaveEpisode(tvSeries.Episodes[i]);
}
}
_validationContext.ThrowIfHasErrors();
// Episodes[0].ActorIds : HasUnknownActors - Episode 0 has unknown actors
// Episodes[1].ActorIds : HasUnknownActors - Episode 1 has unknown actors
_dbContext.SaveChanges();
}
public void AddOrUpdate(TvSeries series)
{
_context.TvSeries.Add(series);
}
public async Task ProcessEpisodes(List <WmcItem> wmcItems)
{
HashSet <string> updatedSeries = new HashSet <string>();
_settings.TvDbLastUpdate = await GetLastDbUpdate(_updateUrl, _settings.TvDbLastUpdate, updatedSeries, _logger);
await _settings.Save(_logger);
foreach (WmcItem wmcItem in wmcItems)
{
if (!IgnoreWmcItem(wmcItem, _settings.IgnoreItems))
{
if (wmcItem.Type == ItemType.Tv && !string.IsNullOrEmpty(wmcItem.Series.WmcName))
{
TvSeries series = FindKnownSeries(wmcItem, _settings.TvSeries);
if (series == null)
{
if (!UserIgnore(wmcItem, _settings.IgnoreItems))
{
series = await GetSeriesInfo(_seriesUrl, wmcItem, wmcItem.Series.WmcName, _logger);
if (series == null)
{
Tuple <bool, TvSeries> cont = await UserSearchSeries(wmcItem, _seriesUrl, _logger);
while (cont.Item1)
{
cont = await UserSearchSeries(wmcItem, _seriesUrl, _logger);
}
series = cont.Item2;
}
if (series != null)
{
_settings.TvSeries.Add(series);
}
}
if (series != null)
{
wmcItem.Series = series;
}
}
else
{
wmcItem.Series = series;
}
if (wmcItem.Series.TvDbName != null)
{
wmcItem.Series.FolderName = CleanFolderName(wmcItem.Series.TvDbName);
Match match = _title.Match(wmcItem.Title);
if (match.Success)
{
wmcItem.TvDbEpisode = new TvDbEpisode
{
SeasonNumber = Convert.ToInt32(match.Groups[1].Value),
EpisodeNumber = Convert.ToInt32(match.Groups[2].Value),
Name = match.Groups[3].Value
};
}
}
}
else if (wmcItem.Type == ItemType.Movie)
{
UserIgnore(wmcItem, _settings.IgnoreItems);
}
}
}
// find the ones where we could not extract the season and episode from the title
IEnumerable <IGrouping <string, WmcItem> > distinctSeries = wmcItems.Where(file => file.Type == ItemType.Tv && file.TvDbEpisode == null).GroupBy(file => file.Series.TvDbId);
await distinctSeries.ForEachAsync(5, async (item) =>
{
WmcItem episode = item.FirstOrDefault();
if (episode != null && episode.Series.TvDbName != null)
{
if (!IsKnownSeries(episode.Series.TvDbId, _settings.TvSeries) || updatedSeries.Contains(episode.Series.TvDbId))
{
await GetEpisodeData(_episodeUrl, episode, _settings.WorkingDirectory);
}
}
});
await _settings.Save(_logger);
}
public TvSeries GetTvSeries(string id)
{
var url = $"http://thetvdb.com/api/{_TvDbApiKey}/series/{id}/all/en.zip";
var temporaryFilePath = Path.GetTempFileName();
TvSeries tvSeries = null;
var client = new System.Net.WebClient();
client.DownloadFile(url, temporaryFilePath);
if (!File.Exists(temporaryFilePath)) return tvSeries;
var extractFolder = temporaryFilePath + "_extract\\";
ZipFile.ExtractToDirectory(temporaryFilePath, extractFolder);
var xmlDoc = new XmlDocument();
xmlDoc.Load(extractFolder + "en.xml");
var seriesNode = xmlDoc.SelectSingleNode("Data/Series");
var overview = seriesNode["Overview"]?.InnerText ?? string.Empty;
tvSeries = new TvSeries()
{
TvDbSeriesId = seriesNode["id"].InnerText,
Name = seriesNode["SeriesName"].InnerText,
FirstAired = Convert.ToDateTime(seriesNode["FirstAired"].InnerText),
Status = seriesNode["Status"].InnerText,
Summary = overview,
AirsTimeOfDay = seriesNode["Airs_Time"]?.InnerText ?? string.Empty,
Network = seriesNode["Network"]?.InnerText ?? string.Empty,
Rating = seriesNode["ContentRating"]?.InnerText ?? string.Empty,
};
if (seriesNode["Airs_DayOfWeek"] != null)
{
DayOfWeek airDate;
Enum.TryParse<DayOfWeek>(seriesNode["Airs_DayOfWeek"].InnerText, out airDate);
tvSeries.AirsDayOfWeek = airDate;
}
tvSeries.LastUpdated = seriesNode["LastUpdated"] != null ? Convert.ToInt64(seriesNode["LastUpdated"]?.InnerText).FromEpochTime() : DateTime.Now;
if (seriesNode["Genre"] != null)
tvSeries.Genres = GetGenres(seriesNode["Genre"].InnerText);
var episodeNodes = xmlDoc.SelectNodes("Data/Episode");
if (episodeNodes != null)
{
foreach (XmlNode node in episodeNodes)
{
if (string.IsNullOrEmpty(node["FirstAired"]?.InnerText)) continue;
var episode = new TvEpisode();
episode.EpisodeNumber = Convert.ToInt32(node["EpisodeNumber"].InnerText);
episode.Season = Convert.ToInt32(node["SeasonNumber"].InnerText);
episode.Title = node["EpisodeName"].InnerText;
episode.FirstAired = Convert.ToDateTime(node["FirstAired"].InnerText);
//TODO Make initial download status configurable
episode.DownloadStatus = "WANT";
overview = node["Overview"]?.InnerText ?? string.Empty;
episode.Summary = overview;
tvSeries.Episodes.Add(episode);
}
}
File.Delete(temporaryFilePath);
Directory.Delete(extractFolder, recursive: true);
return tvSeries;
}
public void AddOrUpdate(TvSeries series)
{
_context.TvSeries.Add(series);
}
public TvSeries GetTvSeries(string id)
{
var url = $"http://thetvdb.com/api/{_TvDbApiKey}/series/{id}/all/en.zip";
var temporaryFilePath = Path.GetTempFileName();
TvSeries tvSeries = null;
var client = new System.Net.WebClient();
client.DownloadFile(url, temporaryFilePath);
if (!File.Exists(temporaryFilePath))
{
return(tvSeries);
}
var extractFolder = temporaryFilePath + "_extract\\";
ZipFile.ExtractToDirectory(temporaryFilePath, extractFolder);
var xmlDoc = new XmlDocument();
xmlDoc.Load(extractFolder + "en.xml");
var seriesNode = xmlDoc.SelectSingleNode("Data/Series");
var overview = seriesNode["Overview"]?.InnerText ?? string.Empty;
tvSeries = new TvSeries()
{
TvDbSeriesId = seriesNode["id"].InnerText,
Name = seriesNode["SeriesName"].InnerText,
FirstAired = Convert.ToDateTime(seriesNode["FirstAired"].InnerText),
Status = seriesNode["Status"].InnerText,
Summary = overview,
AirsTimeOfDay = seriesNode["Airs_Time"]?.InnerText ?? string.Empty,
Network = seriesNode["Network"]?.InnerText ?? string.Empty,
Rating = seriesNode["ContentRating"]?.InnerText ?? string.Empty,
};
if (seriesNode["Airs_DayOfWeek"] != null)
{
DayOfWeek airDate;
Enum.TryParse <DayOfWeek>(seriesNode["Airs_DayOfWeek"].InnerText, out airDate);
tvSeries.AirsDayOfWeek = airDate;
}
tvSeries.LastUpdated = seriesNode["LastUpdated"] != null?Convert.ToInt64(seriesNode["LastUpdated"]?.InnerText).FromEpochTime() : DateTime.Now;
if (seriesNode["Genre"] != null)
{
tvSeries.Genres = GetGenres(seriesNode["Genre"].InnerText);
}
var episodeNodes = xmlDoc.SelectNodes("Data/Episode");
if (episodeNodes != null)
{
foreach (XmlNode node in episodeNodes)
{
if (string.IsNullOrEmpty(node["FirstAired"]?.InnerText))
{
continue;
}
var episode = new TvEpisode();
episode.EpisodeNumber = Convert.ToInt32(node["EpisodeNumber"].InnerText);
episode.Season = Convert.ToInt32(node["SeasonNumber"].InnerText);
episode.Title = node["EpisodeName"].InnerText;
episode.FirstAired = Convert.ToDateTime(node["FirstAired"].InnerText);
//TODO Make initial download status configurable
episode.DownloadStatus = "WANT";
overview = node["Overview"]?.InnerText ?? string.Empty;
episode.Summary = overview;
tvSeries.Episodes.Add(episode);
}
}
File.Delete(temporaryFilePath);
Directory.Delete(extractFolder, recursive: true);
return(tvSeries);
}
public string[] ParseTvSeries()
{
return(TvSeries.Split(SplitDelimiter));
}
