public void FilterDeckListTest003_FilterByTwoAttributes()
{
List <DeckAttribute> filterAttrib = new List <DeckAttribute>()
{
DeckAttribute.Strength, DeckAttribute.Endurance
};
DeckClass?selectedClass = null;
var filteredClasses = new ObservableCollection <DeckClass>(
Utils.ClassAttributesHelper.FindClassByAttribute(filterAttrib)
);
Mock <IDeckTypeSelectorViewModel> typeSelector = GetFullTypeFilter();
int expectedCount = 0 + //none inrandom data
1; //one for every class
DeckListViewModel model = new DeckListViewModel();
IEnumerable <Deck> result = model.FilterDeckList(
DeckBase,
null,
false,
false,
selectedClass,
filteredClasses,
null);
Assert.AreEqual(expectedCount, result.Count());
Assert.IsTrue(result.All(r => { return(Utils.ClassAttributesHelper.Classes[r.Class.Value].Contains(filterAttrib[0])); }));
}
public void FilterDeckListTest002_FilterByOneAttribute()
{
DeckAttribute filterAttrib = DeckAttribute.Strength;
DeckClass? selectedClass = null;
var filteredClasses = new ObservableCollection <DeckClass>(
ClassAttributesHelper.FindClassByAttribute(filterAttrib)
);
Mock <IDeckTypeSelectorViewModel> typeSelector = GetFullTypeFilter();
int expectedCount = 3 + //random data - archer i battlemage y strength
5; //one for every class
DeckListViewModel model = new DeckListViewModel();
IEnumerable <Deck> result = model.FilterDeckList(
DeckBase,
null,
false,
false,
selectedClass,
filteredClasses,
null);
Assert.AreEqual(expectedCount, result.Count());
Assert.IsTrue(result.All(r => { return(Utils.ClassAttributesHelper.Classes[r.Class.Value].Contains(filterAttrib)); }));
}
public void FilterCombo001_WhenFilteredSelectFirstClass_NoFilter()
{
DeckClassSelectorViewModel model = new DeckClassSelectorViewModel();
DeckClass?expected = null;
model.FilterCombo();
//none selcted
Assert.AreEqual(expected, model.SelectedClass);
}
public void FilterDeckListTest008_HideCompletedVersusArenaRunsNoClassFilter()
{
DeckClass?selectedClass = null;
var filteredClasses = new ObservableCollection <DeckClass>(ClassAttributesHelper.Classes.Keys);
List <DeckType> typeFilter = new List <DeckType>()
{
DeckType.VersusArena
};
var filteredTypes = new ObservableCollection <DeckType>(typeFilter);
var showCompletedArenaRuns = false;
Mock <ITracker> tracker = new Mock <ITracker>();
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
trackerFactory.Setup(tf => tf.GetNewGuid()).Returns(() => Guid.NewGuid());
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
trackerFactory.Setup(tf => tf.GetService <IDeckService>()).Returns(new DeckService(trackerFactory.Object));
Deck deckToShow = new Deck(trackerFactory.Object)
{
Type = DeckType.VersusArena, Class = DeckClass.Assassin
};
Deck deckToHide = new Deck(trackerFactory.Object)
{
Type = DeckType.VersusArena, Class = DeckClass.Inteligence
};
tracker.Setup(t => t.Games).Returns(
new ObservableCollection <DataModel.Game>(
GenerateGamesList(deckToShow, 2, 2).Union(GenerateGamesList(deckToHide, 7, 2))
));
int expectedCount = 1;
DeckListViewModel model = new DeckListViewModel();
IEnumerable <Deck> result = model.FilterDeckList(
new Deck[] { deckToShow, deckToHide },
filteredTypes,
showCompletedArenaRuns,
false,
selectedClass,
filteredClasses,
null);
Assert.AreEqual(expectedCount, result.Count());
Assert.AreEqual(deckToShow.DeckId, result.First().DeckId);
}
public DeckListFilterChanged(
Source source,
IEnumerable <DeckType> filteredTypes,
bool?showFinishedArenaRuns,
bool?showHiddenDecks,
DeckClass?selectedClass,
IEnumerable <DeckClass> filteredClasses)
{
this.ChangeSource = source;
this.FilteredTypes = filteredTypes;
this.ShowFInishedArenaRuns = showFinishedArenaRuns.HasValue ? showFinishedArenaRuns.Value : false;
this.ShowHiddenDecks = showHiddenDecks.HasValue ? showHiddenDecks.Value : false;
this.SelectedClass = selectedClass;
this.FilteredClasses = filteredClasses;
}
public dynamic GetDeckVsClass(DeckClass?opponentClass)
{
return(this.DeckGames
.Where(g => (g.OpponentClass.HasValue) && //filter out all game where calss is not set (if we include in show all, crash below as here is no nul key in classes.attibutes)
((g.OpponentClass == opponentClass) || (opponentClass == null))) //class = param, or oaram is null - show all"
.GroupBy(d => d.OpponentClass.Value)
.Select(d => new
{
Class = d.Key,
Attributes = ClassAttributesHelper.Classes[d.Key],
Total = d.Count(),
Victory = d.Where(d2 => d2.Outcome == GameOutcome.Victory).Count(),
Defeat = d.Where(d2 => d2.Outcome == GameOutcome.Defeat).Count(),
WinPercent = d.Count() > 0 ? Math.Round((decimal)d.Where(d2 => d2.Outcome == GameOutcome.Victory).Count() / (decimal)d.Count() * 100, 0).ToString() : "-"
}));
}
public void FilterCombo002_WhenFilteredSelectFirstClass_OneSelected()
{
DeckClassSelectorViewModel model = new DeckClassSelectorViewModel();
DeckClass?expected = DeckClass.Inteligence;
model.FilterClicked(DeckAttribute.Intelligence);
//has been filter applied?
Assert.AreNotEqual(Utils.ClassAttributesHelper.Classes.Count, model.FilteredClasses.Count);
model.FilterCombo();
//none selcted
Assert.AreEqual(expected, model.SelectedClass);
}
internal void SyncToggleButtons(DeckClass?value)
{
//if (value != null)
{
ResetToggleButtons();
//toggle attributes buttons
if (value != null)
{
foreach (DeckAttribute da in ClassAttributesHelper.Classes[value.Value])
{
FilterButtonState[da] = true;
}
}
FilterCombo();
RaisePropertyChangedEvent("FilterButtonStateCollection");
}
}
public void FilterDeckListTest004_ClearFilters()
{
DeckClass?selectedClass = null;
var filteredClasses = new ObservableCollection <DeckClass>(
Utils.ClassAttributesHelper.FindClassByAttribute(DeckAttribute.Neutral)
);
Mock <IDeckTypeSelectorViewModel> typeSelector = GetFullTypeFilter();
int expectedCount = DeckBase.Count;
DeckListViewModel model = new DeckListViewModel();
//do first filter - not intrested
IEnumerable <Deck> result = model.FilterDeckList(
DeckBase,
null,
false,
false,
selectedClass,
filteredClasses,
null);
//model is norw filyred
Assert.AreNotEqual(expectedCount, result.Count());
//reset filters - class selector returns all clases
filteredClasses = new ObservableCollection <DeckClass>(
Utils.ClassAttributesHelper.Classes.Keys
);
result = model.FilterDeckList(
DeckBase,
null,
false,
true,
selectedClass,
filteredClasses,
null);
Assert.AreEqual(expectedCount, result.Count());
}
public void ShowWinsVsClass(DeckClass?deckClass)
{
if ((deckClass != null) && (tracker.ActiveDeck != null))
{
var res = tracker.ActiveDeck.GetDeckVsClass(deckClass);
dynamic data = (res as System.Collections.IEnumerable).Cast <object>().FirstOrDefault();
if (data == null)
{
data = new { Class = deckClass, Victory = 0, Defeat = 0, WinPercent = "-" };
}
this.OpponentClassWins = string.Format("vs {0}: {1}-{2} ({3}%)",
data.Class,
data.Victory,
data.Defeat,
data.WinPercent);
}
else
{
this.OpponentClassWins = "Select opponent class";
}
}
public void FilterCombo()
{
var filteredClasses = Utils.ClassAttributesHelper.FindClassByAttribute(FilterButtonState.Where(f => f.Value).Select(f => f.Key)).ToList();
if ((filteredClasses.Count >= 1) &&
(FilterButtonState.Any(f => f.Value)))
{
selectedClass = filteredClasses.OrderBy(fc => ClassAttributesHelper.Classes[fc].Count).First();
}
else
{
selectedClass = null;
}
RaisePropertyChangedEvent("SelectedClass");
//remove classes not in use.Clear() will trigger binding, as SelectedClass will be set to null by framework
foreach (DeckClass dc in FilteredClasses.ToList())
{
if (!filteredClasses.Contains(dc))
{
FilteredClasses.Remove(dc);
}
}
// FilteredClasses.Clear();
foreach (DeckClass dc in filteredClasses)
{
if (!FilteredClasses.Contains(dc))
{
int i = 0;
IComparer <DeckClass> comparer = Comparer <DeckClass> .Default;
while (i < FilteredClasses.Count && comparer.Compare(FilteredClasses[i], dc) < 0)
{
i++;
}
FilteredClasses.Insert(i, dc);
}
}
messenger.Send(new DeckListFilterChanged(DeckListFilterChanged.Source.ClassFilter, null, null, null, SelectedClass, FilteredClasses), MessangerContext);
}
public IEnumerable <Deck> FilterDeckList(
IEnumerable <Deck> deckBase,
IEnumerable <DeckType> filteredTypes,
bool showCompletedArenaRuns,
bool showHiddenDecks,
DeckClass?selectedClass,
IEnumerable <DeckClass> filteredClasses,
string searchString)
{
IEnumerable <Deck> filteredList;
if (selectedClass.HasValue)
{
//specific class slected (there might nbe more in filteredclasses propery!!!
filteredList = deckBase.Where(d =>
(d.Class == selectedClass) &&
((filteredTypes == null) || (filteredTypes.Contains(d.Type))) &&
((showCompletedArenaRuns) || (!d.IsArenaRunFinished())) &&
((showHiddenDecks) || (!d.IsHidden)) &&
((String.IsNullOrEmpty(searchString)) || (deckService.SearchString(d, searchString)))
);
return(filteredList);
}
else
{
//filter by attributes
filteredList = deckBase.Where(d =>
d.Class.HasValue &&
(filteredClasses == null || filteredClasses.Contains(d.Class.Value)) &&
((filteredTypes == null) || (filteredTypes.Contains(d.Type))) &&
((showCompletedArenaRuns) || (!d.IsArenaRunFinished())) &&
((showHiddenDecks) || (!d.IsHidden)) &&
((String.IsNullOrEmpty(searchString)) || (deckService.SearchString(d, searchString)))
);
return(filteredList);
}
}
