void btnRandomSeries_Click(object sender, RoutedEventArgs e)
{
VM_GroupFilter gf = DataContext as VM_GroupFilter;
if (gf == null)
{
return;
}
MainWindow mainwdw = (MainWindow)Window.GetWindow(this);
RandomSeriesForm frm = new RandomSeriesForm();
frm.Owner = Window.GetWindow(this);;
frm.Init(RandomSeriesEpisodeLevel.GroupFilter, gf);
bool?result = frm.ShowDialog();
if (result.HasValue && result.Value && frm.Series != null)
{
if (mainwdw == null)
{
return;
}
mainwdw.ShowPinnedSeries(frm.Series);
}
}
public static List <VM_GroupFilter> GetChildGroupFilters(VM_GroupFilter grpf)
{
List <VM_GroupFilter> gfs = new List <VM_GroupFilter>();
try
{
int grid = 0;
if (grpf != null)
{
grid = grpf.GroupFilterID;
}
List <VM_GroupFilter> gf_cons = VM_ShokoServer.Instance.ShokoServices.GetGroupFilters(grid).CastList <VM_GroupFilter>();
foreach (VM_GroupFilter gf_con in gf_cons.Where(a => a.Groups.ContainsKey(VM_ShokoServer.Instance.CurrentUser.JMMUserID) && a.Groups[VM_ShokoServer.Instance.CurrentUser.JMMUserID].Count() > 0 ||
(a.FilterType & (int)GroupFilterType.Directory) == (int)GroupFilterType.Directory).OrderBy(a => a.GroupFilterName))
{
gf_con.ParentFilter = grpf;
gfs.Add(gf_con);
}
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
gfs.Sort();
return(gfs);
}
/*static public bool SetSelectedItem(this TreeView treeView, object item)
* {
* return SetSelected(treeView, item);
* }
*
* static private bool SetSelected(ItemsControl parent, object child)
* {
* if (parent == null || child == null)
* {
* return false;
* }
*
* TreeViewItem childNode = parent.ItemContainerGenerator.ContainerFromItem(child) as TreeViewItem;
*
* if (childNode != null)
* {
* childNode.Focus();
* return childNode.IsSelected = true;
* }
*
* if (parent.Items.Count > 0)
* {
* foreach (object childItem in parent.Items)
* {
* ItemsControl childControl = parent.ItemContainerGenerator.ContainerFromItem(childItem) as ItemsControl;
*
* if (SetSelected(childControl, child))
* {
* return true;
* }
* }
* }
*
* return false;
* }*/
public static List <SortDescription> GetSortDescriptions(this VM_GroupFilter gf)
{
List <SortDescription> sortlist = new List <SortDescription>();
foreach (VM_GroupFilterSortingCriteria gfsc in gf.SortCriteriaList)
{
sortlist.Add(gfsc.SortType.GetSortDescription(gfsc.SortDirection));
}
return(sortlist);
}
public void SetGroupFilterSortingOnForms(VM_GroupFilter gf)
{
ViewGroupsForms.SortDescriptions.Clear();
if (gf != null)
{
List <SortDescription> sortlist = gf.GetSortDescriptions();
foreach (SortDescription sd in sortlist)
{
ViewGroupsForms.SortDescriptions.Add(sd);
}
}
}
void chkApplyToSeriesEditing_Click(object sender, RoutedEventArgs e)
{
chkApplyToSeries.IsChecked = chkApplyToSeriesEditing.IsChecked;
VM_GroupFilter gf = DataContext as VM_GroupFilter;
if (gf == null)
{
return;
}
gf.ApplyToSeries = chkApplyToSeriesEditing.IsChecked.Value ? 1 : 0;
}
public static List <VM_AnimeGroup_User> GetAnimeGroupsForFilter(VM_GroupFilter groupFilter)
{
try
{
List <VM_AnimeGroup_User> rawGrps = VM_ShokoServer.Instance.ShokoServices.GetAnimeGroupsForFilter(groupFilter.GroupFilterID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID, false).CastList <VM_AnimeGroup_User>() ?? new List <VM_AnimeGroup_User>();
return(groupFilter.SortGroups(rawGrps.AsQueryable()).ToList());
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
return(new List <VM_AnimeGroup_User>());
}
public void SetGroupFilterSortingOnForms(VM_GroupFilter gf)
{
ViewGroupsForms.SortDescriptions.Clear();
if (gf?.IsDirectoryFilter != true)
{
return;
}
List <SortDescription> sortlist = gf.GetSortDescriptions();
foreach (SortDescription sd in sortlist)
{
ViewGroupsForms.SortDescriptions.Add(sd);
}
}
//[LogExecutionTime]
public void SetGroupFilterSortingOnMainList()
{
if (CurrentWrapper is VM_GroupFilter)
{
VM_GroupFilter gf = (VM_GroupFilter)CurrentWrapper;
ViewGroups.SortDescriptions.Clear();
List <SortDescription> sortlist = gf.GetSortDescriptions();
foreach (SortDescription sd in sortlist)
{
ViewGroups.SortDescriptions.Add(sd);
}
}
else
{
ViewGroups.SortDescriptions.Clear();
}
}
public void Init(VM_GroupFilter gf, VM_GroupFilterSortingCriteria gfsc)
{
groupFilter = gf;
groupFilterSortingCriteria = gfsc;
try
{
cboSortType.Items.Clear();
foreach (string stype in Commons.Extensions.Models.GetAllSortTypes())
{
if (gf != null)
{
bool alreadyExists = false;
foreach (VM_GroupFilterSortingCriteria gfsc_old in gf.SortCriteriaList)
{
if (gfsc_old.SortType.GetTextForEnum_Sorting() == stype)
{
alreadyExists = true;
break;
}
}
if (!alreadyExists)
{
cboSortType.Items.Add(stype);
}
}
}
if (cboSortType.Items.Count > 0)
{
cboSortType.SelectedIndex = 0;
}
cboDirection.Items.Clear();
cboDirection.Items.Add(Commons.Extensions.Models.GetTextForEnum_SortDirection(GroupFilterSortDirection.Asc));
cboDirection.Items.Add(Commons.Extensions.Models.GetTextForEnum_SortDirection(GroupFilterSortDirection.Desc));
cboDirection.SelectedIndex = 0;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void cboBaseConditionEditing_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
VM_GroupFilter gf = DataContext as VM_GroupFilter;
if (gf == null)
{
return;
}
if (cboBaseConditionEditing.SelectedIndex == 0)
{
gf.BaseCondition = 1;
}
else
{
gf.BaseCondition = 2;
}
cboBaseCondition.SelectedIndex = cboBaseConditionEditing.SelectedIndex;
}
void GroupFilterAdmin_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
VM_GroupFilter gf = DataContext as VM_GroupFilter;
if (gf == null)
{
return;
}
if (gf.BaseCondition == 1)
{
cboBaseConditionEditing.SelectedIndex = 0;
cboBaseConditionEditing.SelectedIndex = 0;
}
else
{
cboBaseConditionEditing.SelectedIndex = 1;
cboBaseConditionEditing.SelectedIndex = 1;
}
}
public static List <VM_AnimeGroup_User> GetAnimeGroupsForFilter(VM_GroupFilter groupFilter)
{
try
{
List <VM_AnimeGroup_User> rawGrps = VM_ShokoServer.Instance.ShokoServices.GetAnimeGroupsForFilter(groupFilter.GroupFilterID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID, false).CastList <VM_AnimeGroup_User>() ?? new List <VM_AnimeGroup_User>();
if (string.IsNullOrEmpty(groupFilter.SortingCriteria))
{
groupFilter.SortingCriteria = "5;1";
}
IQueryable <VM_AnimeGroup_User> qr = rawGrps.AsQueryable();
qr = SortGroups(groupFilter, qr);
return(qr.ToList());
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
return(new List <VM_AnimeGroup_User>());
}
void lbFilterConditions_Editing_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
VM_GroupFilter gf = DataContext as VM_GroupFilter;
if (gf == null)
{
return;
}
VM_GroupFilterCondition gfc = lbFilterConditions_Editing.SelectedItem as VM_GroupFilterCondition;
if (gfc == null)
{
return;
}
try
{
GroupFilterConditionForm frm = new GroupFilterConditionForm();
frm.Owner = Window.GetWindow(this);
frm.Init(gf, gfc);
bool?result = frm.ShowDialog();
if (result.HasValue && result.Value == true)
{
Window win = Window.GetWindow(this);
MainWindow main = win as MainWindow;
gf.IsBeingEdited = true;
//gf.FilterConditions.Add(gfc);
VM_MainListHelper.Instance.ViewGroupsForms.Filter = main.GroupFilter_GroupSearch;
VM_MainListHelper.Instance.SetGroupFilterSortingOnForms(gf);
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public void Init(VM_GroupFilter gf, VM_GroupFilterCondition gfc)
{
groupFilter = gf;
groupFilterCondition = gfc;
try
{
cboConditionType.Items.Clear();
foreach (string cond in Commons.Extensions.Models.GetAllConditionTypes())
{
cboConditionType.Items.Add(cond);
}
PopulateAnimeGroups();
PopulateTags();
PopulateCustomTags();
PopulateVideoQuality();
PopulateAnimeTypes();
PopulateLanguages();
// find the right condition
int idx = 0;
for (int i = 0; i < cboConditionType.Items.Count; i++)
{
GroupFilterConditionType conditionTypeTemp = Commons.Extensions.Models.GetEnumForText_ConditionType(cboConditionType.Items[i].ToString());
if (conditionTypeTemp == gfc.ConditionTypeEnum)
{
idx = i;
break;
}
}
cboConditionType.SelectedIndex = idx;
GroupFilterConditionType conditionType = Commons.Extensions.Models.GetEnumForText_ConditionType(cboConditionType.SelectedItem.ToString());
cboConditionOperator.Items.Clear();
foreach (string op in conditionType.GetAllowedOperators())
{
cboConditionOperator.Items.Add(op);
}
cboConditionType.SelectionChanged += new SelectionChangedEventHandler(cboConditionType_SelectionChanged);
cboConditionOperator.SelectionChanged += new SelectionChangedEventHandler(cboConditionOperator_SelectionChanged);
// find the right operator
idx = 0;
for (int i = 0; i < cboConditionOperator.Items.Count; i++)
{
GroupFilterOperator opTypeTemp = Commons.Extensions.Models.GetEnumForText_Operator(cboConditionOperator.Items[i].ToString());
if (opTypeTemp == gfc.ConditionOperatorEnum)
{
idx = i;
break;
}
}
cboConditionOperator.SelectedIndex = idx;
GroupFilterOperator opType = Commons.Extensions.Models.GetEnumForText_Operator(cboConditionOperator.Items[idx].ToString());
// display the selected filter value
switch (conditionType)
{
case GroupFilterConditionType.AirDate:
case GroupFilterConditionType.SeriesCreatedDate:
case GroupFilterConditionType.EpisodeAddedDate:
case GroupFilterConditionType.EpisodeWatchedDate:
case GroupFilterConditionType.LatestEpisodeAirDate:
if (opType == GroupFilterOperator.LastXDays)
{
txtParameter.Text = gfc.ConditionParameter;
}
else
{
DateTime airDate = gfc.ConditionParameter.GetDateFromString();
dpDate.SelectedDate = airDate;
}
break;
case GroupFilterConditionType.AnimeGroup:
// don't display anything
break;
case GroupFilterConditionType.AnimeType:
case GroupFilterConditionType.Tag:
case GroupFilterConditionType.CustomTags:
case GroupFilterConditionType.VideoQuality:
case GroupFilterConditionType.AniDBRating:
case GroupFilterConditionType.UserRating:
case GroupFilterConditionType.AudioLanguage:
case GroupFilterConditionType.SubtitleLanguage:
case GroupFilterConditionType.Year:
txtParameter.Text = gfc.ConditionParameter;
break;
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public static List <VM_GroupFilter> GetChildFilters(VM_GroupFilter pre)
{
return(GroupFilterHelper.GetChildGroupFilters(pre));
}
public static bool EvaluateGroupFilter(VM_GroupFilter gf, VM_AnimeGroup_User grp)
{
return(gf.EvaluateGroupFilter(grp));
}
public void UpdateAll()
{
try
{
CL_MainChanges changes = VM_ShokoServer.Instance.ShokoServices.GetAllChanges(LastChange, VM_ShokoServer.Instance.CurrentUser.JMMUserID);
AllAnimeDetailedDictionary = null;
//Update Anime Groups (Must be done before Series)
foreach (int gr in changes.Groups.RemovedItems)
{
AllGroupsDictionary.Remove(gr);
}
foreach (VM_AnimeGroup_User g in changes.Groups.ChangedItems.CastList <VM_AnimeGroup_User>())
{
VM_AnimeGroup_User v;
if (AllGroupsDictionary.TryGetValue(g.AnimeGroupID, out v))
{
v.Populate(g);
}
else
{
AllGroupsDictionary[g.AnimeGroupID] = g;
}
}
//Update Anime Series (NOTE: relies on AllGroupsDictionary being up to date)
foreach (int sr in changes.Series.RemovedItems)
{
AllSeriesDictionary.Remove(sr);
}
foreach (VM_AnimeSeries_User s in changes.Series.ChangedItems.CastList <VM_AnimeSeries_User>())
{
VM_AnimeSeries_User v;
if (AllSeriesDictionary.TryGetValue(s.AnimeSeriesID, out v))
{
v.Populate(s);
}
else
{
AllSeriesDictionary[s.AnimeSeriesID] = s;
}
}
foreach (VM_AnimeGroup_User v in AllGroupsDictionary.Values)
{
v.PopulateSerieInfo(AllGroupsDictionary, AllSeriesDictionary);
}
//Update Group Filters
foreach (int gfr in changes.Filters.RemovedItems)
{
AllGroupFiltersDictionary.Remove(gfr);
}
foreach (VM_GroupFilter gf in changes.Filters.ChangedItems.CastList <VM_GroupFilter>())
{
VM_GroupFilter v;
if (AllGroupFiltersDictionary.TryGetValue(gf.GroupFilterID, out v))
{
v.Populate(gf);
}
else
{
AllGroupFiltersDictionary[gf.GroupFilterID] = gf;
}
}
foreach (int gf in changes.Filters.ChangedItems.Select(a => a.GroupFilterID))
{
VM_GroupFilter v = AllGroupFiltersDictionary[gf];
//Recalculate Groups Count
v.GetDirectChildren();
}
LastChange = changes.LastChange;
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
//[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);
}
}
public void RefreshGroupFiltersOnly()
{
//LoadTestData();
//return;
try
{
// set this to null so that it will be refreshed the next time it is needed
List <VM_GroupFilter> gfRaw = VM_ShokoServer.Instance.ShokoServices.GetAllGroupFilters().CastList <VM_GroupFilter>();
if (gfRaw.Count == 0)
{
return;
}
Application.Current.Dispatcher.Invoke(DispatcherPriority.Normal, (Action) delegate
{
object p = CurrentWrapper;
VM_GroupFilter vms = AllGroupFiltersDictionary.Values.FirstOrDefault(a => a.GroupFilterID == 0);
AllGroupFiltersDictionary.Clear();
if (vms != null)
{
AllGroupFiltersDictionary.Add(0, vms);
}
foreach (VM_GroupFilter gf in gfRaw.OrderBy(a => a.GroupFilterName))
{
AllGroupFiltersDictionary[gf.GroupFilterID] = gf;
}
//Restore previous condition
if (p is VM_GroupFilter)
{
int id = ((VM_GroupFilter)p).GroupFilterID;
if (AllGroupFiltersDictionary.ContainsKey(id))
{
CurrentWrapper = AllGroupFiltersDictionary[id];
}
}
else if (p is VM_AnimeGroup_User)
{
int id = ((VM_AnimeGroup_User)p).AnimeGroupID;
if (AllGroupsDictionary.ContainsKey(id))
{
CurrentWrapper = AllGroupsDictionary[id];
}
}
else if (p is VM_AnimeSeries_User)
{
int id = ((VM_AnimeSeries_User)p).AnimeSeriesID;
if (AllSeriesDictionary.ContainsKey(id))
{
CurrentWrapper = AllSeriesDictionary[id];
}
}
OnRefreshed();
});
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
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);
}
private List <VM_AnimeSeries_User> GetSeriesForGroupFilter()
{
List <VM_AnimeSeries_User> serList = new List <VM_AnimeSeries_User>();
try
{
if (LevelType != RandomSeriesEpisodeLevel.GroupFilter)
{
return(serList);
}
VM_GroupFilter gf = LevelObject as VM_GroupFilter;
if (gf == null)
{
return(serList);
}
foreach (VM_AnimeGroup_User grp in VM_MainListHelper.Instance.AllGroupsDictionary.Values)
{
// ignore sub groups
if (grp.AnimeGroupParentID.HasValue)
{
continue;
}
foreach (VM_AnimeSeries_User ser in grp.AllAnimeSeries)
{
if (gf.EvaluateGroupFilter(ser))
{
// 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);
}
private List <VM_AnimeSeries_User> GetSeriesForGroupFilter()
{
List <VM_AnimeSeries_User> serList = new List <VM_AnimeSeries_User>();
try
{
BaseConfig.MyAnimeLog.Write("Getting list of candidate random series");
if (MainWindow.RandomWindow_RandomLevel != RandomSeriesEpisodeLevel.GroupFilter)
{
return(serList);
}
VM_GroupFilter gf = MainWindow.RandomWindow_LevelObject as VM_GroupFilter;
if (gf?.GroupFilterID == null)
{
return(serList);
}
BaseConfig.MyAnimeLog.Write("Getting list of candidate random series for: " + gf.GroupFilterName);
bool allTags = MainWindow.RandomWindow_SeriesAllTags;
if (MainWindow.RandomWindow_RandomType == RandomObjectType.Episode)
{
allTags = MainWindow.RandomWindow_EpisodeAllTags;
}
bool completeSeries = true;
bool allWatched = true;
bool unwatched = true;
bool partiallyWatched = true;
if (togWatched != null)
{
allWatched = togWatched.Selected;
}
if (togUnwatched != null)
{
unwatched = togUnwatched.Selected;
}
if (togPartiallyWatched != null)
{
partiallyWatched = togPartiallyWatched.Selected;
}
if (togCompleteOnly != null)
{
completeSeries = togCompleteOnly.Selected;
}
List <VM_AnimeGroup_User> contracts = VM_ShokoServer.Instance.ShokoServices.GetAnimeGroupsForFilter(
gf.GroupFilterID, VM_ShokoServer.Instance.CurrentUser.JMMUserID,
false).CastList <VM_AnimeGroup_User>();
BaseConfig.MyAnimeLog.Write("Total groups for filter = " + contracts.Count);
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_AnimeGroup_User grp in contracts)
{
// ignore sub groups
if (grp.AnimeGroupParentID.HasValue)
{
continue;
}
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;
}
}
if (!ser.IsComplete && completeSeries)
{
continue;
}
if (allWatched && ser.AllFilesWatched)
{
serList.Add(ser);
continue;
}
if (unwatched && !ser.AnyFilesWatched)
{
serList.Add(ser);
continue;
}
if (partiallyWatched && ser.AnyFilesWatched && !ser.AllFilesWatched)
{
serList.Add(ser);
}
}
}
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
return(serList);
}
public static bool EvaluateGroupFilter(VM_GroupFilter gf, VM_AnimeSeries_User ser)
{
return(gf.EvaluateGroupFilter(ser));
}
public static List <VM_GroupFilter> GetChildGroupFilters(VM_GroupFilter gf)
{
return(ShokoServerHelper.GetChildGroupFilters(gf));
}
