public async Task MoveGameToArena(GameResultModel gameModel, ArenaSessionModel arenaModel)
{
using (var context = dbContext())
{
var sourceArena = context.ArenaSessions.Query().First(x => x.Id == gameModel.ArenaSessionId);
var targetarena = context.ArenaSessions.Query().First(x => x.Id == arenaModel.Id);
var game = context.Games.Query().First(x => x.Id == gameModel.Id);
if (sourceArena.Games.Contains(game))
{
sourceArena.Games.Remove(game);
if (game.Victory)
{
sourceArena.Wins--;
}
else
{
sourceArena.Losses--;
}
}
if (!(Equals(targetarena.Hero, game.Hero)))
{
game.Hero = targetarena.Hero;
}
AddGameToArena(game, targetarena);
SetEndDateIfNeeded(targetarena);
await context.SaveChangesAsync();
var latestId = context.ArenaSessions.OrderByDescending(x => x.StartDate).Select(x => x.Id).FirstOrDefault();
events.PublishOnBackgroundThread(new ArenaSessionUpdated(sourceArena.Id, latestId == sourceArena.Id));
events.PublishOnBackgroundThread(new ArenaSessionUpdated(targetarena.Id, latestId == targetarena.Id));
events.PublishOnBackgroundThread(new GameResultUpdated(gameModel.Id, game.ArenaSessionId));
}
}
public async Task AddGame(GameResultModel gameModel)
{
using (var context = dbContext())
{
var game = new GameResult();
game.InjectFrom(gameModel);
if (gameModel.Hero != null)
{
game.Hero = context.Heroes.Find(gameModel.Hero.Id);
}
if (gameModel.OpponentHero != null)
{
game.OpponentHero = context.Heroes.Find(gameModel.OpponentHero.Id);
}
ArenaSessionModel arenaModel = null;
ArenaSession arena = null;
if (gameModel.ArenaSession != null)
{
gameModel.Deck = null;
game.DeckKey = null;
game.Deck = null;
arenaModel = gameModel.ArenaSession;
arena = context.ArenaSessions.Query().FirstOrDefault(x => x.Id == arenaModel.Id);
if (arena == null)
{
throw new InvalidOperationException("Add arena using gameManager first!");
}
// context.Entry(arena).CurrentValues.SetValues(arenaModel);
AddGameToArena(game, arena);
SetEndDateIfNeeded(arena);
arena.Modified = DateTime.Now;
}
if (gameModel.Deck != null)
{
game.Deck = context.Decks.Find(gameModel.Deck.Id);
}
context.Games.Add(game);
await context.SaveChangesAsync();
gameModel.InjectFrom(game);
events.PublishOnBackgroundThread(new GameResultAdded(this, gameModel));
if (arenaModel != null)
{
arenaModel.InjectFrom(arena);
gameModel.ArenaSession = arenaModel;
arenaModel.Games.Add(gameModel);
var latestId = context.ArenaSessions.OrderByDescending(x => x.StartDate).Select(x => x.Id).FirstOrDefault();
events.PublishOnBackgroundThread(new ArenaSessionUpdated(arenaModel.Id, latestId == arenaModel.Id));
}
}
}
private string Handle(string content, ArenaSessionModel arena)
{
if (content.Contains(carenaWins))
{
content = content.Replace(carenaWins, arena.Wins.ToString(CultureInfo.InvariantCulture));
}
if (content.Contains(carenaLosses))
{
content = content.Replace(carenaLosses, arena.Losses.ToString(CultureInfo.InvariantCulture));
}
return(content);
}
public async Task MergeArenas(ArenaSessionModel source, ArenaSessionModel target)
{
if (source == null ||
target == null ||
source.Hero == null ||
target.Hero == null ||
source.Hero.Id != target.Hero.Id)
{
Log.Error("Error merging arenas, null parameters or heroes are not the same.");
return;
}
using (var context = dbContext())
{
var sourceArena = context.ArenaSessions.Query().FirstOrDefault(x => x.Id == source.Id);
var targetArena = context.ArenaSessions.Query().FirstOrDefault(x => x.Id == target.Id);
if (sourceArena == null ||
targetArena == null)
{
Log.Error("Error merging arenas, source or target does not exist");
return;
}
var updatedGames = new List <GameResult>();
foreach (var sourceGame in sourceArena.Games)
{
AddGameToArena(sourceGame, targetArena);
updatedGames.Add(sourceGame);
}
for (var i = sourceArena.Games.Count - 1; i >= 0; i--)
{
sourceArena.Games.Remove(sourceArena.Games[i]);
}
context.ArenaSessions.Remove(sourceArena);
SetEndDateIfNeeded(targetArena);
await context.SaveChangesAsync();
target.MapFrom(targetArena);
events.PublishOnBackgroundThread(new ArenaSessionDeleted(source));
events.PublishOnBackgroundThread(new ArenaSessionUpdated(targetArena.Id));
foreach (var game in updatedGames)
{
events.PublishOnBackgroundThread(new GameResultUpdated(game.Id, game.ArenaSessionId));
}
}
}
public void Load(ArenaSessionModel arenaSessionModel)
{
if (arenaSessionModel == null)
{
return;
}
SelectedArenaSession = arenaSessionModel;
InitLatest();
InitViewModel(SelectedArenaSession);
IsOpen = true;
events.PublishOnBackgroundThread(new SelectedArenaSessionChanged(this, arenaSessionModel.Id));
}
public async Task Retire(ArenaSessionModel arenaModel)
{
using (var context = dbContext())
{
var arena = context.ArenaSessions.Query().First(x => x.Id == arenaModel.Id);
arena.Retired = true;
if (arena.EndDate == null)
{
arena.EndDate = DateTime.Now;
}
arena.Modified = DateTime.Now;
await context.SaveChangesAsync();
arenaModel.InjectFrom(arena);
}
}
public async Task UpdateArenaSession(ArenaSessionModel arenaModel)
{
using (var context = dbContext())
{
var arena = context.ArenaSessions.Query().FirstOrDefault(x => x.Id == arenaModel.Id);
if (arena == null)
{
throw new ArgumentException("arena does not exist", "arenaModel");
}
if (!Equals(arenaModel.Hero, arena.Hero))
{
arena.Hero = context.Heroes.Find(arenaModel.Hero.Id);
}
if (arenaModel.Image1 != null)
{
var img = context.ArenaDeckImages.Find(arenaModel.Image1.Id);
if (img == null)
{
img = arenaModel.Image1;
context.ArenaDeckImages.Add(img);
}
context.Entry(img).CurrentValues.SetValues(arenaModel.Image1);
arena.Image1 = img;
}
if (arenaModel.Image2 != null)
{
var img = context.ArenaDeckImages.Find(arenaModel.Image2.Id);
if (img == null)
{
img = arenaModel.Image2;
context.ArenaDeckImages.Add(img);
}
context.Entry(img).CurrentValues.SetValues(arenaModel.Image2);
arena.Image2 = img;
}
context.Entry(arena).CurrentValues.SetValues(arenaModel);
SetEndDateIfNeeded(arena);
arena.Modified = DateTime.Now;
await context.SaveChangesAsync();
arena = context.ArenaSessions.Query().First(x => x.Id == arena.Id);
var latestId = context.ArenaSessions.OrderByDescending(x => x.StartDate).Select(x => x.Id).FirstOrDefault();
arenaModel.InjectFrom(arena);
events.PublishOnBackgroundThread(new ArenaSessionUpdated(arenaModel.Id, latestId == arena.Id));
}
}
public async Task Save()
{
var arena = new ArenaSessionModel();
arena.Hero = this.Hero;
arena.StartDate = this.Started;
arena.Losses = this.Losses;
arena.Wins = this.Wins;
arena.Server = SelectedServer.Name;
await gameManager.AddArenaSession(arena);
events.PublishOnBackgroundThread(new SendNotification("Arena successfully saved."));
Reset();
IsOpen = false;
ArenaFlyout.Load(arena);
}
private void InitViewModel(ArenaSessionModel arenaSession)
{
this.Started = arenaSession.StartDate;
this.Ended = arenaSession.EndDate;
this.Wins = arenaSession.Wins;
this.Losses = arenaSession.Losses;
this.Hero = arenaSession.Hero;
this.IsEnded = arenaSession.IsEnded;
this.Retired = arenaSession.Retired;
this.RewardDust = arenaSession.RewardDust;
this.RewardGold = arenaSession.RewardGold;
this.RewardPacks = arenaSession.RewardPacks;
this.Notes = arenaSession.Notes;
this.SelectedServer = servers.FirstOrDefault(x => x.Name == arenaSession.Server);
this.DeckScreenshot1 = null;
this.DeckScreenshot2 = null;
if (arenaSession.Image1 != null)
{
this.DeckScreenshot1 = CreateBitmapImage(arenaSession.Image1.Image);
}
if (arenaSession.Image2 != null)
{
this.DeckScreenshot2 = CreateBitmapImage(arenaSession.Image2.Image);
}
NotifyOfPropertyChange(() => IsLatest);
if (IsLatest && !IsEnded)
{
this.Header = this.DisplayName = "Running Arena:";
}
else if (IsLatest)
{
this.Header = this.DisplayName = "Last Arena:";
}
else
{
this.Header = this.DisplayName = "Finished Arena:";
}
}
private async Task <ArenaSessionModel> TryCreateArenaSession(string detectedHero)
{
if (detectedHero == null)
{
Log.Warn("TryCreateArenaSession called without hero");
return(null);
}
using (await newArenaLock.LockAsync())
{
var arena = new ArenaSessionModel
{
Hero = await heroRepository.FirstOrDefaultAsync(x => x.Key == detectedHero),
};
arena = await gameManager.AddArenaSession(arena);
// for web api
events.PublishOnBackgroundThread(new ArenaSessionStarted(arena.StartDate, arena.Hero.Key, arena.Wins, arena.Losses));
return(arena);
}
}
public async Task <ArenaSessionModel> AddArenaSession(ArenaSessionModel arenaModel)
{
using (var context = dbContext())
{
var arena = new ArenaSession();
arena.InjectFrom(arenaModel);
if (arenaModel.Hero != null)
{
arena.Hero = context.Heroes.Find(arenaModel.Hero.Id);
}
if (arenaModel.Image1 != null)
{
var img = context.ArenaDeckImages.Find(arenaModel.Image1.Id);
if (img == null)
{
img = arenaModel.Image1;
context.ArenaDeckImages.Add(img);
}
context.Entry(img).CurrentValues.SetValues(arenaModel.Image1);
arena.Image1 = img;
}
if (arenaModel.Image2 != null)
{
var img = context.ArenaDeckImages.Find(arenaModel.Image2.Id);
if (img == null)
{
img = arenaModel.Image2;
context.ArenaDeckImages.Add(img);
}
context.Entry(img).CurrentValues.SetValues(arenaModel.Image2);
arena.Image2 = img;
}
context.ArenaSessions.Add(arena);
await context.SaveChangesAsync();
arenaModel.InjectFrom(arena);
}
events.PublishOnBackgroundThread(new ArenaSessionAdded(arenaModel));
return(arenaModel);
}
public async Task AssignGameToArena(GameResultModel gameModel, ArenaSessionModel arenaModel)
{
using (var context = dbContext())
{
// var lastGame = context.Games.Where(x => x.ArenaSessionId == arenaModel.Id).OrderByDescending(x => x.ArenaGameNo).FirstOrDefault();
var arena = context.ArenaSessions.Query().First(x => x.Id == arenaModel.Id);
var game = context.Games.Query().First(x => x.Id == gameModel.Id);
// game.ArenaGameNo = lastGame == null ? 1 : lastGame.ArenaGameNo + 1;
AddGameToArena(game, arena);
SetEndDateIfNeeded(arena);
arena.Modified = DateTime.Now;
game.Modified = DateTime.Now;
await context.SaveChangesAsync();
gameModel.InjectFrom(game);
arenaModel.InjectFrom(arena);
gameModel.ArenaSession = arenaModel;
arenaModel.Games.Add(gameModel);
}
}
//private void OnSelectedArenaChanged()
//{
// if (!PauseNotify.IsPaused(this))
// {
// this.events.PublishOnBackgroundThread(new SelectedArenaSessionChanged(this, this.SelectedArenaSession != null ? this.SelectedArenaSession.Id : (Guid?)null));
// }
//}
private async Task Retire(ArenaSessionModel arenaSession)
{
await gameManager.Retire(arenaSession);
}
public ArenaSessionAdded(ArenaSessionModel arenaSession)
{
this.ArenaSession = arenaSession;
}
public ArenaSessionDeleted(ArenaSessionModel arenaSession)
{
ArenaSession = arenaSession;
}
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;
}
}
