private async Task LoginAsync()
{
using (Busy.GetTicket())
{
FailureMessage = "";
var credential = new LoginCredential(Username, Password, null);
// Clear username and password fields
Username = null;
Password = null;
try
{
await _authenticationService.LoginAsync(credential);
if (_globalCache != null)
{
try
{
await _globalCache.LoadAsync();
}
catch (Exception e)
{
throw new Exception("Failed to load global entity cache. Try again!", e);
}
}
}
catch (Exception e)
{
FailureMessage = e.Message;
}
}
}
public async void Search(Guid selection)
{
using (Busy.GetTicket())
{
var items = await UnitOfWork.Search.Simple(SearchText);
Items = new BindableCollection <StaffingResourceListItem>(items);
CurrentStaffingResource = Items.FirstOrDefault(r => r.Id == selection) ?? Items.FirstOrDefault();
}
}
private void LoadMore(bool clearValues = false)
{
EnsureInitialized();
Application.Current.Dispatcher.BeginInvoke((Action)(() =>
{
if (needRefresh)
{
needRefresh = false;
if (loadMoreTicket != null)
{
return;
}
this.loadMoreTicket = Busy.GetTicket();
Task.Run(
async() =>
{
var oldSelected = SelectedGame;
if (clearValues)
{
this.gameResults.Clear();
}
var newgames = new List <GameResultModel>();
var latest = (await gameRepository.ToListAsync(
query =>
{
query = query.Where(this.GetFilterExpression());
query = AddOrderByExpression(query);
return(query.Skip(clearValues ? 0 : this.gameResults.Count)
.Take(50));
})).ToModel();
totalCount = gameRepository.Query(x => x.Where(GetFilterExpression()).Count());
newgames.AddRange(latest);
this.gameResults.AddRange(newgames);
if (oldSelected != null)
{
var foundold = gameResults.FirstOrDefault(x => x.Id == oldSelected.Id);
if (foundold != null)
{
SelectedGame = foundold;
}
else
{
SelectedGame = null;
}
}
loadMoreTicket.Dispose();
loadMoreTicket = null;
});
}
}), DispatcherPriority.ContextIdle);
}
private async void LoadDataAsync(string firstName, string middleName, string lastName)
{
using (Busy.GetTicket())
{
_unitOfWork = _unitOfWorkManager.Create();
var staffingResource = await _unitOfWork.StaffingResourceFactory.CreateAsync();
_unitOfWorkManager.Add(staffingResource.Id, _unitOfWork);
staffingResource.FirstName = firstName;
staffingResource.MiddleName = middleName;
staffingResource.LastName = lastName;
Start(staffingResource.Id, EditMode.Edit);
}
}
public void Install()
{
using (Busy.GetTicket())
{
DownloadReady = false;
var start = Path.Combine(tempPath, "HearthCap.Updater.exe");
var path = this.basePath.EndsWith("\"") ? this.basePath.Substring(0, this.basePath.Length - 1) : this.basePath;
var pi = new ProcessStartInfo(start, String.Format("{0} \"{1}\"", this.filename, path))
{
UseShellExecute = true,
Verb = "runas",
WorkingDirectory = this.basePath,
};
Process.Start(pi);
Application.Current.Shutdown();
}
}
protected async Task Initialize()
{
if (cache != null)
{
return;
}
using (var bsy = Busy.GetTicket())
{
using (var context = dbContext())
{
var heroes = context.Heroes.Select(hero => hero);
var heroesresult = await heroes.ToListAsync();
cache = new Items(heroesresult);
}
}
}
private void RefreshDataCore()
{
Application.Current.Dispatcher.BeginInvoke((Action)(() =>
{
if (needRefresh)
{
needRefresh = false;
var ticket = Busy.GetTicket();
var expr = GetGamesFilterExpression();
var expr2 = GetArenasFilterExpression();
Task.Run(
() =>
{
ActiveItem.RefreshData(expr, expr2);
ticket.Dispose();
});
}
}), DispatcherPriority.ContextIdle);
}
public async Task Download()
{
using (Busy.GetTicket())
{
try
{
UpdateAvailable = false;
Downloading = true;
var updaterexe_filename = "HearthCap.Updater.exe";
var updaterexe_fileurl = updateBaseUrl + (!updateBaseUrl.EndsWith("/") ? "/" : "") + updaterexe_filename;
var file = Path.Combine(tempPath, filename);
var updaterFile = Path.Combine(tempPath, updaterexe_filename);
using (var webclient = new WebClient {
CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore)
})
{
await webclient.DownloadFileTaskAsync(updaterexe_fileurl, updaterFile);
await webclient.DownloadFileTaskAsync(updatefileurl, file);
}
if (!File.Exists(file) || !File.Exists(updaterFile))
{
Error = "Error downloading update. Please try again.";
Log.Error("Error downloading update. Please try again (file does not exist).");
}
else
{
DownloadReady = true;
}
}
catch (Exception ex)
{
Log.Error("Error downloading update: " + ex);
Error = ex.Message;
}
finally
{
Downloading = false;
}
}
}
private async void LoadDataAsync(Guid staffingResourceId, EditMode editMode)
{
using (Busy.GetTicket())
{
_unitOfWork = null;
_staffingResourceId = staffingResourceId;
EditMode = editMode;
StaffingResource = await UnitOfWork.StaffingResources.WithIdAsync(staffingResourceId);
StaffingResourceSummary.Start(StaffingResource.Id, EditMode);
_sections.ForEach(s => s.Start(StaffingResource.Id, EditMode));
if (Items.Count == 0)
{
Items.AddRange(_sections.OrderBy(s => s.Index));
NotifyOfPropertyChange(() => Items);
ActivateItem(Items.First());
}
}
}
public override async void CanClose(Action <bool> callback)
{
try
{
if (UnitOfWork.HasChanges())
{
var dialogResult = await _dialogManager.ShowMessageAsync(
"There are unsaved changes. Would you like to save your changes?",
DialogResult.Yes, DialogResult.Cancel, DialogButtons.YesNoCancel);
using (Busy.GetTicket())
{
if (dialogResult == DialogResult.Yes)
{
await UnitOfWork.CommitAsync();
}
if (dialogResult == DialogResult.No)
{
UnitOfWork.Rollback();
}
callback(true);
}
}
else
{
base.CanClose(callback);
}
}
catch (TaskCanceledException)
{
callback(false);
}
catch (Exception)
{
callback(false);
throw;
}
}
public void Install()
{
using (Busy.GetTicket())
{
DownloadReady = false;
string filename = UpdateInfo.File;
filename = filename.Substring(filename.LastIndexOf("/", StringComparison.Ordinal) + 1);
var file = Path.Combine(_tempPath, filename);
var updaterFile = Path.Combine(_tempPath, HearthcapUpdaterExe);
var path = _basePath.EndsWith("\"", StringComparison.Ordinal) ? _basePath.Substring(0, _basePath.Length - 1) : _basePath;
var pi = new ProcessStartInfo(updaterFile, String.Format("{0} \"{1}\"", file, path))
{
UseShellExecute = true,
Verb = "runas",
WorkingDirectory = _basePath
};
Process.Start(pi);
Application.Current.Shutdown();
}
}
public async Task CheckForUpdates()
{
UpdateAvailable = false;
DownloadReady = false;
Downloading = false;
CheckingForUpdates = false;
UpdateCheckDone = false;
HasLatestVersion = false;
Error = null;
using (Busy.GetTicket())
{
CheckingForUpdates = true;
// TODO: remove
// await Task.Delay(1000);
await DoCheckForUpdates();
CheckingForUpdates = false;
UpdateCheckDone = true;
}
}
public async Task Save()
{
using (var busy = Busy.GetTicket())
{
GameResultModel gameResult = null;
var added = false;
if (LastGameId == null)
{
gameResult = new GameResultModel();
added = true;
}
else
{
// gameResult = (await gameRepository.FirstOrDefaultAsync(x => x.Id == this.LastGameId)).ToModel();
gameResult = SelectedGame;
}
SetGameResult(gameResult);
if (ArenaSession != null)
{
gameResult.ArenaSession = ArenaSession;
}
if (added)
{
await gameManager.AddGame(gameResult);
}
else
{
await gameManager.UpdateGame(gameResult);
}
events.PublishOnBackgroundThread(new SendNotification("Game successfully saved."));
LastGameId = gameResult.Id;
LoadGameResult(gameResult);
}
}
public async void Search(bool cache)
{
try
{
using (Busy.GetTicket())
{
if (string.IsNullOrEmpty(SearchText))
{
Start();
return;
}
Expression <Func <Customer, bool> > predicate = x => x.CompanyName.Contains(SearchText);
Func <IQueryable <Customer>, IOrderedQueryable <Customer> > orderBy = q => q.OrderBy(x => x.CompanyName);
Customers = new BindableCollection <Customer>(
cache ? UnitOfWork.Entities.FindInCache(predicate, orderBy) : await UnitOfWork.Entities.FindAsync(predicate, orderBy));
}
}
catch (Exception e)
{
ErrorHandler.Handle(e);
}
}
public async void Start()
{
try
{
using (Busy.GetTicket())
{
Func <IQueryable <Customer>, IOrderedQueryable <Customer> > orderBy = q => q.OrderBy(x => x.CompanyName);
if (!string.IsNullOrEmpty(SearchText))
{
Search(IsRestored);
}
else
{
Customers = new BindableCollection <Customer>(
IsRestored ? UnitOfWork.Entities.AllInCache(orderBy) : await UnitOfWork.Entities.AllAsync(orderBy));
}
}
}
catch (Exception e)
{
ErrorHandler.Handle(e);
}
}
private void LoadMore(bool clearValues = false)
{
Application.Current.Dispatcher.BeginInvoke(
(Action)(async() =>
{
if (needRefresh)
{
needRefresh = false;
if (loadMoreTicket != null)
{
return;
}
loadMoreTicket = Busy.GetTicket();
await Task.Run(
async() =>
{
if (clearValues)
{
arenaSessions.Clear();
}
var newarenas = new List <ArenaSessionModel>();
var result = await arenaRepository.ToListAsync(
query =>
{
query = query.Where(GetFilterExpression());
query = AddOrderByExpression(query);
return(query.Skip(clearValues ? 0 : arenaSessions.Count)
.Take(50));
});
totalCount = arenaRepository.Query(x => x.Where(GetFilterExpression()).Count());
foreach (var arena in result.ToModel())
{
newarenas.Add(arena);
if (ArenaViewModel.IsOpen
&&
ArenaViewModel.SelectedArenaSession != null
&&
SelectedArenaSession != null
&&
SelectedArenaSession.Id == arena.Id)
{
SelectedArenaSession = arena;
}
if (SelectedGame != null
&&
EditGameViewModel.IsOpen
&&
EditGameViewModel.SelectedGame != null
&&
SelectedGame != null)
{
var hasgame = arena.Games.FirstOrDefault(x => x.Id == SelectedGame.Id);
if (hasgame != null)
{
SelectedGame = hasgame;
}
}
}
arenaSessions.AddRange(newarenas);
loadMoreTicket.Dispose();
loadMoreTicket = null;
// does not work nicely
//if (EditGameFlyout.IsOpen && EditGameFlyout.SelectedGame != null)
//{
// Handle(new SelectedGameChanged(EditGameFlyout, EditGameFlyout.SelectedGame.Id));
//}
//else
//{
// if (ArenaViewModel.IsOpen && ArenaViewModel.SelectedArenaSession != null)
// {
// var selected = this.arenaSessions.FirstOrDefault(x => x.Id == ArenaViewModel.SelectedArenaSession.Id);
// this.SelectedArenaSession = selected;
// }
//}
});
}
}),
DispatcherPriority.ContextIdle);
}
public override void RefreshData()
{
if (refreshing)
{
return;
}
refreshing = true;
LoadData();
DeckStats.Clear();
var newstats = new BindableCollection <IDictionary <Deck, IList <StatModel> > >();
Task.Run(
() =>
{
using (Busy.GetTicket())
{
foreach (Deck deck in Decks)
{
if (!String.IsNullOrEmpty(GameMode))
{
var gameMode = (GameMode)Enum.Parse(typeof(GameMode), GameMode);
if (gameMode == Data.GameMode.Arena)
{
var emptystats = new Dictionary <Deck, IList <StatModel> >();
newstats.Add(emptystats);
var emptylst = new List <StatModel>();
emptystats.Add(deck, emptylst);
emptylst.AddRange(Heroes.Select(h => new StatModel()
{
Hero = h
}));
continue;
}
}
var r =
gameRepository.Query(
x =>
{
var q = x.Where(g => g.Deck.Id == deck.Id);
q = q.Where(GetFilterExpression());
var group = q
.Where(g => q.Any())
.GroupBy(g => g.OpponentHero.Key)
.Select(
g =>
new
{
HeroKey = g.Key,
GlobalTotal = q.Count(),
Total = g.Count(),
TotalCoin = g.Count(c => !c.GoFirst),
TotalNoCoin = g.Count(c => c.GoFirst),
Wins = g.Count(c => c.Victory),
Losses = g.Count(c => !c.Victory),
WinsCoin = g.Count(c => c.Victory && !c.GoFirst),
WinsNoCoin = g.Count(c => c.Victory && c.GoFirst),
LossesCoin = g.Count(c => !c.Victory && !c.GoFirst),
LossesNoCoin = g.Count(c => !c.Victory && c.GoFirst)
});
return(group.ToList());
});
if (r.Sum(x => x.GlobalTotal) == 0)
{
continue;
}
var stats = new Dictionary <Deck, IList <StatModel> >();
newstats.Add(stats);
var lst = new List <StatModel>();
stats.Add(deck, lst);
for (int i = 0; i < Heroes.Count; i++)
{
var oppHero = Heroes[i];
dynamic result = null;
if (oppHero.Key != null)
{
result = r.FirstOrDefault(x => x.HeroKey == oppHero.Key);
}
else
{
result = new
{
HeroKey = String.Empty,
GlobalTotal = r.Sum(x => x.Total),
Total = r.Sum(x => x.Total),
TotalCoin = r.Sum(x => x.TotalCoin),
TotalNoCoin = r.Sum(x => x.TotalNoCoin),
Wins = r.Sum(x => x.Wins),
Losses = r.Sum(x => x.Losses),
WinsCoin = r.Sum(x => x.WinsCoin),
WinsNoCoin = r.Sum(x => x.WinsNoCoin),
LossesCoin = r.Sum(x => x.LossesCoin),
LossesNoCoin = r.Sum(x => x.LossesNoCoin)
};
}
if (result == null)
{
lst.Add(new StatModel()
{
Hero = oppHero
});
}
else
{
lst.Add(
new StatModel()
{
Hero = oppHero,
TotalGames = result.Total,
GlobalTotal = result.GlobalTotal,
Wins = result.Wins,
Losses = result.Losses,
WinsCoin = result.WinsCoin,
WinsNoCoin = result.WinsNoCoin,
LossesCoin = result.LossesCoin,
LossesNoCoin = result.LossesNoCoin,
WinRate = result.Total > 0 ? Math.Round((decimal)result.Wins / result.Total * 100, 0) : 0,
LossRate = result.Total > 0 ? Math.Round((decimal)result.Losses / result.Total * 100, 0) : 0,
WinRateCoin =
result.TotalCoin > 0 ? Math.Round((decimal)result.WinsCoin / result.TotalCoin * 100, 0) : 0,
WinRateNoCoin =
result.TotalNoCoin > 0 ? Math.Round((decimal)result.WinsNoCoin / result.TotalNoCoin * 100, 0) : 0,
LossRateCoin =
result.TotalCoin > 0 ? Math.Round((decimal)result.LossesCoin / result.TotalCoin * 100, 0) : 0,
LossRateNoCoin =
result.TotalNoCoin > 0 ? Math.Round((decimal)result.LossesNoCoin / result.TotalNoCoin * 100, 0) : 0
});
}
}
}
refreshing = false;
}
}).ContinueWith(
t =>
{
using (Busy.GetTicket())
{
DeckStats.IsNotifying = false;
DeckStats.Clear();
DeckStats.AddRange(newstats);
DeckStats.IsNotifying = true;
DeckStats.Refresh();
}
});;
}
public async Task Download()
{
using (Busy.GetTicket())
{
try
{
UpdateAvailable = false;
Downloading = true;
// Updater
string updaterFileUrl = UpdateInfo.Updater;
if (String.IsNullOrEmpty(UpdateInfo.Updater))
{
updaterFileUrl = HearthcapUpdaterExe;
}
if (!updaterFileUrl.StartsWith("http://", StringComparison.Ordinal) &&
!updaterFileUrl.StartsWith("https://", StringComparison.Ordinal))
{
updaterFileUrl = _updateBaseUrl + (!_updateBaseUrl.EndsWith("/", StringComparison.Ordinal) ? "/" : "") + updaterFileUrl;
}
// File package
string filePackageUrl = UpdateInfo.File;
if (!filePackageUrl.StartsWith("http://", StringComparison.Ordinal) &&
!filePackageUrl.StartsWith("https://", StringComparison.Ordinal))
{
filePackageUrl = _updateBaseUrl + (!_updateBaseUrl.EndsWith("/", StringComparison.Ordinal) ? "/" : "") + filePackageUrl;
}
string filename = UpdateInfo.File;
filename = filename.Substring(filename.LastIndexOf("/", StringComparison.Ordinal) + 1);
var file = Path.Combine(_tempPath, filename);
var updaterFile = Path.Combine(_tempPath, HearthcapUpdaterExe);
// Download
using (var wcFilePackage = new WebClient {
CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore)
})
using (var wcUpdater = new WebClient {
CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore)
})
{
await Task.WhenAll(
wcUpdater.DownloadFileTaskAsync(updaterFileUrl, updaterFile),
wcFilePackage.DownloadFileTaskAsync(filePackageUrl, file)
);
}
if (!File.Exists(file) ||
!File.Exists(updaterFile))
{
Error = "Error downloading update. Please try again.";
_log.Error("Error downloading update. Please try again (file does not exist).");
}
else
{
DownloadReady = true;
}
}
catch (Exception ex)
{
_log.Error("Error downloading update: " + ex);
Error = ex.Message;
}
finally
{
Downloading = false;
}
}
}
private async Task Save()
{
using (var bsy = Busy.GetTicket())
{
var gameResult = new GameResultModel();
ArenaSessionModel arenasession = null;
var newArena = false;
gameResult.GameMode = GameMode;
gameResult.Conceded = Conceded;
if (Deck != null)
{
gameResult.Deck = Deck;
}
gameResult.GoFirst = GoFirst;
gameResult.Hero = Hero;
gameResult.OpponentHero = OpponentHero;
gameResult.Started = StartTime;
gameResult.Stopped = Stopped;
gameResult.Turns = Turns;
gameResult.Victory = Victory;
gameResult.Notes = Notes;
gameResult.Server = BindableServerCollection.Instance.DefaultName;
if (gameResult.GameMode == GameMode.Arena)
{
var serverName = gameResult.Server;
var latestArena = arenaRepository.Query(a => a.Where(x => x.Server == serverName).OrderByDescending(x => x.StartDate).FirstOrDefault());
if (latestArena == null
||
latestArena.IsEnded
||
(gameResult.Hero != null && latestArena.Hero.Key != gameResult.Hero.Key))
{
Log.Debug("Creating new arena.");
newArena = true;
arenasession = new ArenaSessionModel
{
Hero = gameResult.Hero,
StartDate = gameResult.Started
};
try
{
GlobalLocks.NewArenaLock.Reset();
await gameManager.AddArenaSession(arenasession);
}
finally
{
GlobalLocks.NewArenaLock.Set();
}
}
else
{
arenasession = latestArena.ToModel();
}
gameResult.ArenaSession = arenasession;
}
await gameManager.AddGame(gameResult);
// for webapi
if (arenasession != null)
{
if (newArena)
{
events.PublishOnBackgroundThread(new ArenaSessionStarted(arenasession.StartDate, arenasession.Hero.Key, arenasession.Wins, arenasession.Losses));
}
else
{
if (arenasession.IsEnded &&
arenasession.EndDate.HasValue)
{
events.PublishOnBackgroundThread(new ArenaSessionEnded(arenasession.StartDate, arenasession.EndDate.Value, arenasession.Hero.Key, arenasession.Wins, arenasession.Losses));
}
}
}
// notifications
//var wonString = gameResult.Victory ? "You won!" : "You lost!";
var title = "New game tracked.";
//var hero = gameResult.Hero != null ? gameResult.Hero.ClassName : String.Empty;
//var oppHero = gameResult.OpponentHero != null ? gameResult.OpponentHero.ClassName : String.Empty;
//var msg = string.Format("Hero: {0}, Opponent: {1}, {2}", hero, oppHero, wonString);
//events.PublishOnBackgroundThread(new SendNotification(String.Format("{0} {1}", title, msg)));
var vm = IoC.Get <GameResultBalloonViewModel>();
vm.SetGameResult(gameResult);
events.PublishOnBackgroundThread(new TrayNotification(title, vm, 10000)
{
BalloonType = BalloonTypes.GameStartEnd
});
// reset
Clear();
IsOpen = false;
}
}
public override void RefreshData()
{
if (refreshing)
{
return;
}
refreshing = true;
var newstats = new BindableCollection <IDictionary <Hero, IList <StatModel> > >();
Task.Run(
() =>
{
using (Busy.GetTicket())
{
foreach (var hero in Heroes)
{
if (hero.Key == null)
{
continue;
}
var r =
gameRepository.Query(
x =>
{
var q = x.Where(g => g.Hero.Id == hero.Id);
q = q.Where(GetFilterExpression());
var group = q
.GroupBy(g => g.OpponentHero.Key)
.Select(
g =>
new
{
HeroKey = g.Key,
GlobalTotal = q.Count(),
Total = g.Count(),
TotalCoin = g.Count(c => !c.GoFirst),
TotalNoCoin = g.Count(c => c.GoFirst),
Wins = g.Count(c => c.Victory),
Losses = g.Count(c => !c.Victory),
WinsCoin = g.Count(c => c.Victory && !c.GoFirst),
WinsNoCoin = g.Count(c => c.Victory && c.GoFirst),
LossesCoin = g.Count(c => !c.Victory && !c.GoFirst),
LossesNoCoin = g.Count(c => !c.Victory && c.GoFirst)
});
return(group.ToList());
});
var stats = new Dictionary <Hero, IList <StatModel> >();
newstats.Add(stats);
var lst = new List <StatModel>();
stats.Add(hero, lst);
for (var i = 0; i < Heroes.Count; i++)
{
var oppHero = Heroes[i];
dynamic result = null;
if (oppHero.Key != null)
{
result = r.FirstOrDefault(x => x.HeroKey == oppHero.Key);
}
else
{
result = new
{
HeroKey = String.Empty,
GlobalTotal = r.Sum(x => x.Total),
Total = r.Sum(x => x.Total),
TotalCoin = r.Sum(x => x.TotalCoin),
TotalNoCoin = r.Sum(x => x.TotalNoCoin),
Wins = r.Sum(x => x.Wins),
Losses = r.Sum(x => x.Losses),
WinsCoin = r.Sum(x => x.WinsCoin),
WinsNoCoin = r.Sum(x => x.WinsNoCoin),
LossesCoin = r.Sum(x => x.LossesCoin),
LossesNoCoin = r.Sum(x => x.LossesNoCoin)
};
}
if (result == null)
{
lst.Add(new StatModel {
Hero = oppHero
});
}
else
{
lst.Add(
new StatModel
{
Hero = oppHero,
TotalGames = result.Total,
GlobalTotal = result.GlobalTotal,
Wins = result.Wins,
Losses = result.Losses,
WinsCoin = result.WinsCoin,
WinsNoCoin = result.WinsNoCoin,
LossesCoin = result.LossesCoin,
LossesNoCoin = result.LossesNoCoin,
WinRate = result.Total > 0 ? Math.Round((decimal)result.Wins / result.Total * 100, 0) : 0,
LossRate = result.Total > 0 ? Math.Round((decimal)result.Losses / result.Total * 100, 0) : 0,
WinRateCoin =
result.TotalCoin > 0 ? Math.Round((decimal)result.WinsCoin / result.TotalCoin * 100, 0) : 0,
WinRateNoCoin =
result.TotalNoCoin > 0 ? Math.Round((decimal)result.WinsNoCoin / result.TotalNoCoin * 100, 0) : 0,
LossRateCoin =
result.TotalCoin > 0 ? Math.Round((decimal)result.LossesCoin / result.TotalCoin * 100, 0) : 0,
LossRateNoCoin =
result.TotalNoCoin > 0 ? Math.Round((decimal)result.LossesNoCoin / result.TotalNoCoin * 100, 0) : 0
});
}
}
}
refreshing = false;
}
}).ContinueWith(
t =>
{
using (Busy.GetTicket())
{
HeroStats.IsNotifying = false;
HeroStats.Clear();
HeroStats.AddRange(newstats);
HeroStats.IsNotifying = true;
HeroStats.Refresh();
}
});
}
