dev

GameData/ApiClient.cs

@@ -232,14 +232,14 @@ namespace GameData
             return res;
         }
 
-        public T[] Get<T>(string serviceUrl, bool suppressExceptions = false)
+        public async Task<T[]> Get<T>(string serviceUrl, bool suppressExceptions = false)
         {
             WrapperArray<T> res = default;
 
             try
             {
                 _logger.LogDebug($"calling service url {serviceUrl}");
-                var response = client.Send(GetHttpRequestMessage(HttpMethod.Get, serviceUrl));
+                var response = await client.SendAsync(GetHttpRequestMessage(HttpMethod.Get, serviceUrl));
 
                 if (response.IsSuccessStatusCode)
                 {
@@ -266,7 +266,7 @@ namespace GameData
                 }
                 else
                 {
-                    var errorResult = response.Content.ReadAsStringAsync().Result;
+                    var errorResult = await response.Content.ReadAsStringAsync();
                     _logger.LogError("error getting from service '{service}' with code '{statuscode}' - Result: '{result}'", serviceUrl, response.StatusCode, errorResult);
                 }
             }
@@ -318,6 +318,7 @@ namespace GameData
                 {
                     var errorResult = await response.Content.ReadAsStringAsync();
                     _logger.LogError("error getting from service '{service}' with code '{statuscode}' - Result: '{result}'", serviceUrl, response.StatusCode, errorResult);
+                    return await Task.FromResult<T>(default(T));
                 }
             }
             catch (Exception ex)

GameData/Dummy/DummyExpenseRepository.cs

@@ -20,6 +20,11 @@ namespace GameData.Dummy
             throw new NotImplementedException();
         }
 
+        Task<IEnumerable<Expense>> IExpenseRepository.GetAll()
+        {
+            throw new NotImplementedException();
+        }
+
         Task<PlayerExpense> IExpenseRepository.Save(PlayerExpense data)
         {
             throw new NotImplementedException();

GameData/Dummy/DummyGameRepository.cs

@@ -37,5 +37,15 @@ namespace GameData.Dummy
         {
             throw new NotImplementedException();
         }
+
+        public Task<Game> Create(string gameName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<IEnumerable<GameState>> LoadStates(Guid gameId)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

GameData/Repository/ExpenseRepository.cs

@@ -27,9 +27,9 @@ namespace GameData.Repository
             _log?.LogDebug("creating ExpenseRepository");
         }
 
-        public IEnumerable<Expense> GetAll()
+        public async Task<IEnumerable<Expense>> GetAll()
         {
-            return _client.Get<Expense>(UrlExpense).ToList();
+            return await _client.Get<Expense>(UrlExpense);
         }
 
         public async Task<PlayerExpense> Save(PlayerExpense memberExpense)

GameData/Repository/GameRepository.cs

@@ -3,6 +3,7 @@ using GameModel;
 using GameModel.Contracts;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -26,9 +27,25 @@ namespace GameData.Repository
             _client = apiClient;
         }
 
-        public GameState Load(Guid gameId)
+        public async Task<IEnumerable<GameState>?> LoadStates(Guid gameId)
         {
-            throw new NotImplementedException();
+            string str = JsonConvert.SerializeObject(
+              new
+              {
+                  gameid = new
+                  {
+                      _eq = gameId
+                  }
+              }
+            );
+            var states = await _client.Get<GameStateDo>( UrlGameState + "?filter" + str);
+
+            var res = states.OrderBy(_ => _.Counter).Select(_ => JsonConvert.DeserializeObject<GameState>(_.GameState, new JsonSerializerSettings()
+            {
+                TypeNameHandling = TypeNameHandling.Auto
+            }));
+
+            return res;
         }
 
         public async Task<GameState> Save(GameState gameState)
@@ -63,5 +80,13 @@ namespace GameData.Repository
         {
             return await _client.GetSingle<Game>(UrlGame + "/" + gameId);
         }
+
+        public async Task<Game> Create(string gameName)
+        {
+            dynamic payload = new JObject();
+            payload.gamename = gameName;
+            
+            return await _client.Post<Game>(payload, UrlGame);
+        }
     }
 }

GameHandler/ExpenseHandler.cs

@@ -23,7 +23,7 @@ namespace GameHandler
             _expenseRepository = expenseRepository;
         }
 
