private void ShowNextEpisode()
{
VM_AnimeGroup_User grp = DataContext as VM_AnimeGroup_User;
if (grp == null)
{
return;
}
if (grp.AnimeGroupID == 0)
{
ucNextEpisode.EpisodeExists = false;
ucNextEpisode.EpisodeMissing = true;
ucNextEpisode.DataContext = null;
return;
}
VM_AnimeEpisode_User ep = (VM_AnimeEpisode_User)VM_ShokoServer.Instance.ShokoServices.GetNextUnwatchedEpisodeForGroup(grp.AnimeGroupID, VM_ShokoServer.Instance.CurrentUser.JMMUserID);
if (ep != null)
{
ep.SetTvDBInfo();
ucNextEpisode.DataContext = ep;
}
else
{
ucNextEpisode.EpisodeExists = false;
ucNextEpisode.EpisodeMissing = true;
ucNextEpisode.DataContext = null;
}
}
public static bool EvaluateGroupTextSearch(VM_AnimeGroup_User grp, string filterText)
{
if (string.IsNullOrEmpty(filterText) || grp == null)
{
return(true);
}
// do this so that when viewing sub groups they don't get filtered
if (grp.AnimeGroupParentID.HasValue)
{
return(true);
}
// get all possible names for the group
// search the group name
int index = grp.GroupName.IndexOf(filterText, 0, StringComparison.InvariantCultureIgnoreCase);
if (index > -1)
{
return(true);
}
// search the sort name
index = grp.SortName.IndexOf(filterText, 0, StringComparison.InvariantCultureIgnoreCase);
if (index > -1)
{
return(true);
}
// check the tags
if (grp.Stat_AllTags != null && grp.Stat_AllTags.Count > 0)
{
if (grp.Stat_AllTags.Contains(filterText, StringComparer.InvariantCultureIgnoreCase))
{
return(true);
}
}
// check the custom tags
if (grp.Stat_AllCustomTags != null && grp.Stat_AllCustomTags.Count > 0)
{
if (grp.Stat_AllCustomTags.Contains(filterText, StringComparer.InvariantCultureIgnoreCase))
{
return(true);
}
}
// search the titles (romaji name, english names) etc from anidb
if (grp.Stat_AllTitles != null && grp.Stat_AllTitles.Count > 0)
{
if (grp.Stat_AllTitles.SubContains(filterText))
{
return(true);
}
}
return(false);
}
private bool GroupSearchFilter(object obj)
{
VM_AnimeGroup_User grpvm = obj as VM_AnimeGroup_User;
if (grpvm == null)
{
return(true);
}
return(GroupSearchFilterHelper.EvaluateGroupTextSearch(grpvm, txtGroupSearch.Text));
}
void btnOK_Click(object sender, RoutedEventArgs e)
{
int?groupID = null;
if (IsExistingGroup)
{
if (lbGroups.SelectedItem == null)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_GroupSelectionRequired, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
lbGroups.Focus();
return;
}
else
{
SelectedGroup = lbGroups.SelectedItem as VM_AnimeGroup_User;
DialogResult = true;
Close();
}
}
if (IsNewGroup)
{
if (txtGroupName.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_GroupNameRequired, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtGroupName.Focus();
return;
}
VM_AnimeGroup_User grp = new VM_AnimeGroup_User();
grp.GroupName = txtGroupName.Text.Trim();
grp.SortName = txtGroupName.Text.Trim();
grp.AnimeGroupParentID = null;
grp.Description = "";
grp.IsFave = 0;
grp.IsManuallyNamed = 0;
grp.OverrideDescription = 0;
if (grp.Validate())
{
grp.IsReadOnly = true;
grp.IsBeingEdited = false;
if (grp.Save())
{
VM_MainListHelper.Instance.ViewGroups.Refresh();
groupID = grp.AnimeGroupID;
}
}
SelectedGroup = grp;
DialogResult = true;
Close();
}
}
public Fanart(object fanartObject)
{
this.fileName = "";
List <string> allFanarts = new List <string>();
// check for a default fanart
if (fanartObject.GetType() == typeof(VM_AnimeGroup_User))
{
VM_AnimeGroup_User grp = fanartObject as VM_AnimeGroup_User;
if (grp.DefaultAnimeSeriesID.HasValue)
{
VM_AnimeSeries_User ser = grp.DefaultSeries;
if (ser != null)
{
VM_AniDB_Anime anime = ser.Anime;
allFanarts.AddRange(GetFanartFilenames(anime));
}
}
else
{
// get all the series for this group
foreach (VM_AnimeSeries_User ser in grp.AllSeries)
{
VM_AniDB_Anime anime = ser.Anime;
allFanarts.AddRange(GetFanartFilenames(anime));
}
}
}
else if (fanartObject.GetType() == typeof(VM_AnimeSeries_User))
{
VM_AnimeSeries_User ser = fanartObject as VM_AnimeSeries_User;
VM_AniDB_Anime anime = ser.Anime;
allFanarts.AddRange(GetFanartFilenames(anime));
}
else if (fanartObject.GetType() == typeof(VM_AniDB_Anime))
{
VM_AniDB_Anime anime = fanartObject as VM_AniDB_Anime;
allFanarts.AddRange(GetFanartFilenames(anime));
}
string randomFanart = "";
if (allFanarts.Count > 0)
{
randomFanart = allFanarts[fanartRandom.Next(0, allFanarts.Count)];
}
if (!String.IsNullOrEmpty(randomFanart))
{
fileName = randomFanart;
}
}
public static List <VM_AnimeSeries_User> GetAnimeSeriesForGroupRecursive(VM_AnimeGroup_User grp)
{
try
{
return(VM_ShokoServer.Instance.ShokoServices.GetSeriesForGroupRecursive(grp.AnimeGroupID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID).CastList <VM_AnimeSeries_User>() ?? new List <VM_AnimeSeries_User>());
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
return(new List <VM_AnimeSeries_User>());
}
void btnRemoveDefaultSeries_Click(object sender, RoutedEventArgs e)
{
VM_AnimeGroup_User grp = DataContext as VM_AnimeGroup_User;
if (grp == null)
{
return;
}
if (grp.AnimeGroupID == 0)
{
return;
}
VM_ShokoServer.Instance.ShokoServices.RemoveDefaultSeriesForGroup(grp.AnimeGroupID);
grp.DefaultAnimeSeriesID = null;
}
void btnRandomEpisode_Click(object sender, RoutedEventArgs e)
{
VM_AnimeGroup_User grp = DataContext as VM_AnimeGroup_User;
if (grp == null)
{
return;
}
MainWindow mainwdw = (MainWindow)Window.GetWindow(this);
RandomEpisodeForm frm = new RandomEpisodeForm();
frm.Owner = Window.GetWindow(this);;
frm.Init(RandomSeriesEpisodeLevel.Group, grp);
bool?result = frm.ShowDialog();
}
private bool GroupSeriesSearchFilter(object obj)
{
VM_AnimeGroup_User grpvm = obj as VM_AnimeGroup_User;
if (grpvm != null)
{
return(GroupSearchFilterHelper.EvaluateGroupTextSearch(grpvm, txtGroupSearch.Text));
}
VM_AnimeSeries_User ser = obj as VM_AnimeSeries_User;
if (ser != null)
{
return(GroupSearchFilterHelper.EvaluateSeriesTextSearch(ser, txtGroupSearch.Text));
}
return(false);
}
public void UpdateAboveGroups(VM_AnimeSeries_User ser)
{
int?groupID = ser.AnimeGroupID;
List <CL_AnimeGroup_User> grps = new List <CL_AnimeGroup_User>();
while (groupID.HasValue)
{
VM_AnimeGroup_User grp = AllGroupsDictionary.SureGet(groupID.Value);
if (grp != null)
{
grp.PopulateSerieInfo(AllGroupsDictionary, AllSeriesDictionary);
}
else
{
groupID = null;
}
}
}
public static bool EvaluateGroupTextSearch(VM_AnimeGroup_User grp, string filterText)
{
filterText = filterText.Trim();
if (string.IsNullOrEmpty(filterText))
{
return(true);
}
if (grp == null)
{
return(false);
}
// do this so that when viewing sub groups they don't get filtered
if (grp.AnimeGroupParentID.HasValue)
{
return(true);
}
// get all possible names for the group
// search the group name
if (grp.GroupName.FuzzyMatches(filterText))
{
return(true);
}
// search the sort name
if (grp.SortName.FuzzyMatches(filterText))
{
return(true);
}
// search the titles (romaji name, english names) etc from anidb
if (grp.AllAnimeSeries.Any(a => EvaluateSeriesTextSearch(a, filterText)))
{
return(true);
}
return(false);
}
public static string GetPosterAsFileName(VM_AnimeGroup_User grp)
{
List <string> allPosters = new List <string>();
string fileName = "";
if (grp.DefaultAnimeSeriesID.HasValue)
{
VM_AnimeSeries_User ser = grp.DefaultSeries;
if (ser != null)
{
VM_AniDB_Anime anime = ser.Anime;
fileName = GetPosterAsFileName(anime);
if (!string.IsNullOrEmpty(fileName) && File.Exists(fileName))
{
allPosters.Add(fileName);
}
}
}
else
{
// get all the series for this group
foreach (VM_AnimeSeries_User ser in grp.AllSeries)
{
VM_AniDB_Anime anime = ser.Anime;
fileName = GetPosterAsFileName(anime);
if (!string.IsNullOrEmpty(fileName) && File.Exists(fileName))
{
allPosters.Add(fileName);
}
}
}
if (allPosters.Count > 0)
{
fileName = allPosters[bannerRandom.Next(0, allPosters.Count - 1)];
}
return(fileName);
}
public static String GetGroupImage(VM_AnimeGroup_User grp, GUIFacadeControl.Layout viewMode)
{
string imgFileName = "";
Size sz = PosterSize;
switch (viewMode)
{
case GUIFacadeControl.Layout.LargeIcons:
imgFileName = GetWideBannerAsFileName(grp); sz = BannerSize; break;
case GUIFacadeControl.Layout.List:
case GUIFacadeControl.Layout.AlbumView:
case GUIFacadeControl.Layout.Filmstrip:
case GUIFacadeControl.Layout.CoverFlow:
imgFileName = GetPosterAsFileName(grp); sz = PosterSize; break;
}
//BaseConfig.MyAnimeLog.Write("GetGroupBanner::viewMode: {0} : {1} : {2}", viewMode, imgFileName, grp);
if (string.IsNullOrEmpty(imgFileName))
{
string ident = "series_" + grp.GroupName;
string sTextureName = buildMemoryImage(drawSimpleBanner(sz, grp.GroupName), ident, sz, true);
if (sTextureName.Length > 0 && !s_SeriesImageList.Contains(sTextureName))
{
s_SeriesImageList.Add(sTextureName);
}
return(sTextureName);
}
else
{
string sTextureName = "";
if (imgFileName.Length > 0 && System.IO.File.Exists(imgFileName))
{
sTextureName = buildMemoryImageFromFile(imgFileName, sz);
}
return(sTextureName);
}
}
public static String GetGroupImageAsFileName(VM_AnimeGroup_User grp, GUIFacadeControl.Layout viewMode)
{
string imgFileName = "";
DateTime start = DateTime.Now;
switch (viewMode)
{
case GUIFacadeControl.Layout.LargeIcons:
imgFileName = GetWideBannerAsFileName(grp); break;
case GUIFacadeControl.Layout.List:
case GUIFacadeControl.Layout.AlbumView:
case GUIFacadeControl.Layout.Filmstrip:
case GUIFacadeControl.Layout.CoverFlow:
imgFileName = GetPosterAsFileName(grp); break;
}
TimeSpan ts = DateTime.Now - start;
BaseConfig.MyAnimeLog.Write("GetGroupImageAsFileName::: {0} in {1}ms", grp.GroupName, ts.TotalMilliseconds);
return(imgFileName);
}
void btnSelectDefaultSeries_Click(object sender, RoutedEventArgs e)
{
VM_AnimeGroup_User grp = DataContext as VM_AnimeGroup_User;
if (grp == null)
{
return;
}
Window wdw = Window.GetWindow(this);
SelectDefaultSeriesForm frm = new SelectDefaultSeriesForm();
frm.Owner = wdw;
frm.Init(grp);
bool?result = frm.ShowDialog();
if (result.Value)
{
// update info
grp.DefaultAnimeSeriesID = frm.SelectedSeriesID.Value;
VM_ShokoServer.Instance.ShokoServices.SetDefaultSeriesForGroup(grp.AnimeGroupID, frm.SelectedSeriesID.Value);
}
}
void btnLoadFiles_Click(object sender, RoutedEventArgs e)
{
try
{
if (!VM_ShokoServer.Instance.ServerOnline)
{
return;
}
ViewFiles.Refresh();
Cursor = Cursors.Wait;
EnableDisableControls(false);
List <VM_VideoLocal> rawVids = new List <VM_VideoLocal>();
if (LoadTypeIsRandom)
{
rawVids = VM_ShokoServer.Instance.ShokoServices.RandomFileRenamePreview(udRandomFiles.Value.Value, VM_ShokoServer.Instance.CurrentUser.JMMUserID).CastList <VM_VideoLocal>();
/*List<int> testIDs = new List<int>();
*
* testIDs.Add(6041); // Gekijouban Bleach: Fade to Black Kimi no Na o Yobu
* testIDs.Add(6784); // Fate/Stay Night: Unlimited Blade Works
* testIDs.Add(5975); // Toaru Majutsu no Index
* testIDs.Add(7599); // Toaru Majutsu no Index II
* testIDs.Add(8694); // Gekijouban Toaru Majutsu no Index (movie)
* testIDs.Add(6071); // Quiz Magic Academy: The Original Animation
* testIDs.Add(4145); // Amaenaide yo!! Katsu!!
* testIDs.Add(2369); // Bleach
* testIDs.Add(69); // One Piece
* foreach (int animeID in testIDs)
* {
* List<JMMServerBinary.Contract_VideoLocal> raws = VM_ShokoServer.Instance.clientBinaryHTTP.GetVideoLocalsForAnime(animeID,
* VM_ShokoServer.Instance.CurrentUser.JMMUserID.Value);
*
* rawVids.AddRange(raws);
* }*/
}
if (LoadTypeIsAll)
{
rawVids = VM_ShokoServer.Instance.ShokoServices.RandomFileRenamePreview(int.MaxValue, VM_ShokoServer.Instance.CurrentUser.JMMUserID).CastList <VM_VideoLocal>();
}
if (LoadTypeIsSeries)
{
Window wdw = Window.GetWindow(this);
SelectGroupSeriesForm frm = new SelectGroupSeriesForm();
frm.Owner = wdw;
frm.Init();
bool?result = frm.ShowDialog();
if (result.HasValue && result.Value == true)
{
if (frm.SelectedObject.GetType() == typeof(VM_AnimeGroup_User))
{
VM_AnimeGroup_User grp = frm.SelectedObject as VM_AnimeGroup_User;
foreach (VM_AnimeSeries_User ser in grp.AllAnimeSeries)
{
rawVids.AddRange(VM_ShokoServer.Instance.ShokoServices.GetVideoLocalsForAnime(ser.AniDB_ID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID).Cast <VM_VideoLocal>());
}
}
if (frm.SelectedObject.GetType() == typeof(VM_AnimeSeries_User))
{
VM_AnimeSeries_User ser = frm.SelectedObject as VM_AnimeSeries_User;
rawVids.AddRange(VM_ShokoServer.Instance.ShokoServices.GetVideoLocalsForAnime(ser.AniDB_ID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID).Cast <VM_VideoLocal>());
}
}
}
foreach (VM_VideoLocal vid in rawVids)
{
VM_VideoLocal_Renamed ren = new VM_VideoLocal_Renamed();
ren.VideoLocalID = vid.VideoLocalID;
ren.VideoLocal = vid;
ren.Success = false;
FileResults.Add(ren);
}
FileCount = FileResults.Count;
Cursor = Cursors.Arrow;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
finally
{
Cursor = Cursors.Arrow;
EnableDisableControls(true);
}
}
private List <VM_AnimeSeries_User> GetSeriesForGroup()
{
List <VM_AnimeSeries_User> serList = new List <VM_AnimeSeries_User>();
try
{
if (LevelType != RandomSeriesEpisodeLevel.Group)
{
return(serList);
}
VM_AnimeGroup_User grp = LevelObject as VM_AnimeGroup_User;
if (grp == null)
{
return(serList);
}
foreach (VM_AnimeSeries_User ser in grp.AllAnimeSeries)
{
// tags
if (!string.IsNullOrEmpty(SelectedTags))
{
string filterParm = SelectedTags.Trim();
string[] cats = filterParm.Split(',');
bool foundCat = false;
if (cboCatFilter.SelectedIndex == 1)
{
foundCat = true; // all
}
foreach (string cat in cats)
{
if (cat.Trim().Length == 0)
{
continue;
}
if (cat.Trim() == ",")
{
continue;
}
bool fnd = ser.AllTags.Contains(cat, StringComparer.InvariantCultureIgnoreCase);
if (cboCatFilter.SelectedIndex == 0) // any
{
if (fnd)
{
foundCat = true;
break;
}
}
else //all
{
if (!fnd)
{
foundCat = false;
break;
}
}
}
if (!foundCat)
{
continue;
}
}
serList.Add(ser);
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
return(serList);
}
//[LogExecutionTime]
public void ShowChildWrappers(IListWrapper wrapper)
{
try
{
CurrentWrapper = wrapper;
CurrentWrapperIsGroup = wrapper is VM_GroupFilter;
CurrentListWrapperIsGroup = wrapper is VM_AnimeGroup_User;
if (wrapper is VM_AnimeGroup_User)
{
//LastAnimeGroupID = ((VM_AnimeGroup_User)wrapper).AnimeGroupID.Value;
Instance.CurrentOpenGroupFilter = "VM_AnimeGroup_User|" + ((VM_AnimeGroup_User)wrapper).AnimeGroupID;
}
if (wrapper is VM_GroupFilter)
{
CurrentGroupFilter = (VM_GroupFilter)wrapper;
//LastGroupFilterID = ((GroupFilterVM)wrapper).GroupFilterID.Value;
Instance.CurrentOpenGroupFilter = "GroupFilterVM|" + ((VM_GroupFilter)wrapper).GroupFilterID;
}
if (wrapper is VM_AnimeSeries_User)
{
CurrentSeries = (VM_AnimeSeries_User)wrapper;
//LastAnimeSeriesID = ((VM_AnimeSeries_User)wrapper).AnimeSeriesID.Value;
Instance.CurrentOpenGroupFilter = "NoGroup";
}
if (wrapper == null)
{
Instance.CurrentOpenGroupFilter = "Init";
}
Application.Current.Dispatcher.Invoke(DispatcherPriority.Normal, (Action) delegate
{
// update wrappers
// check where this wrapper sits in the heirarchy and remove anything below it
int pos = -1;
if (wrapper != null)
{
for (int i = 0; i < BreadCrumbs.Count; i++)
{
if (BreadCrumbs[i] == null)
{
continue;
}
if (wrapper is VM_GroupFilter && BreadCrumbs[i] is VM_GroupFilter)
{
VM_GroupFilter wrapObj = (VM_GroupFilter)wrapper;
VM_GroupFilter bcObj = (VM_GroupFilter)BreadCrumbs[i];
if (wrapObj.GroupFilterName == bcObj.GroupFilterName)
{
pos = i;
}
}
else if (wrapper is VM_AnimeGroup_User && BreadCrumbs[i] is VM_AnimeGroup_User)
{
VM_AnimeGroup_User wrapObj = (VM_AnimeGroup_User)wrapper;
VM_AnimeGroup_User bcObj = (VM_AnimeGroup_User)BreadCrumbs[i];
if (wrapObj.AnimeGroupID == bcObj.AnimeGroupID)
{
pos = i;
}
}
else if (wrapper is VM_AnimeSeries_User && BreadCrumbs[i] is VM_AnimeSeries_User)
{
VM_AnimeSeries_User wrapObj = (VM_AnimeSeries_User)wrapper;
VM_AnimeSeries_User bcObj = (VM_AnimeSeries_User)BreadCrumbs[i];
if (wrapObj.AnimeSeriesID == bcObj.AnimeSeriesID)
{
pos = i;
}
}
else if (wrapper is VM_AnimeEpisodeType && BreadCrumbs[i] is VM_AnimeEpisodeType)
{
VM_AnimeEpisodeType wrapObj = (VM_AnimeEpisodeType)wrapper;
VM_AnimeEpisodeType bcObj = (VM_AnimeEpisodeType)BreadCrumbs[i];
if (wrapObj.EpisodeTypeDescription == bcObj.EpisodeTypeDescription)
{
pos = i;
}
}
else if (wrapper is VM_AnimeEpisode_User && BreadCrumbs[i] is VM_AnimeEpisode_User)
{
VM_AnimeEpisode_User wrapObj = (VM_AnimeEpisode_User)wrapper;
VM_AnimeEpisode_User bcObj = (VM_AnimeEpisode_User)BreadCrumbs[i];
if (wrapObj.AnimeEpisodeID == bcObj.AnimeEpisodeID)
{
pos = i;
}
}
}
}
else
{
pos = 0;
}
if (pos > 0)
{
for (int i = BreadCrumbs.Count - 1; i >= 0; i--)
{
if (i >= pos)
{
BreadCrumbs.RemoveAt(i);
}
}
}
else if (pos == 0)
{
BreadCrumbs.Clear();
}
BreadCrumbs.Add(wrapper);
if (wrapper is VM_GroupFilter)
{
if (AllGroupsDictionary.Count == 0)
{
RefreshGroupsSeriesData();
}
// apply sorting
// get default sorting from the group filter
}
// means we are at the top level
if (wrapper == null)
{
CurrentWrapperList.Clear();
foreach (VM_GroupFilter grpFilter in AllGroupFiltersDictionary.Values
.Where(a => a != null && !a.ParentGroupFilterID.HasValue).OrderBy(a => a.GroupFilterName))
{
CurrentWrapperList.Add(grpFilter);
}
}
else
{
CurrentWrapperList.Clear();
foreach (IListWrapper wp in wrapper.GetDirectChildren())
{
CurrentWrapperList.Add(wp);
}
}
SetGroupFilterSortingOnMainList();
ViewGroups.Refresh();
//new FilterMainListBox(ViewGroups, SearchTextBox, CurrentGroupFilter);
});
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void btnLoadFiles_Click(object sender, RoutedEventArgs e)
{
try
{
if (!VM_ShokoServer.Instance.ServerOnline)
{
return;
}
ViewFiles.Refresh();
Cursor = Cursors.Wait;
EnableDisableControls(false);
List <VM_VideoLocal> rawVids = new List <VM_VideoLocal>();
if (LoadTypeIsRandom)
{
rawVids = VM_ShokoServer.Instance.ShokoServices
.RandomFileRenamePreview(udRandomFiles.Value.Value,
VM_ShokoServer.Instance.CurrentUser.JMMUserID)
.CastList <VM_VideoLocal>();
}
else if (LoadTypeIsAll)
{
rawVids = VM_ShokoServer.Instance.ShokoServices
.RandomFileRenamePreview(int.MaxValue, VM_ShokoServer.Instance.CurrentUser.JMMUserID)
.CastList <VM_VideoLocal>();
}
else if (LoadTypeIsSeries)
{
Window wdw = Window.GetWindow(this);
SelectGroupSeriesForm frm = new SelectGroupSeriesForm();
frm.Owner = wdw;
frm.Init();
bool?result = frm.ShowDialog();
if (result.HasValue && result.Value == true)
{
if (frm.SelectedObject.GetType() == typeof(VM_AnimeGroup_User))
{
VM_AnimeGroup_User grp = frm.SelectedObject as VM_AnimeGroup_User;
foreach (VM_AnimeSeries_User ser in grp.AllAnimeSeries)
{
rawVids.AddRange(VM_ShokoServer.Instance.ShokoServices
.GetVideoLocalsForAnime(ser.AniDB_ID, VM_ShokoServer.Instance.CurrentUser.JMMUserID)
.Cast <VM_VideoLocal>());
}
}
if (frm.SelectedObject.GetType() == typeof(VM_AnimeSeries_User))
{
VM_AnimeSeries_User ser = frm.SelectedObject as VM_AnimeSeries_User;
rawVids.AddRange(VM_ShokoServer.Instance.ShokoServices
.GetVideoLocalsForAnime(ser.AniDB_ID, VM_ShokoServer.Instance.CurrentUser.JMMUserID)
.Cast <VM_VideoLocal>());
}
}
}
else if (LoadTypeIsLast)
{
int number = udRandomFiles.Value.Value;
rawVids = VM_ShokoServer.Instance.ShokoServices
.SearchForFiles((int)FileSearchCriteria.LastOneHundred, number.ToString(),
VM_ShokoServer.Instance.CurrentUser.JMMUserID)
.OrderByDescending(a => a.DateTimeCreated)
.CastList <VM_VideoLocal>();
}
foreach (VM_VideoLocal vid in rawVids)
{
VM_VideoLocal_Renamed ren = new VM_VideoLocal_Renamed();
ren.VideoLocalID = vid.VideoLocalID;
ren.VideoLocal = vid;
ren.Success = false;
FileResults.Add(ren);
}
FileCount = FileResults.Count;
Cursor = Cursors.Arrow;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
finally
{
Cursor = Cursors.Arrow;
EnableDisableControls(true);
}
}
public void Init(VM_AnimeGroup_User grp)
{
SeriesForGroup = grp.AllAnimeSeries;
}
public static void DeleteGroup(VM_AnimeGroup_User grp)
{
}
protected override void OnShowContextMenu()
{
GUIListItem currentitem = m_Facade.SelectedListItem;
if (currentitem == null)
{
return;
}
if (currentitem.TVTag.GetType() == typeof(VM_AnimeEpisode_User))
{
VM_AnimeEpisode_User ep = currentitem.TVTag as VM_AnimeEpisode_User;
if (ep != null)
{
GUIDialogMenu dlg = (GUIDialogMenu)GUIWindowManager.GetWindow((int)Window.WINDOW_DIALOG_MENU);
if (dlg == null)
{
return;
}
dlg.Reset();
dlg.SetHeading(ep.EpisodeNumberAndName);
dlg.Add("Mark as Watched");
dlg.Add("Play Previous Episode");
dlg.Add("Go To Episode List");
dlg.Add("View Series Info");
dlg.DoModal(GUIWindowManager.ActiveWindow);
switch (dlg.SelectedLabelText)
{
case "Mark as Watched":
ep.ToggleWatchedStatus(true);
LoadData();
break;
case "Play Previous Episode":
if (ep.AnimeSeries == null)
{
return;
}
VM_AnimeEpisode_User epPrev = (VM_AnimeEpisode_User)VM_ShokoServer.Instance.ShokoServices.GetPreviousEpisodeForUnwatched(ep.AnimeSeries.AnimeSeriesID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID);
if (epPrev == null)
{
Utils.DialogMsg("Error", "Previous episode not found");
return;
}
MainWindow.vidHandler.ResumeOrPlay(epPrev);
break;
case "Go To Episode List":
if (ep.AnimeSeries == null)
{
return;
}
MainWindow.Breadcrumbs = new List <History>
{
new History {
Selected = GroupFilterHelper.AllGroupsFilter
}
};
// find the group for this series
VM_AnimeGroup_User grp = ShokoServerHelper.GetGroup(ep.AnimeSeries.AnimeGroupID);
if (grp == null)
{
BaseConfig.MyAnimeLog.Write("Group not found");
return;
}
MainWindow.ContinueWatching_CurrentSeries = ep.AnimeSeries;
MainWindow.Breadcrumbs.Add(new History {
Listing = GroupFilterHelper.AllGroupsFilter, Selected = grp
});
MainWindow.Breadcrumbs.Add(new History {
Listing = grp, Selected = MainWindow.ContinueWatching_CurrentSeries
});
bool foundEpType = false;
if (MainWindow.ContinueWatching_CurrentSeries.EpisodeTypesToDisplay.Count == 1)
{
MainWindow.Breadcrumbs.Add(new History {
Listing = MainWindow.ContinueWatching_CurrentSeries, Selected = null
});
}
else
{
foreach (VM_AnimeEpisodeType anEpType in MainWindow.ContinueWatching_CurrentSeries.EpisodeTypesToDisplay)
{
if (anEpType.EpisodeType == EpisodeType.Episode)
{
MainWindow.Breadcrumbs.Add(new History {
Listing = MainWindow.ContinueWatching_CurrentSeries, Selected = anEpType
});
MainWindow.Breadcrumbs.Add(new History {
Listing = anEpType, Selected = null
});
foundEpType = true;
break;
}
}
if (!foundEpType)
{
return;
}
}
GUIWindowManager.CloseCurrentWindow();
GUIWindowManager.ActivateWindow(Constants.WindowIDs.MAIN, false);
return;
case "View Series Info":
if (ep.AnimeSeries == null)
{
return;
}
MainWindow.GlobalSeriesID = ep.AnimeSeries.AnimeSeriesID;
GUIWindowManager.ActivateWindow(Constants.WindowIDs.ANIMEINFO, false);
break;
}
}
}
}
void btnConfirm_Click(object sender, RoutedEventArgs e)
{
// get the details from the form
groupFilterCondition.ConditionType = (int)Commons.Extensions.Models.GetEnumForText_ConditionType(cboConditionType.SelectedItem.ToString());
groupFilterCondition.ConditionOperator = (int)Commons.Extensions.Models.GetEnumForText_Operator(cboConditionOperator.SelectedItem.ToString());
NumberStyles style = NumberStyles.Number;
CultureInfo culture = CultureInfo.CreateSpecificCulture("en-GB");
// get the parameter details
if (IsParameterDate)
{
if (dpDate.SelectedDate == null)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_SelectDate, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
dpDate.Focus();
return;
}
else
{
groupFilterCondition.ConditionParameter = Commons.Extensions.Models.GetDateAsString(dpDate.SelectedDate.Value);
}
}
if (IsParameterRating)
{
if (txtParameter.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
decimal dRating = -1;
decimal.TryParse(txtParameter.Text, style, culture, out dRating);
if (dRating <= 0 || dRating > 10)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_RatingValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
groupFilterCondition.ConditionParameter = txtParameter.Text.Trim();
}
}
if (IsParameterInteger)
{
if (txtParameter.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
int parmInt = -1;
if (!int.TryParse(txtParameter.Text, out parmInt))
{
MessageBox.Show(Shoko.Commons.Properties.Resources.GroupFilter_IntegerOnly, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
groupFilterCondition.ConditionParameter = parmInt.ToString();
}
}
if (IsParameterLastXDays)
{
if (txtParameter.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
int days = -1;
int.TryParse(txtParameter.Text, out days);
if (days < 1 || days > int.MaxValue)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_DaysValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
groupFilterCondition.ConditionParameter = txtParameter.Text.Trim();
}
}
if (IsParameterTag)
{
if (txtSelectedTags.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
// validate
string[] cats = txtSelectedTags.Text.Trim().Split(',');
groupFilterCondition.ConditionParameter = "";
foreach (string cat in cats)
{
if (cat.Trim().Length == 0)
{
continue;
}
if (cat.Trim() == ", ")
{
continue;
}
if (groupFilterCondition.ConditionParameter.Length > 0)
{
groupFilterCondition.ConditionParameter += ", ";
}
groupFilterCondition.ConditionParameter += cat;
}
}
}
if (IsParameterCustomTag)
{
if (txtSelectedCustomTags.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtSelectedCustomTags.Focus();
return;
}
else
{
// validate
string[] tags = txtSelectedCustomTags.Text.Trim().Split(',');
groupFilterCondition.ConditionParameter = "";
foreach (string tag in tags)
{
if (tag.Trim().Length == 0)
{
continue;
}
if (tag.Trim() == ", ")
{
continue;
}
if (groupFilterCondition.ConditionParameter.Length > 0)
{
groupFilterCondition.ConditionParameter += ", ";
}
groupFilterCondition.ConditionParameter += tag;
}
}
}
if (IsParameterVideoQuality)
{
if (txtSelectedVideoQuality.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
// validate
string[] vidQuals = txtSelectedVideoQuality.Text.Trim().Split(',');
groupFilterCondition.ConditionParameter = "";
foreach (string vidq in vidQuals)
{
if (vidq.Trim().Length == 0)
{
continue;
}
if (vidq.Trim() == ", ")
{
continue;
}
if (groupFilterCondition.ConditionParameter.Length > 0)
{
groupFilterCondition.ConditionParameter += ", ";
}
groupFilterCondition.ConditionParameter += vidq;
}
}
}
if (IsParameterAudioLanguage)
{
if (txtSelectedAudioLanguages.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
// validate
string[] languages = txtSelectedAudioLanguages.Text.Trim().Split(',');
groupFilterCondition.ConditionParameter = "";
foreach (string lanName in languages)
{
if (lanName.Trim().Length == 0)
{
continue;
}
if (lanName.Trim() == ", ")
{
continue;
}
if (groupFilterCondition.ConditionParameter.Length > 0)
{
groupFilterCondition.ConditionParameter += ", ";
}
groupFilterCondition.ConditionParameter += lanName;
}
}
}
if (IsParameterSubtitleLanguage)
{
if (txtSelectedSubtitleLanguages.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
// validate
string[] languages = txtSelectedSubtitleLanguages.Text.Trim().Split(',');
groupFilterCondition.ConditionParameter = "";
foreach (string lanName in languages)
{
if (lanName.Trim().Length == 0)
{
continue;
}
if (lanName.Trim() == ", ")
{
continue;
}
if (groupFilterCondition.ConditionParameter.Length > 0)
{
groupFilterCondition.ConditionParameter += ", ";
}
groupFilterCondition.ConditionParameter += lanName;
}
}
}
if (IsParameterAnimeType)
{
if (txtSelectedAnimeTypes.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
// validate
string[] aTypes = txtSelectedAnimeTypes.Text.Trim().Split(',');
groupFilterCondition.ConditionParameter = "";
foreach (string aType in aTypes)
{
if (aType.Trim().Length == 0)
{
continue;
}
if (aType.Trim() == ", ")
{
continue;
}
if (groupFilterCondition.ConditionParameter.Length > 0)
{
groupFilterCondition.ConditionParameter += ", ";
}
groupFilterCondition.ConditionParameter += aType;
}
}
}
if (IsParameterAnimeGroup)
{
if (lbGroups.SelectedItem == null)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_GroupSelectionRequired, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
lbGroups.Focus();
return;
}
else
{
VM_AnimeGroup_User grp = lbGroups.SelectedItem as VM_AnimeGroup_User;
groupFilterCondition.ConditionParameter = grp.AnimeGroupID.ToString();
}
}
if (IsParameterText)
{
if (txtParameter.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_EnterValue, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtParameter.Focus();
return;
}
else
{
groupFilterCondition.ConditionParameter = txtParameter.Text.Trim();
}
}
DialogResult = true;
Close();
}
protected override void OnClicked(int controlId, GUIControl control, Action.ActionType actionType)
{
MainMenu menu = new MainMenu();
menu.Add(btnAddTag, () =>
{
string tag = Utils.PromptSelectTag("");
if (!MainWindow.RandomWindow_SeriesTags.Contains(tag, StringComparer.InvariantCultureIgnoreCase))
{
MainWindow.RandomWindow_SeriesTags.Add(tag);
SetDisplayDetails();
}
});
menu.Add(btnEpisodeAddTag, () =>
{
string tag = Utils.PromptSelectTag("");
if (!MainWindow.RandomWindow_EpisodeTags.Contains(tag, StringComparer.InvariantCultureIgnoreCase))
{
MainWindow.RandomWindow_EpisodeTags.Add(tag);
SetDisplayDetails();
}
});
menu.Add(btnClearTags, () =>
{
MainWindow.RandomWindow_SeriesTags.Clear();
SetDisplayDetails();
});
menu.Add(btnEpisodeClearTags, () =>
{
MainWindow.RandomWindow_EpisodeTags.Clear();
SetDisplayDetails();
});
menu.Add(btnAllAnyTags, () =>
{
MainWindow.RandomWindow_SeriesAllTags = !MainWindow.RandomWindow_SeriesAllTags;
SetDisplayDetails();
});
menu.Add(btnEpisodeAllAnyTags, () =>
{
MainWindow.RandomWindow_EpisodeAllTags = !MainWindow.RandomWindow_EpisodeAllTags;
SetDisplayDetails();
});
menu.Add(btnRandom, () =>
{
if (togWatched != null)
{
MainWindow.RandomWindow_SeriesWatched = togWatched.Selected;
}
if (togUnwatched != null)
{
MainWindow.RandomWindow_SeriesUnwatched = togUnwatched.Selected;
}
if (togPartiallyWatched != null)
{
MainWindow.RandomWindow_SeriesPartiallyWatched = togPartiallyWatched.Selected;
}
if (togCompleteOnly != null)
{
MainWindow.RandomWindow_SeriesOnlyComplete = togCompleteOnly.Selected;
}
if (togEpisodeUnwatched != null)
{
MainWindow.RandomWindow_EpisodeUnwatched = togEpisodeUnwatched.Selected;
}
if (togEpisodeWatched != null)
{
MainWindow.RandomWindow_EpisodeWatched = togEpisodeWatched.Selected;
}
MainWindow.RandomWindow_CurrentEpisode = null;
MainWindow.RandomWindow_CurrentSeries = null;
btnRandom.IsFocused = true;
LoadData();
});
menu.Add(btnSwitchSeries, () =>
{
btnSwitchSeries.IsFocused = false;
btnRandom.IsFocused = true;
MainWindow.RandomWindow_RandomType = RandomObjectType.Series;
LoadData();
});
menu.Add(btnSwitchEpisode, () =>
{
btnSwitchEpisode.IsFocused = false;
btnRandom.IsFocused = true;
MainWindow.RandomWindow_RandomType = RandomObjectType.Episode;
LoadData();
});
menu.AddFunc(btnPlayEpisode, () =>
{
if (MainWindow.RandomWindow_CurrentEpisode == null)
{
return(false);
}
MainWindow.vidHandler.ResumeOrPlay(MainWindow.RandomWindow_CurrentEpisode);
return(true);
});
menu.AddFunc(btnEpisodeList, () =>
{
if (MainWindow.RandomWindow_CurrentSeries == null)
{
return(false);
}
MainWindow.Breadcrumbs = new List <History>
{
new History {
Selected = GroupFilterHelper.AllGroupsFilter
}
};
// find the group for this series
VM_AnimeGroup_User grp = ShokoServerHelper.GetGroup(MainWindow.RandomWindow_CurrentSeries.AnimeGroupID);
if (grp == null)
{
BaseConfig.MyAnimeLog.Write("Group not found");
return(false);
}
MainWindow.Breadcrumbs.Add(new History {
Listing = GroupFilterHelper.AllGroupsFilter, Selected = grp
});
MainWindow.Breadcrumbs.Add(new History {
Listing = grp, Selected = MainWindow.RandomWindow_CurrentSeries
});
bool foundEpType = false;
if (MainWindow.RandomWindow_CurrentSeries.EpisodeTypesToDisplay.Count == 1)
{
MainWindow.Breadcrumbs.Add(new History {
Listing = MainWindow.RandomWindow_CurrentSeries, Selected = null
});
}
else
{
foreach (VM_AnimeEpisodeType anEpType in MainWindow.RandomWindow_CurrentSeries.EpisodeTypesToDisplay)
{
if (anEpType.EpisodeType == enEpisodeType.Episode)
{
MainWindow.Breadcrumbs.Add(new History {
Listing = MainWindow.RandomWindow_CurrentSeries, Selected = anEpType
});
MainWindow.Breadcrumbs.Add(new History {
Listing = anEpType, Selected = null
});
foundEpType = true;
break;
}
}
if (!foundEpType)
{
return(false);
}
}
GUIWindowManager.CloseCurrentWindow();
GUIWindowManager.ActivateWindow(Constants.WindowIDs.MAIN, false);
return(true);
});
if (menu.Check(control))
{
return;
}
base.OnClicked(controlId, control, actionType);
}
void btnConfirm_Click(object sender, RoutedEventArgs e)
{
//VM_AnimeGroup_User grp = null;
int animeID = 0;
int?groupID = null;
try
{
if (IsAnimeNotSelected)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.NewSeries_SelectAnime, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtAnimeSearch.Focus();
return;
}
if (IsExistingGroup)
{
if (lbGroups.SelectedItem == null)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_GroupSelectionRequired, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
lbGroups.Focus();
return;
}
else
{
VM_AnimeGroup_User grp = lbGroups.SelectedItem as VM_AnimeGroup_User;
groupID = grp.AnimeGroupID;
}
}
if (IsNewGroup)
{
if (txtGroupName.Text.Trim().Length == 0)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.MSG_ERR_GroupNameRequired, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
txtGroupName.Focus();
return;
}
}
if (SelectedAnime != null)
{
animeID = SelectedAnime.AnimeID;
}
Cursor = Cursors.Wait;
if (IsNewGroup)
{
VM_AnimeGroup_User grp = new VM_AnimeGroup_User();
grp.GroupName = txtGroupName.Text.Trim();
grp.SortName = txtGroupName.Text.Trim();
grp.AnimeGroupParentID = null;
grp.Description = "";
grp.IsFave = 0;
grp.IsManuallyNamed = 0;
grp.OverrideDescription = 0;
if (grp.Validate())
{
grp.IsReadOnly = true;
grp.IsBeingEdited = false;
if (grp.Save())
{
VM_MainListHelper.Instance.ViewGroups.Refresh();
groupID = grp.AnimeGroupID;
}
}
}
CL_Response <CL_AnimeSeries_User> response = VM_ShokoServer.Instance.ShokoServices.CreateSeriesFromAnime(animeID, groupID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID);
if (response.ErrorMessage.Length > 0)
{
Cursor = Cursors.Arrow;
MessageBox.Show(response.ErrorMessage, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
VM_MainListHelper.Instance.AllSeriesDictionary[response.Result.AnimeSeriesID] = (VM_AnimeSeries_User)response.Result;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
finally
{
Cursor = Cursors.Arrow;
}
DialogResult = true;
Close();
}
private void SetDisplayDetails()
{
string combinedDetails = string.Empty;
if (MainWindow.RandomWindow_RandomLevel == RandomSeriesEpisodeLevel.GroupFilter)
{
SetGUIProperty(GuiProperty.Random_LevelType, Translation.GroupFilter);
VM_GroupFilter gf = MainWindow.RandomWindow_LevelObject as VM_GroupFilter;
if (gf != null)
{
SetGUIProperty(GuiProperty.Random_LevelName, gf.GroupFilterName);
combinedDetails += Translation.GroupFilter + ": " + gf.GroupFilterName + " ";
}
else
{
ClearGUIProperty(GuiProperty.Random_LevelName);
}
}
else if (MainWindow.RandomWindow_RandomLevel == RandomSeriesEpisodeLevel.Group)
{
SetGUIProperty(GuiProperty.Random_LevelType, Translation.Group);
VM_AnimeGroup_User grp = MainWindow.RandomWindow_LevelObject as VM_AnimeGroup_User;
if (grp != null)
{
SetGUIProperty(GuiProperty.Random_LevelName, grp.GroupName);
combinedDetails += Translation.Group + ": " + grp.GroupName + " ";
}
else
{
ClearGUIProperty(GuiProperty.Random_LevelName);
}
}
else if (MainWindow.RandomWindow_RandomLevel == RandomSeriesEpisodeLevel.Series)
{
SetGUIProperty(GuiProperty.Random_LevelType, Translation.Series);
VM_AnimeSeries_User ser = MainWindow.RandomWindow_LevelObject as VM_AnimeSeries_User;
if (ser != null)
{
SetGUIProperty(GuiProperty.Random_LevelName, ser.SeriesName);
combinedDetails += Translation.Series + ": " + ser.SeriesName + " ";
}
else
{
ClearGUIProperty(GuiProperty.Random_LevelName);
}
}
else
{
ClearGUIProperty(GuiProperty.Random_LevelType);
ClearGUIProperty(GuiProperty.Random_LevelName);
}
if (MainWindow.RandomWindow_RandomType == RandomObjectType.Series)
{
combinedDetails += string.Format(" ({0} " + (MainWindow.RandomWindow_MatchesFound == 1 ? Translation.Match : Translation.Matches) + ")", MainWindow.RandomWindow_MatchesFound);
}
SetGUIProperty(GuiProperty.Random_CombinedFilterDetails, combinedDetails);
SetGUIProperty(GuiProperty.Random_NumberOfMatches, MainWindow.RandomWindow_MatchesFound.ToString(Globals.Culture));
SetGUIProperty(GuiProperty.Random_Series_Tags, string.Join(", ", MainWindow.RandomWindow_SeriesTags));
SetGUIProperty(GuiProperty.Random_Episode_Tags, string.Join(", ", MainWindow.RandomWindow_EpisodeTags));
SetGUIProperty(GuiProperty.Random_Series_TagType, MainWindow.RandomWindow_SeriesAllTags ? Translation.All : Translation.Any);
SetGUIProperty(GuiProperty.Random_Episode_TagType, MainWindow.RandomWindow_EpisodeAllTags ? Translation.All : Translation.Any);
}
public static bool EvaluateGroupFilter(VM_GroupFilter gf, VM_AnimeGroup_User grp)
{
return(gf.EvaluateGroupFilter(grp));
}
private List <VM_AnimeSeries_User> GetSeriesForGroup()
{
List <VM_AnimeSeries_User> serList = new List <VM_AnimeSeries_User>();
try
{
BaseConfig.MyAnimeLog.Write("Getting list of candidate random series for group");
if (MainWindow.RandomWindow_RandomLevel != RandomSeriesEpisodeLevel.Group)
{
return(serList);
}
VM_AnimeGroup_User grp = MainWindow.RandomWindow_LevelObject as VM_AnimeGroup_User;
if (grp == null)
{
return(serList);
}
bool allTags = MainWindow.RandomWindow_SeriesAllTags;
if (MainWindow.RandomWindow_RandomType == RandomObjectType.Episode)
{
allTags = MainWindow.RandomWindow_EpisodeAllTags;
}
BaseConfig.MyAnimeLog.Write("Getting list of candidate random series for: " + grp.GroupName);
HashSet <string> selectedTags = new HashSet <string>(MainWindow.RandomWindow_SeriesTags, StringComparer.InvariantCultureIgnoreCase);
if (MainWindow.RandomWindow_RandomType == RandomObjectType.Episode)
{
selectedTags = new HashSet <string>(MainWindow.RandomWindow_EpisodeTags, StringComparer.InvariantCultureIgnoreCase);
}
foreach (VM_AnimeSeries_User ser in grp.AllSeries)
{
// tags
if (selectedTags.Count > 0)
{
bool foundTag = false;
if (allTags)
{
foundTag = true; // all
}
if (ser.Anime.GetAllTags().Overlaps(selectedTags))
{
foundTag = true;
}
if (!foundTag)
{
continue;
}
}
serList.Add(ser);
}
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
return(serList);
}
