void getDataWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
colEpisodes = e.Result as List <VM_AnimeEpisode_User>;
if (colEpisodes == null || colEpisodes.Count == 0)
{
if (dummyAnyRecords != null)
{
dummyAnyRecords.Visible = false;
}
setGUIProperty("Watching.Status", "No episodes have recently been watched");
return;
}
if (dummyAnyRecords != null)
{
dummyAnyRecords.Visible = true;
}
foreach (VM_AnimeEpisode_User ep in colEpisodes)
{
GUIListItem item = new GUIListItem("");
VM_AniDB_Anime anime = ep.AnimeSeries.Anime;
string imagePath = GUIGraphicsContext.Skin + @"\Media\MyAnime3\anime3_question_poster.png";
if (anime.DefaultPosterPath.Trim().Length > 0)
{
if (File.Exists(anime.DefaultPosterPath))
{
imagePath = anime.DefaultPosterPath;
}
}
item.IconImage = item.IconImageBig = imagePath;
item.TVTag = ep;
item.OnItemSelected += onFacadeItemSelected;
m_Facade.Add(item);
}
if (m_Facade.Count > 0)
{
m_Facade.SelectedListItemIndex = 0;
VM_AnimeEpisode_User ep = m_Facade.SelectedListItem.TVTag as VM_AnimeEpisode_User;
if (ep != null)
{
SetEpisode(ep);
}
}
if (MainWindow.animeSeriesIDToBeRated.HasValue && BaseConfig.Settings.DisplayRatingDialogOnCompletion)
{
VM_AnimeSeries_User ser = (VM_AnimeSeries_User)VM_ShokoServer.Instance.ShokoServices.GetSeries(MainWindow.animeSeriesIDToBeRated.Value,
VM_ShokoServer.Instance.CurrentUser.JMMUserID);
if (ser != null)
{
Utils.PromptToRateSeriesOnCompletion(ser);
}
MainWindow.animeSeriesIDToBeRated = null;
}
}
private string GetFileName(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case ImageEntityType.AniDB_Cover:
VM_AniDB_Anime anime = req.ImageData as VM_AniDB_Anime;
return(anime?.PosterPathNoDefaultPlain);
case ImageEntityType.TvDB_Cover:
VM_TvDB_ImagePoster poster = req.ImageData as VM_TvDB_ImagePoster;
return(poster?.FullImagePathPlain);
case ImageEntityType.TvDB_Banner:
VM_TvDB_ImageWideBanner banner = req.ImageData as VM_TvDB_ImageWideBanner;
return(banner?.FullImagePathPlain);
case ImageEntityType.TvDB_Episode:
VM_TvDB_Episode episode = req.ImageData as VM_TvDB_Episode;
return(episode?.FullImagePathPlain);
case ImageEntityType.TvDB_FanArt:
VM_TvDB_ImageFanart fanart = req.ImageData as VM_TvDB_ImageFanart;
if (thumbNailOnly)
{
return(fanart?.FullThumbnailPathPlain);
}
else
{
return(fanart?.FullImagePathPlain);
}
case ImageEntityType.MovieDB_Poster:
VM_MovieDB_Poster moviePoster = req.ImageData as VM_MovieDB_Poster;
return(moviePoster?.FullImagePathPlain);
case ImageEntityType.MovieDB_FanArt:
VM_MovieDB_Fanart movieFanart = req.ImageData as VM_MovieDB_Fanart;
return(movieFanart?.FullImagePathPlain);
case ImageEntityType.AniDB_Character:
VM_AniDB_Character chr = req.ImageData as VM_AniDB_Character;
return(chr?.ImagePathPlain);
case ImageEntityType.AniDB_Creator:
VM_AniDB_Seiyuu cre = req.ImageData as VM_AniDB_Seiyuu;
return(cre?.ImagePathPlain);
default:
return(string.Empty);
}
}
public void Init(int animeID, string animeName, string searchCriteria, string existingTraktID, VM_AniDB_Anime anime)
{
Anime = anime;
AnimeID = animeID;
AnimeName = animeName;
ExistingTraktID = existingTraktID;
txtSearch.Text = searchCriteria;
}
public List <string> GetParms()
{
List <string> parms = new List <string>();
if (SearchType == DownloadSearchType.Episode)
{
VM_AnimeEpisode_User ep = (VM_AnimeEpisode_User)SearchParameter;
VM_AnimeSeries_User series = ShokoServerHelper.GetSeries(ep.AnimeSeriesID);
if (series == null)
{
return(parms);
}
VM_AniDB_Anime anime = series.Anime;
if (anime == null)
{
return(parms);
}
// only use the first 2 words of the anime's title
string[] titles = anime.MainTitle.Split(' ');
int i = 0;
foreach (string s in titles)
{
i++;
parms.Add(s.Trim());
if (i == 2)
{
break;
}
}
parms.Add(ep.EpisodeNumber.ToString().PadLeft(2, '0'));
}
if (SearchType == DownloadSearchType.Series)
{
VM_AniDB_Anime anime = (VM_AniDB_Anime)SearchParameter;
// only use the first 2 words of the anime's title
string[] titles = anime.MainTitle.Split(' ');
int i = 0;
foreach (string s in titles)
{
i++;
parms.Add(s.Trim());
if (i == 2)
{
break;
}
}
}
if (SearchType == DownloadSearchType.Manual)
{
string[] titles = SearchParameter.ToString().Split(' ');
foreach (string s in titles)
{
parms.Add(s.Trim());
}
}
return(parms);
}
private void LoadData(int step, DateTime monthNow, bool special = false)
{
BaseConfig.MyAnimeLog.Write("LoadData Step: " + step + " Month: " + monthNow);
// find the anime for this month
colAnime = ShokoServerHelper.GetAnimeForMonthYear(monthNow.Month, monthNow.Year);
dummyAnyAnimeForMonth.Visible = ((colAnime.Count > 0) || (m_Facade.Count > 0));
// now sort the groups by air date
if (step == -1)
{
colAnime = colAnime.OrderByDescending(a => a.AirDate).ToList();
}
else
{
colAnime = colAnime.OrderBy(a => a.AirDate).ToList();
}
//BaseConfig.MyAnimeLog.Write(monthNow.ToString("MMM yyyy").ToUpper());
if (m_Facade.Count == 0)
{
GUIControl.ClearControl(GetID, m_Facade.GetID);
m_Facade.CurrentLayout = GUIFacadeControl.Layout.Filmstrip;
}
VM_AniDB_Anime selanime = null;
if (m_Facade.Count > 0)
{
selanime = (VM_AniDB_Anime)m_Facade.SelectedListItem.TVTag;
}
int selIndex = 0;
foreach (VM_AniDB_Anime anime in colAnime)
{
//BaseConfig.MyAnimeLog.Write(anime.ToString());
string imagePath = GUIGraphicsContext.Skin + @"\Media\MyAnime3\anime3_question_poster.png";
if (anime.DefaultPosterPath.Trim().Length > 0)
{
if (File.Exists(anime.DefaultPosterPath))
{
imagePath = anime.DefaultPosterPath;
}
}
if ((anime.AnimeID == MainWindow.GlobalSeriesID) && (m_Facade.Count == 0))
{
selanime = anime;
}
GUIListItem item = new GUIListItem();
item.IconImage = item.IconImageBig = imagePath;
item.TVTag = anime;
item.OnItemSelected += onFacadeItemSelected;
if (step == -1)
{
m_Facade.Insert(0, item);
}
else
{
m_Facade.Add(item);
}
}
if ((m_Facade.Count > 0) && (selanime != null))
{
//BaseConfig.MyAnimeLog.Write("selIndex: {0}", selIndex.ToString());
for (int x = 0; x < m_Facade.Count; x++)
{
if ((m_Facade.FilmstripLayout.ListItems[x].TVTag) == selanime)
{
selIndex = x;
break;
}
}
if (special) //hack
{
m_Facade.OnAction(new MediaPortal.GUI.Library.Action(MediaPortal.GUI.Library.Action.ActionType.ACTION_MOVE_LEFT, 0, 0));
m_Facade.OnAction(new MediaPortal.GUI.Library.Action(MediaPortal.GUI.Library.Action.ActionType.ACTION_MOVE_RIGHT, 0, 0));
}
m_Facade.SelectedListItemIndex = selIndex;
VM_AniDB_Anime anime = m_Facade.SelectedListItem.TVTag as VM_AniDB_Anime;
if (anime != null)
{
SetAnime(anime);
}
}
if (step == 0)
{
LoadData(-1, monthNow.AddMonths(-1), true);
}
}
private void ShowRelations()
{
GUIControl.ClearControl(this.GetID, m_Facade.GetID);
if (dummyRelationsExist != null)
{
if (relations.Count > 0)
{
dummyRelationsExist.Visible = true;
}
else
{
dummyRelationsExist.Visible = false;
}
}
string imagePathMissing = GUIGraphicsContext.Skin + @"\Media\MyAnime3\anime3_question_poster.png";
string imagePathNoPicture = GUIGraphicsContext.Skin + @"\Media\MyAnime3\anime3_blankchar.png";
BaseConfig.MyAnimeLog.Write("CharWindow.GlobalSeriesID = {0}", MainWindow.GlobalSeriesID.ToString());
BaseConfig.MyAnimeLog.Write("CharWindow.Relations count = " + relations.Count);
if (relations?.Count > 0)
{
foreach (CL_AniDB_Anime_Relation ra in relations)
{
string imagePath = "";
if (ra.AniDB_Anime != null && ra.AnimeSeries != null)
{
BaseConfig.MyAnimeLog.Write("AnimeID: " + MainWindow.GlobalSeriesID + ", Related ID: " +
ra.AniDB_Anime.AnimeID.ToString());
BaseConfig.MyAnimeLog.Write("Poster Path: " + ((VM_AniDB_Anime)ra.AniDB_Anime).DefaultPosterPath);
VM_AniDB_Anime anime = (VM_AniDB_Anime)ra.AniDB_Anime;
// try and load the series
VM_AnimeSeries_User serAnime = (VM_AnimeSeries_User)ra.AnimeSeries;
if (serAnime != null)
{
string posterName = ImageAllocator.GetSeriesImageAsFileName(serAnime,
GUIFacadeControl.Layout.Filmstrip);
if (File.Exists(posterName))
{
imagePath = posterName;
}
}
if (imagePath.Length == 0)
{
if (anime.DefaultPosterPath.Trim().Length > 0 && File.Exists(anime.DefaultPosterPath))
{
imagePath = anime.DefaultPosterPath;
}
else
{
imagePath = imagePathNoPicture;
}
}
}
else
{
imagePath = imagePathMissing;
}
// If it has no title skip it as it's probably an invalid item
if (!string.IsNullOrEmpty(ra.AniDB_Anime?.MainTitle))
{
GUIListItem item = new GUIListItem();
item.IconImage = item.IconImageBig = imagePath;
item.TVTag = ra;
item.OnItemSelected += new GUIListItem.ItemSelectedHandler(onFacadeItemSelected);
m_Facade.Add(item);
}
}
}
if (m_Facade.Count > 0)
{
m_Facade.SelectedListItemIndex = 0;
CL_AniDB_Anime_Relation ra = m_Facade.SelectedListItem?.TVTag as CL_AniDB_Anime_Relation;
if (ra != null)
{
SetAnime(ra);
}
}
//GUIControl.FocusControl(GetID, 50);
}
public void Init(int animeID, string animeName, enEpisodeType aniEpType, int aniEpNumber, string traktID, int traktSeason, int traktEpNumber, string trakSeriesName,
VM_AniDB_Anime anime, int?crossRef_AniDB_TraktV2ID)
{
Anime = anime;
AnimeID = animeID;
AnimeName = animeName;
AnimeEpisodeType = (int)aniEpType;
AnimeEpisodeNumber = aniEpNumber;
TraktID = traktID;
TraktSeason = traktSeason;
TraktEpisodeNumber = traktEpNumber;
TraktSeriesName = trakSeriesName;
CrossRef_AniDB_TraktV2ID = crossRef_AniDB_TraktV2ID;
AnimeURL = string.Format(Constants.URLS.AniDB_Series, AnimeID);
TraktURL = string.Format(Constants.URLS.Trakt_Series, TraktID);
bool hasSpecials = false;
AniDBEpisodes = new List <VM_AniDB_Episode>();
foreach (VM_AniDB_Episode contract in VM_ShokoServer.Instance.ShokoServices.GetAniDBEpisodesForAnime(AnimeID).Cast <VM_AniDB_Episode>())
{
AniDBEpisodes.Add(contract);
if (contract.EpisodeType == (int)enEpisodeType.Special)
{
hasSpecials = true;
}
}
cboEpisodeType.Items.Clear();
cboEpisodeType.Items.Add(Shoko.Commons.Properties.Resources.Anime_Episodes);
if (hasSpecials)
{
cboEpisodeType.Items.Add(Shoko.Commons.Properties.Resources.Anime_Specials);
}
cboEpisodeType.SelectionChanged += new SelectionChangedEventHandler(cboEpisodeType_SelectionChanged);
if (aniEpType == enEpisodeType.Episode)
{
cboEpisodeType.SelectedIndex = 0;
}
else
{
cboEpisodeType.SelectedIndex = 1;
}
// get the seasons
try
{
cboSeasonNumber.Items.Clear();
List <int> seasons = null;
if (anime.traktSummary.traktDetails.ContainsKey(traktID))
{
traktDetails = anime.traktSummary.traktDetails[traktID];
seasons = anime.traktSummary.traktDetails[traktID].DictTraktSeasons.Keys.ToList();
}
else
{
VM_ShokoServer.Instance.ShokoServices.UpdateTraktData(traktID);
traktDetails = new VM_TraktDetails(traktID);
seasons = traktDetails.DictTraktSeasons.Keys.ToList();
}
int i = 0;
int idx = 0;
foreach (int season in seasons)
{
cboSeasonNumber.Items.Add(season.ToString());
if (season == traktSeason)
{
idx = i;
}
i++;
}
cboSeasonNumber.SelectionChanged += new SelectionChangedEventHandler(cboSeasonNumber_SelectionChanged);
cboEpisodeNumber.SelectionChanged += new SelectionChangedEventHandler(cboEpisodeNumber_SelectionChanged);
cboSeasonNumber.SelectedIndex = idx;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void communityWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
try
{
SearchCommunityResults res = e.Result as SearchCommunityResults;
if (res == null)
{
return;
}
VM_AniDB_Anime anime = DataContext as VM_AniDB_Anime;
if (anime == null)
{
return;
}
if (anime.AnimeID != res.AnimeID)
{
return;
}
if (!string.IsNullOrEmpty(res.ErrorMessage))
{
return;
}
foreach (VM_CrossRef_AniDB_TvDBV2 tvxref in res.TvDBLinks)
{
CommunityTVDBLinks.Add(tvxref);
}
foreach (VM_CrossRef_AniDB_TraktV2 traktxref in res.TraktLinks)
{
CommunityTraktLinks.Add(traktxref);
}
btnTvDBCommLinks1.IsEnabled = true;
btnTvDBCommLinks2.IsEnabled = true;
CommTvDBButtonText = Shoko.Commons.Properties.Resources.CommunityLinks_NoLinksAvailable;
if (CommunityTVDBLinks.Count > 0)
{
CommTvDBButtonText = Shoko.Commons.Properties.Resources.CommunityLinks_NeedApproval;
foreach (VM_CrossRef_AniDB_TvDBV2 xref in CommunityTVDBLinks)
{
if (xref.IsAdminApprovedBool)
{
CommTvDBButtonText = Shoko.Commons.Properties.Resources.CommunityLinks_ApprovalExists;
break;
}
}
}
btnTraktCommLinks1.IsEnabled = true;
btnTraktCommLinks2.IsEnabled = true;
CommTraktButtonText = Shoko.Commons.Properties.Resources.CommunityLinks_NoLinksAvailable;
if (CommunityTraktLinks.Count > 0)
{
CommTraktButtonText = Shoko.Commons.Properties.Resources.CommunityLinks_NeedApproval;
foreach (VM_CrossRef_AniDB_TraktV2 xref in CommunityTraktLinks)
{
if (xref.IsAdminApprovedBool)
{
CommTraktButtonText = Shoko.Commons.Properties.Resources.CommunityLinks_ApprovalExists;
break;
}
}
}
//SearchStatus = string.Format("{0} Anime still need TvDB approval", link.AnimeNeedingApproval);
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
}
}
void communityWorker_DoWork(object sender, DoWorkEventArgs e)
{
SearchCommunityResults res = new SearchCommunityResults();
res.ErrorMessage = string.Empty;
res.TvDBLinks = new List <VM_CrossRef_AniDB_TvDBV2>();
res.TraktLinks = new List <VM_CrossRef_AniDB_TraktV2>();
res.ExtraInfo = string.Empty;
res.AnimeID = -1;
try
{
VM_AniDB_Anime anime = e.Argument as VM_AniDB_Anime;
if (anime == null)
{
return;
}
res.AnimeID = anime.AnimeID;
SearchCriteria crit = new SearchCriteria();
crit.AnimeID = anime.AnimeID;
crit.ExtraInfo = string.Empty;
// search for TvDB links
try
{
List <Azure_CrossRef_AniDB_TvDB> xrefs = VM_ShokoServer.Instance.ShokoServices.GetTVDBCrossRefWebCache(crit.AnimeID, true).CastList <Azure_CrossRef_AniDB_TvDB>();
if (xrefs != null && xrefs.Count > 0)
{
foreach (Azure_CrossRef_AniDB_TvDB xref in xrefs)
{
res.TvDBLinks.Add((VM_CrossRef_AniDB_TvDBV2)xref);
}
}
}
catch (Exception ex)
{
res.ErrorMessage = ex.Message;
}
// search for Trakt links
try
{
List <Azure_CrossRef_AniDB_Trakt> xrefs = VM_ShokoServer.Instance.ShokoServices.GetTraktCrossRefWebCache(crit.AnimeID, true);
if (xrefs != null && xrefs.Count > 0)
{
foreach (Azure_CrossRef_AniDB_Trakt xref in xrefs)
{
res.TraktLinks.Add((VM_CrossRef_AniDB_TraktV2)xref);
}
}
}
catch (Exception ex)
{
res.ErrorMessage = ex.Message;
}
e.Result = res;
}
catch (Exception ex)
{
res.ErrorMessage = ex.Message;
e.Result = res;
}
}
void commTraktMenuItem_Click(object sender, RoutedEventArgs e)
{
try
{
MenuItem item = e.Source as MenuItem;
MenuItem itemSender = sender as MenuItem;
if (item == null || itemSender == null)
{
return;
}
if (!item.Header.ToString().Equals(itemSender.Header.ToString()))
{
return;
}
if (item != null && item.CommandParameter != null)
{
CommTvDBTraktMenuCommand cmd = item.CommandParameter as CommTvDBTraktMenuCommand;
Debug.Write("Comm TvDB Menu: " + cmd.ToString() + Environment.NewLine);
VM_AniDB_Anime anime = DataContext as VM_AniDB_Anime;
if (anime == null)
{
return;
}
Cursor = Cursors.Wait;
if (cmd.MenuType == CommTvDBTraktItemType.ShowCommAdmin)
{
MainWindow mainwdw = (MainWindow)Window.GetWindow(this);
if (mainwdw == null)
{
return;
}
mainwdw.ShowWebCacheAdmin(anime);
}
if (cmd.MenuType == CommTvDBTraktItemType.UseMyLinks)
{
if (!AniDB_AnimeCrossRefs.TraktCrossRefExists)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.CommunityLinks_NoLinks, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
string res = VM_ShokoServer.Instance.ShokoServices.UseMyTraktLinksWebCache(anime.AnimeID);
Cursor = Cursors.Arrow;
MessageBox.Show(res, Shoko.Commons.Properties.Resources.Result, MessageBoxButton.OK, MessageBoxImage.Information);
}
Cursor = Cursors.Arrow;
RefreshAdminData();
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
private string GetEntityID(ImageDownloadRequest req)
{
switch (req.ImageType)
{
case ImageEntityType.AniDB_Cover:
VM_AniDB_Anime anime = req.ImageData as VM_AniDB_Anime;
return(anime.AnimeID.ToString());
case ImageEntityType.TvDB_Cover:
VM_TvDB_ImagePoster poster = req.ImageData as VM_TvDB_ImagePoster;
return(poster.TvDB_ImagePosterID.ToString());
case ImageEntityType.TvDB_Banner:
VM_TvDB_ImageWideBanner banner = req.ImageData as VM_TvDB_ImageWideBanner;
return(banner.TvDB_ImageWideBannerID.ToString());
case ImageEntityType.TvDB_Episode:
VM_TvDB_Episode episode = req.ImageData as VM_TvDB_Episode;
return(episode.TvDB_EpisodeID.ToString());
case ImageEntityType.TvDB_FanArt:
VM_TvDB_ImageFanart fanart = req.ImageData as VM_TvDB_ImageFanart;
return(fanart.TvDB_ImageFanartID.ToString());
case ImageEntityType.MovieDB_Poster:
VM_MovieDB_Poster moviePoster = req.ImageData as VM_MovieDB_Poster;
return(moviePoster.MovieDB_PosterID.ToString());
case ImageEntityType.MovieDB_FanArt:
VM_MovieDB_Fanart movieFanart = req.ImageData as VM_MovieDB_Fanart;
return(movieFanart.MovieDB_FanartID.ToString());
case ImageEntityType.Trakt_Poster:
VM_Trakt_ImagePoster traktPoster = req.ImageData as VM_Trakt_ImagePoster;
return(traktPoster.Trakt_ImagePosterID.ToString());
case ImageEntityType.Trakt_Fanart:
VM_Trakt_ImageFanart trakFanart = req.ImageData as VM_Trakt_ImageFanart;
return(trakFanart.Trakt_ImageFanartID.ToString());
case ImageEntityType.Trakt_CommentUser:
VM_Trakt_CommentUser traktShoutUser = req.ImageData as VM_Trakt_CommentUser;
return(traktShoutUser.User.Trakt_FriendID.ToString());
case ImageEntityType.Trakt_Episode:
VM_Trakt_Episode trakEp = req.ImageData as VM_Trakt_Episode;
return(trakEp.Trakt_EpisodeID.ToString());
case ImageEntityType.AniDB_Character:
VM_AniDB_Character chr = req.ImageData as VM_AniDB_Character;
return(chr.AniDB_CharacterID.ToString());
case ImageEntityType.AniDB_Creator:
VM_AniDB_Seiyuu cre = req.ImageData as VM_AniDB_Seiyuu;
return(cre.AniDB_SeiyuuID.ToString());
default:
return("");
}
}
public static bool EvaluateAnimeTextSearch(VM_AniDB_Anime anime, string filterText)
{
return(EvaluateAnimeTextSearch(anime, filterText, SeriesSearchType.Everything));
}