-        public ExpenseModel HandleGameExenseEventArgs(GameExenseEventArgs gameExenseEventArgs, ExpenseModel expenseModelToAppend)
+        public async Task<ExpenseModel> HandleGameExenseEventArgs(GameExenseEventArgs gameExenseEventArgs, ExpenseModel expenseModelToAppend)
         {
             if (!gameExenseEventArgs.PlayerIds.Any(_ => _ == gameExenseEventArgs.PlayerId))
             {
@@ -33,14 +33,16 @@ namespace GameHandler
             List<PlayerExpense> memberExpenses = PrepareResult(ref expenseModelToAppend);
             var triggers = gameExenseEventArgs.Triggers;
 
-            AssignExpenses(gameExenseEventArgs.PlayerId, gameExenseEventArgs.PlayerIds, memberExpenses, triggers);
+            await AssignExpenses(gameExenseEventArgs.PlayerId, gameExenseEventArgs.PlayerIds, memberExpenses, triggers);
 
             return expenseModelToAppend with { MemberExpenses = memberExpenses.ToArray() };
         }
 
-        private void AssignExpenses(int playerId, int[] playerIds, List<PlayerExpense> memberExpenses, ExpenseTrigger[] triggers)
+        private async Task AssignExpenses(int playerId, int[] playerIds, List<PlayerExpense> memberExpenses, ExpenseTrigger[] triggers)
         { 
-            var destExpenses = _expenseRepository.GetAll().Where(_ => _.ExpenseTriggers.Any(et => triggers.Any(et2 => et2 == et)));
+            var list = await _expenseRepository.GetAll();
+            var destExpenses = list
+                .Where(_ => _.ExpenseTriggers.Any(et => triggers.Any(et2 => et2 == et)));
 
             var inversePlayers = playerIds.Where(_ => _ != playerId);
             foreach (var expense in destExpenses)

GameHandler/GameService.cs

@@ -76,7 +76,7 @@ namespace GameHandler
         {
             var gm = _gh.InitGameModel(playerIds, gameSettings);
             var throwState = ThrowState.Create(_gh.ThrowMode(), _gh.ThrowsPerRount());
-            _game = await _gameStateHandler.CreateNewGame();
+            _game = await _gameStateHandler.CreateNewGame(gameName);            
             return GameState.Create(_game.Id, gameName, throwState, _gh.GetCurrentPlayerId(gm), gm);
         }
 
@@ -92,7 +92,7 @@ namespace GameHandler
 
         private void _gh_GameExpenseOccured(object? sender, EventArgs e)
         {
-            var expenseModel = _eh.HandleGameExenseEventArgs(e as GameExenseEventArgs, _gameStateHandler.ExpenseModel);
+            var expenseModel = _eh.HandleGameExenseEventArgs(e as GameExenseEventArgs, _gameStateHandler.ExpenseModel).Result;
             _gameStateHandler.Add(expenseModel);
             //_lastState = _lastState with { ExpenseModel = expenseModel };
         }
@@ -158,13 +158,21 @@ namespace GameHandler
             Game game = null;
             using (var scope = _rootContainer?.BeginLifetimeScope())
             {
-                var gs = new GameStateHandler(_scope.Resolve<IGameRepository>(), _scope.Resolve<IExpenseRepository>());
+                var gs = new GameStateHandler(scope.Resolve<IGameRepository>(), scope.Resolve<IExpenseRepository>());
                 game = await gs.LoadGame(gameId);
             }
 
+            if (game == null)
+            {
+                return null;
+            }
+
             _game = game;
             InitGameServiceBehaviour(game.GameName);
             var res = await _gameStateHandler.LoadState(game.Id);
+
+            _isStarted = res != null;
+                 
             return res;
         }
 

GameHandler/GameStateHandler.cs

@@ -114,14 +114,16 @@ namespace GameHandler
             
         }
 
-        internal async Task<Game> CreateNewGame()
+        internal async Task<Game> CreateNewGame(string gameName)
         {
-            return await _gameRepository.Create(null);
+            return await _gameRepository.Create(gameName);
         }
 
-        internal Task<GameState> LoadState(Guid gameId)
+        internal async Task<GameState> LoadState(Guid gameId)
         {
-            throw new NotImplementedException();
+            var existingGameStates = await _gameRepository.LoadStates(gameId);
+            gameStates.AddRange(existingGameStates.Select(_ => new GameStateHandlerItem<GameState>(_.Id,_)));
+            return existingGameStates.Last();
         }
 
         internal async Task<Game?> LoadGame(Guid gameId)

GameModel/Contracts/IExpenseRepository.cs

@@ -17,7 +17,7 @@ namespace GameModel.Contract
             Expense.Create(ExpenseType.Monetary,new[] { ExpenseTrigger.ExpensePoint }, "Strafpunkt, z.B. im \"Scheißspiel\"", 0.5m, false),
         };
 
-        IEnumerable<Expense> GetAll();
+        Task<IEnumerable<Expense>> GetAll();
         Task<PlayerExpense> Save(PlayerExpense data);
     }    
 }

GameModel/Contracts/IGameRepository.cs

@@ -9,7 +9,8 @@ namespace GameModel.Contracts
     public interface IGameRepository
     {
         Task<Game> Create(Game game);
-        GameState Load(Guid gameId);
+        Task<Game> Create(string gameName);        
+        Task<IEnumerable<GameState>> LoadStates(Guid gameId);
         Task<Game> LoadGame(Guid gameId);
         Task<GameState> Save(GameState gameState);
         Task Update(Game game);

KoogleCli/Program.cs

@@ -88,7 +88,7 @@ async Task ShowMainMenu()
 
 void ContinueGame()
 {
-    StartGameAction("", new Guid("597956fe-6d83-424f-865f-5856b63f82c9"));
+    StartGameAction("", new Guid("c042f8f0-3f52-48e7-b61e-82a6387af4bb"));
 }
 
 void MasterDataAction()
@@ -144,6 +144,13 @@ void StartGameAction(string gameName, Guid gameId)
         gameState = starttask.Result;
     }
 
+    if (gameState == null)
+    {
+        Console.WriteLine($"game with id {gameId} not found");
+        ShowMainMenu();
+        return;
+    }
+
     Show(gameState);
 
     do