KoogleV4/GameData/Repository/GameRepository.cs

using GameData.Model;
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;
using System.Text;
using System.Threading.Tasks;
using static System.Net.Mime.MediaTypeNames;

namespace GameData.Repository
{
    public class GameRepository : IGameRepository
    {
        readonly ILogger<GameRepository> _log;
        private ApiClient _client;

        string UrlGameState => "items/gamestate";
        string UrlGame => "items/game";

        public GameRepository(ILogger<GameRepository> log, ApiClient apiClient)
        {
            _log = log;
            _client = apiClient;
        }

        public async Task<IEnumerable<GameState>?> LoadStates(Guid gameId)
        {
            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)
        {
            var str = JsonConvert.SerializeObject(gameState, new JsonSerializerSettings()
            {
                TypeNameHandling = TypeNameHandling.Auto
            });
            var gameStateDo = new GameStateDo(gameState.Id, gameState.GameId, gameState.GameName, str, gameState.Counter);
            var res = await _client.Post<GameStateDo>(gameStateDo,UrlGameState);

            if (res == null)
            {
                var msg = "error saviong gamestate - save rsult cannot be null - repo not online, or game deleted";
                _log.LogError(msg);
                throw new InvalidOperationException(msg);
            }

            var obj = JsonConvert.DeserializeObject<GameState>(res.GameState, new JsonSerializerSettings()
            {
                TypeNameHandling = TypeNameHandling.Auto
            });

            return obj;
        }

        public async Task Update(Game game)
        {
            await _client.Put<Game>(game, UrlGame);
        }

        public async Task<Game> Create(Game game)
        {
            return await _client.Post<Game>(game, UrlGame);
        }

        public async Task<Game> LoadGame(Guid gameId)
        {
            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);
        }

        public async Task Delete(IEnumerable<GameState> gameStates)
        {
            try
            {
                var arr = gameStates.Select(_ => _.Id.ToString()).ToArray();
                dynamic keys = new JObject();
                keys.keys = new JArray(arr);

                await _client.Delete(keys, UrlGameState);
            }
            catch (Exception e)
            {
                _log.LogError(e, "error on Delete");
                throw;
            }
        }
    }
}