private void UpdateStats()
{
int wins = 0;
int losses = 0;
if (_games == null || _games.Count == 0)
{
UpdateGames();
}
Stats.Clear();
var filter = new GameFilter(null, SelectedRegion, SelectedGameMode, SelectedTimeFrame,
SelectedGameFormat, PlayerClass.ALL, SelectedClass, RankMin, RankMax);
var filtered = filter.Apply(_games);
var stats = ViewModelHelper.GetArchetypeStats(filtered);
foreach (var s in stats)
{
Stats.Add(s);
wins += s.TotalWins;
losses += s.TotalLosses;
}
TotalWins = wins;
TotalLosses = losses;
}
public void setFilter(GameFilter filter)
{
List = new GameList(filter);
titleText.Text = List.Filter.listType.Value;
TitleIcon.Text = List.Filter.listType.Icon;
updateList();
}
public void ConvertTimeFrameToRange_All()
{
var range = GameFilter.ConvertTimeFrameToRange(TimeFrame.ALL, now);
Assert.AreEqual(DateTime.MinValue, range.Start);
Assert.AreEqual(DateTime.Parse(now), range.End);
}
public void DefaultFilter_ShouldDoNoFiltering()
{
var filter = new GameFilter();
var filtered = filter.Apply(games);
CollectionAssert.AreEquivalent(games, filtered);
}
public OverallResultByGameFilter(GameFilter gameFilter, List <UserResult> userResults)
{
if (gameFilter == null)
{
throw new ArgumentNullException("gameFilter");
}
if (userResults == null)
{
throw new ArgumentNullException("userResults");
}
if (userResults.Count == 0)
{
//userResults.Add(new UserResult(){
}
else
{
foreach (var userResult in userResults)
{
if (gameFilter.GameFilterId != userResult.GameFilterId)
{
throw new ArgumentException(
string.Format("gameFilter.GameFilterId:{0} does not match userResult.GameFilterId:{1}",
gameFilter.GameFilterId,
userResult.GameFilterId));
}
}
}
GameFilter = gameFilter;
UserResults = userResults;
Places = new List <int>();
}
public async void BrowserDownload(GameBananaRecord record, GameFilter game)
{
var gameName = "";
switch (game)
{
case GameFilter.P3:
gameName = "Persona 3 FES";
break;
case GameFilter.P4G:
gameName = "Persona 4 Golden";
break;
case GameFilter.P5:
gameName = "Persona 5";
break;
case GameFilter.P5S:
gameName = "Persona 5 Strikers";
break;
}
DownloadWindow downloadWindow = new DownloadWindow(record);
downloadWindow.ShowDialog();
if (downloadWindow.YesNo)
{
string downloadUrl = null;
string fileName = null;
if (record.Files.Count == 1)
{
downloadUrl = record.Files[0].DownloadUrl;
fileName = record.Files[0].FileName;
}
else if (record.Files.Count > 1)
{
UpdateFileBox fileBox = new UpdateFileBox(record.Files, record.Title);
fileBox.Activate();
fileBox.ShowDialog();
downloadUrl = fileBox.chosenFileUrl;
fileName = fileBox.chosenFileName;
}
if (downloadUrl != null && fileName != null)
{
await DownloadFile(downloadUrl, fileName, new Progress <DownloadProgress>(ReportUpdateProgress),
CancellationTokenSource.CreateLinkedTokenSource(cancellationToken.Token));
if (!cancelled)
{
await ExtractFile($@"{assemblyLocation}\Downloads\{fileName}", gameName);
if (File.Exists($@"{assemblyLocation}\refresh.aem"))
{
FileIOWrapper.Delete($@"{assemblyLocation}\refresh.aem");
}
FileIOWrapper.WriteAllText($@"{assemblyLocation}\refresh.aem", gameName);
}
}
}
}
/// <summary>
/// Gets game filter with parameters set according to the
/// set sort order parameter.
/// </summary>
/// <param name="sortOrder">Determines the ordering of the data.</param>
/// <param name="searchString">String used for searching by name.</param>
/// <returns>Filter with appropriate sorting data.</returns>
private GameFilter GetGameFilter(string sortOrder, string searchString)
{
var filter = new GameFilter
{
SearchName = searchString
};
switch (sortOrder)
{
case "name_asc":
filter.Name = OrderByEnum.Ascending;
filter.Code = OrderByEnum.None;
return(filter);
case "name_desc":
filter.Name = OrderByEnum.Descending;
filter.Code = OrderByEnum.None;
return(filter);
case "code_asc":
filter.Name = OrderByEnum.None;
filter.Code = OrderByEnum.Ascending;
return(filter);
case "code_desc":
filter.Name = OrderByEnum.None;
filter.Code = OrderByEnum.Descending;
return(filter);
default:
filter.Name = OrderByEnum.None;
filter.Code = OrderByEnum.None;
return(filter);
}
}
public void Apply_FilterByTime()
{
var filter = new GameFilter(null, Region.ALL, GameMode.ALL, TimeFrame.TODAY, GameFormat.ANY);
var filtered = filter.Apply(games);
Assert.AreEqual(1, filtered.Count);
}
public async Task <PartialViewResult> GetGamesByProducers(string producerName)
{
if (Session["Filters"] != null)
{
GameFilters = Session["Filters"] as List <GameFilter>;
}
else
{
GameFilters = new List <GameFilter>();
}
var filter = new GameFilter
{
Name = producerName,
Expression = x => x.Producer.Name == producerName
};
GameFilters.Add(filter);
Session["Filters"] = GameFilters;
var games = await gameService.GetGames(GameFilters);
return(PartialView("GameView"));
}
private void AddFilter(string type, string name)
{
if (Session["GameFilters"] == null)
{
Session["GameFilters"] = new List <GameFilter>();
}
var filters = Session["GameFilters"] as List <GameFilter>;
var isExist = filters.FirstOrDefault(x => x.Name == name && x.Type == type);
if (isExist != null)
{
filters.Remove(isExist);
Session["GameFilters"] = filters;
return;
}
var filter = new GameFilter
{
Name = name,
Type = type
};
if (type == "Developer")
{
filter.Predicate = (x => x.Developer.Name == name);
}
if (type == "Genre")
{
filter.Predicate = (x => x.Genre.Name == name);
}
filters.Add(filter);
Session["GameFilters"] = filters;
}
public void ConvertTimeFrameToRange_Today()
{
var start = "2015-01-10T00:00:00+00:00";
var range = GameFilter.ConvertTimeFrameToRange(TimeFrame.TODAY, now);
Assert.AreEqual(DateTime.Parse(start), range.Start);
Assert.AreEqual(DateTime.Parse(now), range.End);
}
public void ConvertTimeFrameToRange_ThisYear()
{
var start = "2015-01-01T00:00:00+00:00";
var range = GameFilter.ConvertTimeFrameToRange(TimeFrame.THIS_YEAR, now);
Assert.AreEqual(DateTime.Parse(start), range.Start);
Assert.AreEqual(DateTime.Parse(now), range.End);
}
public void ConvertTimeFrameToRange_Last7Days()
{
var start = "2015-01-03T19:23:44+00:00";
var range = GameFilter.ConvertTimeFrameToRange(TimeFrame.LAST_7_DAYS, now);
Assert.AreEqual(DateTime.Parse(start), range.Start);
Assert.AreEqual(DateTime.Parse(now), range.End);
}
public ActionResult DeleteConfirmed(int id)
{
GameFilter gamefilter = db.GameFilters.Find(id);
db.GameFilters.Remove(gamefilter);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void Apply_FilterByDeck()
{
var filter = new GameFilter(games[0].Deck.Id, Region.ALL, GameMode.ALL, TimeFrame.ALL, GameFormat.ANY);
var filtered = filter.Apply(games);
Assert.AreEqual(1, filtered.Count);
Assert.AreEqual(games[0].Deck.Id, filtered[0].Deck.Id);
}
public FilterItem(string name, string prefix, string kind, GameFilter filter, string seperator)
{
this.name = name;
this.prefix = prefix;
this.filter = filter;
this.kind = kind;
this.seperator = seperator;
}
public void Apply_FilterByPlayerClass()
{
var filter = new GameFilter(null, Region.ALL, GameMode.ALL, TimeFrame.ALL, GameFormat.ANY, PlayerClass.DRUID, PlayerClass.ALL);
var filtered = filter.Apply(games);
Assert.AreEqual(1, filtered.Count);
Assert.AreEqual(PlayerClass.DRUID, filtered[0].PlayerClass);
}
public void Apply_FilterByFormat()
{
var filter = new GameFilter(null, Region.ALL, GameMode.ALL, TimeFrame.ALL, GameFormat.STANDARD);
var filtered = filter.Apply(games);
Assert.AreEqual(1, filtered.Count);
Assert.AreEqual(GameFormat.STANDARD, filtered[0].Format);
}
private async Task UpdateGameCount()
{
var deck = SelectedDeck == ALL_DECK ? null : SelectedDeck;
var filter = new GameFilter(deck?.Id, SelectedRegion, SelectedGameMode, SelectedTimeFrame, SelectedGameFormat);
var games = await Task.Run(() => StatsConverter.Data.GetAllGames());
GameCount = filter.Apply(games).Count;
}
public static async Task GetFeed(int page, GameFilter game, TypeFilter type, FeedFilter filter, GameBananaCategory category, GameBananaCategory subcategory, int perPage)
{
error = false;
if (feed == null)
{
feed = new Dictionary <string, GameBananaModList>();
}
// Remove oldest key if more than 15 pages are cached
if (feed.Count > 15)
{
feed.Remove(feed.Aggregate((l, r) => DateTime.Compare(l.Value.TimeFetched, r.Value.TimeFetched) < 0 ? l : r).Key);
}
using (var httpClient = new HttpClient())
{
var requestUrl = GenerateUrl(page, game, type, filter, category, subcategory, perPage);
if (feed.ContainsKey(requestUrl) && feed[requestUrl].IsValid)
{
CurrentFeed = feed[requestUrl];
return;
}
try
{
var response = await httpClient.GetAsync(requestUrl);
var responseString = await response.Content.ReadAsStringAsync();
responseString = responseString.Replace(@"""_aModManagerIntegrations"": []", @"""_aModManagerIntegrations"": {}");
var records = JsonConvert.DeserializeObject <ObservableCollection <GameBananaRecord> >(responseString);
CurrentFeed = new GameBananaModList();
CurrentFeed.Records = records;
// Get record count from header
var numRecords = response.GetHeader("X-GbApi-Metadata_nRecordCount");
if (numRecords != -1)
{
var totalPages = Convert.ToInt32(Math.Ceiling(numRecords / Convert.ToDouble(perPage)));
if (totalPages == 0)
{
totalPages = 1;
}
CurrentFeed.TotalPages = totalPages;
}
}
catch (Exception e)
{
error = true;
exception = e;
return;
}
if (!feed.ContainsKey(requestUrl))
{
feed.Add(requestUrl, CurrentFeed);
}
else
{
feed[requestUrl] = CurrentFeed;
}
}
}
public void DefaultFilter_ShouldHavePropsSetToAll()
{
var filter = new GameFilter();
Assert.IsNull(filter.DeckId);
Assert.AreEqual(Region.ALL, filter.Region);
Assert.AreEqual(GameMode.ALL, filter.Mode);
Assert.AreEqual(TimeFrame.ALL, filter.TimeFrame);
}
public void ConvertTimeFrameToRange_Yesterday()
{
var start = "2015-01-09T00:00:00+00:00";
var end = "2015-01-09T23:59:59+00:00";
var range = GameFilter.ConvertTimeFrameToRange(TimeFrame.YESTERDAY, now);
Assert.AreEqual(DateTime.Parse(start), range.Start);
Assert.AreEqual(DateTime.Parse(end), range.End);
}
public void Apply_FilterByOpponentClass()
{
var filter = new GameFilter(null, Region.ALL, GameMode.ALL, TimeFrame.ALL, GameFormat.ANY, PlayerClass.ALL, PlayerClass.MAGE);
var filtered = filter.Apply(games);
Assert.AreEqual(2, filtered.Count);
Assert.AreEqual(PlayerClass.MAGE, filtered[0].OpponentClass);
Assert.AreEqual(PlayerClass.MAGE, filtered[1].OpponentClass);
}
public void ConvertTimeFrameToRange_PreviousWeek()
{
var start = "2014-12-29T00:00:00+00:00";
var end = "2015-01-04T23:59:59+00:00";
var range = GameFilter.ConvertTimeFrameToRange(TimeFrame.PREVIOUS_WEEK, now);
Assert.AreEqual(DateTime.Parse(start), range.Start);
Assert.AreEqual(DateTime.Parse(end), range.End);
}
public void ConvertTimeFrameToRange_PreviousYear()
{
var start = "2014-01-01T00:00:00+00:00";
var end = "2014-12-31T23:59:59+00:00";
var range = GameFilter.ConvertTimeFrameToRange(TimeFrame.PREVIOUS_YEAR, now);
Assert.AreEqual(DateTime.Parse(start), range.Start);
Assert.AreEqual(DateTime.Parse(end), range.End);
}
//
// GET: /GameFilter/Delete/5
public ActionResult Delete(int id = 0)
{
GameFilter gamefilter = db.GameFilters.Find(id);
if (gamefilter == null)
{
return(HttpNotFound());
}
return(View(gamefilter));
}
public ActionResult Edit(GameFilter gamefilter)
{
if (ModelState.IsValid)
{
db.Entry(gamefilter).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(gamefilter));
}
public void ConvertTimeFrameToRange_ShouldUseNowIfParamIsAbsent()
{
var dt = DateTime.Now;
var range = GameFilter.ConvertTimeFrameToRange(TimeFrame.TODAY);
Assert.AreEqual(dt.Day, range.End.Day);
Assert.AreEqual(dt.Month, range.End.Month);
Assert.AreEqual(dt.Year, range.End.Year);
Assert.AreEqual(dt.Hour, range.End.Hour);
Assert.AreEqual(dt.Minute, range.End.Minute);
}
public ActionResult Create(GameFilter gamefilter)
{
if (ModelState.IsValid)
{
db.GameFilters.Add(gamefilter);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(gamefilter));
}
public FilteredGameSource(GameFilter filter, string filterName)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
if (filterName == null)
{
throw new ArgumentNullException(nameof(filterName));
}
this.filter = filter;
this.Prefix = filterName;
}
