/// <summary>
/// Changes details of the episode
/// </summary>
/// <param name="record">Episode to change</param>
/// <param name="oldName">Original name of the episode</param>
public void editEpisode(EpisodeRecord record, string oldName)
{
record.ShowId = findEpisodesShowId(oldName);
var episodeId = getIdofExistingEpisode(oldName, record.ShowId);
_db.editEpisodeEntry(record, episodeId);
}
public static void Populate(this TvDB_Episode episode, EpisodeRecord apiEpisode)
{
episode.Id = apiEpisode.Id;
episode.SeriesID = 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);
}
}
private void remove_Click(object sender, RoutedEventArgs e)
{
EpisodeRecord episode = (EpisodeRecord)episodes.SelectedItem;
_repo.removeEpisode(episode.Title);
episodes.ItemsSource = _repo.getAllEpisodesInShow(_repo.FindShowsTitle(episode.ShowId));
}
private void makeCurrent_Click(object sender, RoutedEventArgs e)
{
EpisodeRecord episode = (EpisodeRecord)episodes.SelectedItem;
episode.ShowId = _repo.findEpisodesShowId(episode.Title);
_repo.changeCurrentEpisode(episode);
}
/// <summary>
/// Updates an episode entry in the database
/// </summary>
/// <param name="record">Episode to update</param>
/// <param name="oldName">Old name of the episode</param>
public void editEpisodeEntry(EpisodeRecord record, int id)
{
string query = string.Format("Update Episodes set Title=@Title, Season=@Season, EpisodeNumber=@Episode" +
" where EpisodeId=@IdofEpisode;");
var conn = new SqlConnection(connectionString);
var command = new SqlCommand(query, conn);
command.Parameters.AddWithValue("@Title", record.Title);
command.Parameters.AddWithValue("@Season", record.Season);
command.Parameters.AddWithValue("@Episode", record.Episode);
command.Parameters.AddWithValue("@IdofEpisode", id);
try
{
conn.Open();
command.ExecuteNonQuery();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
finally
{
if ((conn.State == ConnectionState.Open))
{
conn.Close();
}
}
}
private void edit_Click(object sender, RoutedEventArgs e)
{
EpisodeRecord record = (EpisodeRecord)episodes.SelectedItem;
EditEpisode episode = new EditEpisode(record.Title);
episode.DataContext = record;
episode.Closed += ChildWindowClosed;
episode.Show();
}
/// <summary>
/// Creates an episode from the EpisodeRecord.
/// </summary>
private Episode CreateEpisode(EpisodeRecord record, Show show)
=> new Episode
{
Title = record.EpisodeName ?? string.Empty,
AbsoluteNumber = record.AbsoluteNumber,
Overview = record.Overview ?? string.Empty,
IsMovie = record.IsMovie > 0,
SeasonNumber = record.AiredSeason,
EpisodeNumber = record.AiredEpisodeNumber,
TvDbId = record.Id,
ShowId = show.Id
};
private void newEpisode_Click(object sender, RoutedEventArgs e)
{
var items = episodes.Items.Cast <EpisodeRecord>().ToList();
var ep = new EpisodeRecord()
{
ShowId = _repo.getIdOfExistingShow(title)
};
NewEpisode episode = new NewEpisode();
episode.DataContext = ep;
episode.Closed += ChildWindowClosed;
episode.Show();
}
private void MapToEpisode(Episode episode, EpisodeRecord data)
{
episode.Title = data.EpisodeName;
episode.Description = data.Overview;
episode.ImdbId = data.ImdbId;
episode.Number = data.AiredEpisodeNumber.Value;
episode.SeasonNumber = data.AiredSeason.Value;
episode.TheTvDbId = data.Id;
if (!string.IsNullOrWhiteSpace(data.FirstAired))
{
episode.FirstAired = this.DateParser.ParseFirstAired(data.FirstAired);
}
episode.LastUpdated = data.LastUpdated.ToDateTime();
}
private RemoteImageInfo GetImageInfo(EpisodeRecord episode)
{
if (string.IsNullOrEmpty(episode.Filename))
{
return(null);
}
return(new RemoteImageInfo
{
Width = Convert.ToInt32(episode.ThumbWidth),
Height = Convert.ToInt32(episode.ThumbHeight),
ProviderName = Name,
Url = TvdbUtils.BannerUrl + episode.Filename,
Type = ImageType.Primary
});
}
private void AddVirtualEpisode(EpisodeRecord episode, Season season)
{
// tvdb has a lot of bad data?
if (!IsValidEpisode(episode) || season == null)
{
return;
}
// Put as much metadata into it as possible
DateTime.TryParse(episode.FirstAired, out var premiereDate);
var newEpisode = new Episode
{
Name = episode.EpisodeName,
IndexNumber = episode.AiredEpisodeNumber !.Value,
ParentIndexNumber = episode.AiredSeason !.Value,
Id = _libraryManager.GetNewItemId(
season.Series.Id + episode.AiredSeason.Value.ToString(CultureInfo.InvariantCulture) + "Episode " + episode.AiredEpisodeNumber,
typeof(Episode)),
IsVirtualItem = true,
SeasonId = season.Id,
SeriesId = season.Series.Id,
AirsBeforeEpisodeNumber = episode.AirsBeforeEpisode,
AirsAfterSeasonNumber = episode.AirsAfterSeason,
AirsBeforeSeasonNumber = episode.AirsBeforeSeason,
Overview = episode.Overview,
CommunityRating = (float?)episode.SiteRating,
OfficialRating = episode.ContentRating,
PremiereDate = premiereDate,
SeriesName = season.Series.Name,
SeriesPresentationUniqueKey = season.SeriesPresentationUniqueKey,
SeasonName = season.Name,
DateLastSaved = DateTime.UtcNow
};
newEpisode.PresentationUniqueKey = newEpisode.GetPresentationUniqueKey();
newEpisode.SetProviderId(MetadataProvider.Tvdb, episode.Id.ToString(CultureInfo.InvariantCulture));
_logger.LogInformation(
"Creating virtual episode {0} {1}x{2}",
season.Series.Name,
episode.AiredSeason,
episode.AiredEpisodeNumber);
season.AddChild(newEpisode, CancellationToken.None);
}
private Episode Map(EpisodeRecord episode)
{
var episodeMapper = new Mapper <EpisodeRecord, Episode>(StringComparison.OrdinalIgnoreCase);
episodeMapper.AddMapping((s, d) =>
{
d.SeasonNumber = s.AiredSeason;
d.CombinedEpisodeNumber = (s.AbsoluteNumber?.ToString());
d.CombinedSeason = (s.AiredSeason?.ToString());
d.Director = s.Directors.Length > 0 ? s.Directors[0] : null;
d.EpisodeNumber = s.AiredEpisodeNumber;
if (DateTime.TryParse(s.FirstAired, out var firstAired))
{
d.FirstAired = firstAired;
}
d.GuestStars = string.Join(";", s.GuestStars);
d.Rating = (double)(s.SiteRating ?? 0);
d.RatingString = d.Rating.ToString();
d.Writer = s.Writers.Length > 0 ? s.Writers[0] : null;
});
return(episodeMapper.CreateMappedObject(episode));
}
/// <summary>
/// Gets all episodes for particular show from the database
/// </summary>
/// <param name="id">Id of show</param>
/// <returns>A list of episodes for the particular show</returns>
public List <EpisodeRecord> getAllEpisodeEntriesForShow(int id)
{
var entries = new List <EpisodeRecord>();
var conn = new SqlConnection(connectionString);
string query = string.Format("Select * from Episodes where IdofShow = @IdofShow;");
var command = new SqlCommand(query, conn);
command.Parameters.AddWithValue("@IdofShow", id);
try
{
conn.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
EpisodeRecord record = new EpisodeRecord();
record.Title = reader.GetString(reader.GetOrdinal("Title"));
record.Episode = reader.GetInt32(reader.GetOrdinal("EpisodeNumber"));
record.Season = reader.GetInt32(reader.GetOrdinal("Season"));
record.ShowId = reader.GetInt32(reader.GetOrdinal("IdofShow"));
entries.Add(record);
}
}
}
catch (Exception ex)
{
ex.ToString();
}
finally
{
if ((conn.State == ConnectionState.Open))
{
conn.Close();
}
}
return(entries);
}
public static async Task QueueEpisodeImageDownloadAsync(BasicEpisode item, List <int> existingEpIds, bool downloadImages, bool forceRefresh)
{
try
{
// the episode id
int id = item.Id;
existingEpIds.Add(id);
TvDB_Episode ep = RepoFactory.TvDB_Episode.GetByTvDBID(id);
if (ep == null)
{
ep = new TvDB_Episode();
}
EpisodeRecord episode = await GetEpisodeDetailsAsync(id);
if (episode == null)
{
return;
}
ep.Populate(episode);
RepoFactory.TvDB_Episode.Save(ep);
if (downloadImages)
{
// download the image for this episode
if (!string.IsNullOrEmpty(ep.Filename))
{
bool fileExists = File.Exists(ep.GetFullImagePath());
if (!fileExists || forceRefresh)
{
CommandRequest_DownloadImage cmd =
new CommandRequest_DownloadImage(ep.TvDB_EpisodeID,
JMMImageType.TvDB_Episode, forceRefresh);
cmd.Save();
}
}
}
}
catch (TvDbSharper.Errors.TvDbServerException exception)
{
if (exception.StatusCode == HttpStatusCode.Unauthorized)
{
client.Authentication.Token = null;
await _checkAuthorizationAsync();
if (client.Authentication.Token != null)
{
await QueueEpisodeImageDownloadAsync(item, existingEpIds, downloadImages, forceRefresh);
return;
}
// suppress 404 and move on
}
else if (exception.StatusCode == HttpStatusCode.NotFound)
{
return;
}
logger.Error(exception, "TvDB returned an error code: " + exception.StatusCode + "\n " + exception.Message);
}
catch (Exception ex)
{
logger.Error(ex, "Error in TVDBHelper.GetEpisodes: " + ex.ToString());
}
}
public static async Task <TvDB_Episode> QueueEpisodeImageDownloadAsync(int tvDBEpisodeID, bool downloadImages, bool forceRefresh)
{
try
{
TvDB_Episode ep = RepoFactory.TvDB_Episode.GetByTvDBID(tvDBEpisodeID);
if (ep == null || forceRefresh)
{
EpisodeRecord episode = await GetEpisodeDetailsAsync(tvDBEpisodeID);
if (episode == null)
{
return(null);
}
if (ep == null)
{
ep = new TvDB_Episode();
}
ep.Populate(episode);
RepoFactory.TvDB_Episode.Save(ep);
}
if (downloadImages)
{
if (!string.IsNullOrEmpty(ep.Filename))
{
bool fileExists = File.Exists(ep.GetFullImagePath());
if (!fileExists || forceRefresh)
{
CommandRequest_DownloadImage cmd =
new CommandRequest_DownloadImage(ep.TvDB_EpisodeID,
ImageEntityType.TvDB_Episode, forceRefresh);
cmd.Save();
}
}
}
return(ep);
}
catch (TvDbServerException exception)
{
if (exception.StatusCode == (int)HttpStatusCode.Unauthorized)
{
client.Authentication.Token = null;
await CheckAuthorizationAsync();
if (!string.IsNullOrEmpty(client.Authentication.Token))
{
return(await QueueEpisodeImageDownloadAsync(tvDBEpisodeID, downloadImages, forceRefresh));
}
// suppress 404 and move on
}
else if (exception.StatusCode == (int)HttpStatusCode.NotFound)
{
return(null);
}
logger.Error(exception,
$"TvDB returned an error code: {exception.StatusCode}\n {exception.Message}");
}
catch (Exception ex)
{
logger.Error(ex, $"Error in TVDBHelper.GetEpisodes: {ex}");
}
return(null);
}
private void Confirm_Executed(object sender, ExecutedRoutedEventArgs e)
{
_record = new EpisodeRecord();
e.Handled = true;
}
/// <summary>
/// Changes the current episode and season that are being watched by the user
/// </summary>
/// <param name="episode">A new episode to change</param>
public void changeCurrentEpisode(EpisodeRecord episode)
{
_db.changeCurrentEpisode(episode.ShowId, episode.Episode, episode.Season);
}
private static MetadataResult <Episode> MapEpisodeToResult(EpisodeInfo id, EpisodeRecord episode)
{
var result = new MetadataResult <Episode>
{
HasMetadata = true,
Item = new Episode
{
IndexNumber = id.IndexNumber,
ParentIndexNumber = id.ParentIndexNumber,
IndexNumberEnd = id.IndexNumberEnd,
AirsBeforeEpisodeNumber = episode.AirsBeforeEpisode,
AirsAfterSeasonNumber = episode.AirsAfterSeason,
AirsBeforeSeasonNumber = episode.AirsBeforeSeason,
Name = episode.EpisodeName,
Overview = episode.Overview,
CommunityRating = (float?)episode.SiteRating,
}
};
result.ResetPeople();
var item = result.Item;
item.SetProviderId(MetadataProviders.Tvdb, episode.Id.ToString());
item.SetProviderId(MetadataProviders.Imdb, episode.ImdbId);
if (string.Equals(id.SeriesDisplayOrder, "dvd", StringComparison.OrdinalIgnoreCase))
{
item.IndexNumber = Convert.ToInt32(episode.DvdEpisodeNumber ?? episode.AiredEpisodeNumber);
item.ParentIndexNumber = episode.DvdSeason ?? episode.AiredSeason;
}
else if (episode.AiredEpisodeNumber.HasValue)
{
item.IndexNumber = episode.AiredEpisodeNumber;
}
else if (episode.AiredSeason.HasValue)
{
item.ParentIndexNumber = episode.AiredSeason;
}
if (DateTime.TryParse(episode.FirstAired, out var date))
{
// dates from tvdb are UTC but without offset or Z
item.PremiereDate = date;
item.ProductionYear = date.Year;
}
foreach (var director in episode.Directors)
{
result.AddPerson(new PersonInfo
{
Name = director,
Type = PersonType.Director
});
}
// GuestStars is a weird list of names and roles
// Example:
// 1: Some Actor (Role1
// 2: Role2
// 3: Role3)
// 4: Another Actor (Role1
// ...
for (var i = 0; i < episode.GuestStars.Length; ++i)
{
var currentActor = episode.GuestStars[i];
var roleStartIndex = currentActor.IndexOf('(');
if (roleStartIndex == -1)
{
result.AddPerson(new PersonInfo
{
Type = PersonType.GuestStar,
Name = currentActor,
Role = string.Empty
});
continue;
}
var roles = new List <string> {
currentActor.Substring(roleStartIndex + 1)
};
// Fetch all roles
for (var j = i + 1; j < episode.GuestStars.Length; ++j)
{
var currentRole = episode.GuestStars[j];
var roleEndIndex = currentRole.IndexOf(')');
if (roleEndIndex == -1)
{
roles.Add(currentRole);
continue;
}
roles.Add(currentRole.TrimEnd(')'));
// Update the outer index (keep in mind it adds 1 after the iteration)
i = j;
break;
}
result.AddPerson(new PersonInfo
{
Type = PersonType.GuestStar,
Name = currentActor.Substring(0, roleStartIndex).Trim(),
Role = string.Join(", ", roles)
});
}
foreach (var writer in episode.Writers)
{
result.AddPerson(new PersonInfo
{
Name = writer,
Type = PersonType.Writer
});
}
result.ResultLanguage = episode.Language.EpisodeName;
return(result);
}
private static MetadataResult <Episode> MapEpisodeToResult(EpisodeInfo id, EpisodeRecord episode)
{
var result = new MetadataResult <Episode>
{
HasMetadata = true,
Item = new Episode
{
IndexNumber = id.IndexNumber,
ParentIndexNumber = id.ParentIndexNumber,
IndexNumberEnd = id.IndexNumberEnd,
AirsBeforeEpisodeNumber = episode.AirsBeforeEpisode,
AirsAfterSeasonNumber = episode.AirsAfterSeason,
AirsBeforeSeasonNumber = episode.AirsBeforeSeason,
Name = episode.EpisodeName,
Overview = episode.Overview,
CommunityRating = (float?)episode.SiteRating,
}
};
result.ResetPeople();
var item = result.Item;
item.SetProviderId(MetadataProviders.Tvdb, episode.Id.ToString());
item.SetProviderId(MetadataProviders.Imdb, episode.ImdbId);
if (string.Equals(id.SeriesDisplayOrder, "dvd", StringComparison.OrdinalIgnoreCase))
{
item.IndexNumber = Convert.ToInt32(episode.DvdEpisodeNumber ?? episode.AiredEpisodeNumber);
item.ParentIndexNumber = episode.DvdSeason ?? episode.AiredSeason;
}
else if (episode.AiredEpisodeNumber.HasValue)
{
item.IndexNumber = episode.AiredEpisodeNumber;
}
else if (episode.AiredSeason.HasValue)
{
item.ParentIndexNumber = episode.AiredSeason;
}
if (DateTime.TryParse(episode.FirstAired, out var date))
{
// dates from tvdb are UTC but without offset or Z
item.PremiereDate = date;
item.ProductionYear = date.Year;
}
foreach (var director in episode.Directors)
{
result.AddPerson(new PersonInfo
{
Name = director,
Type = PersonType.Director
});
}
foreach (var person in episode.GuestStars)
{
var index = person.IndexOf('(');
string role = null;
var name = person;
if (index != -1)
{
role = person.Substring(index + 1).Trim().TrimEnd(')');
name = person.Substring(0, index).Trim();
}
result.AddPerson(new PersonInfo
{
Type = PersonType.GuestStar,
Name = name,
Role = role
});
}
foreach (var writer in episode.Writers)
{
result.AddPerson(new PersonInfo
{
Name = writer,
Type = PersonType.Writer
});
}
result.ResultLanguage = episode.Language.EpisodeName;
return(result);
}
/// <summary>
/// Checks if particular episode already existant for the chosen show
/// </summary>
/// <param name="record">Episode record to check for</param>
/// <returns>True if exists else false</returns>
public bool checkIfEpisodeAlreadyExists(EpisodeRecord record)
{
return(_db.checkForExistingEpisodeEntry(record.Title, record.ShowId));
}
private static bool EpisodeExists(EpisodeRecord episodeRecord, IReadOnlyList <Episode> existingEpisodes)
{
return(existingEpisodes.Any(ep => ep.ContainsEpisodeNumber(episodeRecord.AiredEpisodeNumber !.Value) && ep.ParentIndexNumber == episodeRecord.AiredSeason));
}
private static bool IsValidEpisode(EpisodeRecord episodeRecord)
{
return(episodeRecord?.AiredSeason != null && episodeRecord.AiredEpisodeNumber != null);
}
