🔀merge théo et moi

Sources/Model/Game.cs

@@ -12,9 +12,11 @@ namespace Model
         public int Id { get; set; }
 
         public TimeSpan Duration { get; set; }
+
         public DateOnly Date { get; set; }
-        //public ReadOnlyCollection<Player> Players { get; private set; }
-        //private List<Player> players = new();
+
+        public ReadOnlyCollection<Player> Players { get; private set; }
+        private List<Player> players = new();
 
         public ReadOnlyCollection<Turn> Turns { get; private set; }
         private List<Turn> turns = new();
@@ -43,6 +45,7 @@ namespace Model
         public Game(DateOnly date, Player owner, GameMode gameMode, int id = 0)
         {
             Date = date;
+            Players = new ReadOnlyCollection<Player>(players);
             Grilles = new ReadOnlyDictionary<Player, Grille>(grilles);
             Scores = new ReadOnlyDictionary<Player, int>(scores);
             Turns = new ReadOnlyCollection<Turn>(turns);
@@ -50,7 +53,6 @@ namespace Model
             scores.Add(owner, 0);
             GameMode = gameMode;
             Id = id;
-
         }
 
         public bool AddPlayerToGame(Player player)
@@ -74,7 +76,7 @@ namespace Model
             return false;
         }
 
-        public bool AddCaseValue(Player player, int value, int index)
+        public bool AddCaseValueToPlayer(Player player, int value, int index)
         {
             if (grilles.ContainsKey(player) == true && scores.ContainsKey(player) == true)
             {

Sources/Model/IDataManager.cs

@@ -30,11 +30,10 @@ namespace Model
     public interface IGamesManager : IGenericDataManager<Game?>
     {
         Task<bool> AddPlayer(Player player);
-        Task<bool> AddScoreToPlayer(int id, int score);
-        Task<bool> AddCaseValueToPlayer(int id, int value, int index);
+        Task<bool> AddScoreToPlayer(int idGame, int idPlayer, int score);
+        Task<bool> AddCaseValueToPlayer(int idGame, int idPlayer, int value, int index);
         Task<bool> AddTurn(Turn turn);
         Task<bool> AddTime(TimeSpan time);
-
     }
 
     public interface IGamesModeManager : IGenericDataManager<GameMode?>

Sources/Stub/Stub/Extensions.cs

@@ -34,7 +34,7 @@ namespace Stub
         {
             if (item == null || collection.Contains(item))
             {
-                return Task.FromResult<T?>(default(T));
+                return Task.FromResult(default(T));
             }
             collection.Add(item);
             return Task.FromResult<T?>(item);

Sources/Stub/Stub/StubData.Cases.cs

@@ -27,29 +27,22 @@ namespace Stub
                 => this.parent = parent;
 
             public Task<Case?> AddItem(Case? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.Cases.AddItem(item);
 
             public Task<bool> DeleteItem(Case? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.Cases.DeleteItem(item);
 
             public Task<IEnumerable<Case?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.Cases.GetItemsWithFilterAndOrdering(
+                    c => true,
+                    index, count, 
+                    orderingPropertyName, descending);
 
             public Task<int> GetNbItems()
-            {
-                throw new NotImplementedException();
-            }
+                => Task.FromResult(parent.Cases.Count());
 
             public Task<Case?> UpdateItem(Case? oldItem, Case? newItem)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.Cases.UpdateItem(oldItem, newItem);
         }
     }
 }

Sources/Stub/Stub/StubData.Games.cs

@@ -23,55 +23,88 @@ namespace Stub
             public GamesManager(StubData parent)
                 => this.parent = parent;
 
-            Task<bool> IGamesManager.AddCaseValueToPlayer(int id, int value, int index)
+            Task<bool> IGamesManager.AddCaseValueToPlayer(int idGame, int idPlayer, int value, int index)
             {
-                throw new NotImplementedException();
-            }
-
-            Task<Game?> IGenericDataManager<Game?>.AddItem(Game? item)
-            {
-                throw new NotImplementedException();
+                var game = parent.games.FirstOrDefault(g => g.Id == idGame);
+                if(game == null)
+                {
+                    return Task.FromResult(false);
+                }
+                var player = game.Players.FirstOrDefault(p => p.Id == idPlayer);
+                if(player == null)
+                {
+                    return Task.FromResult(false);
+                }
+                game.AddCaseValueToPlayer(player, value, index);
+                return Task.FromResult(true);
             }
 
             Task<bool> IGamesManager.AddPlayer(Player player)
             {
-                throw new NotImplementedException();
+                var game = parent.games.FirstOrDefault();
+                if(game == null)
+                {
+                    return Task.FromResult(false) ;
+                }
+                game.Players.AddItem(player);
+                return Task.FromResult(true);
             }
 
-            Task<bool> IGamesManager.AddScoreToPlayer(int id, int score)
+            Task<bool> IGamesManager.AddScoreToPlayer(int idGame, int idPlayer, int score)
             {
-                throw new NotImplementedException();
+                var game = parent.games.FirstOrDefault(g => g.Id == idGame);
+                if( game == null)
+                {
+                    return Task.FromResult(false);
+                }
+                var player = game.Players.FirstOrDefault(p => p.Id == idPlayer);
+                if(player == null)
+                {
+                    return Task.FromResult(false);
+                }
+                game.AddScoreToPlayer(player, score);
+                return Task.FromResult(true);
             }
 
             Task<bool> IGamesManager.AddTime(TimeSpan time)
             {
-                throw new NotImplementedException();
+                var game = parent.games.FirstOrDefault();
+                if (game == null)
+                {
+                    return Task.FromResult(false);
+                }
+                game.AddTime(time);
+                return Task.FromResult(true);
             }
 
             Task<bool> IGamesManager.AddTurn(Turn turn)
             {
-                throw new NotImplementedException();
+                var game = parent.games.FirstOrDefault();
+                if( game == null)
+                {
+                    return Task.FromResult(false);
+                }
+                game.AddTurn(turn);
+                return Task.FromResult(true);
             }
 
+            Task<Game?> IGenericDataManager<Game?>.AddItem(Game? item)
+                => parent.games.AddItem(item);
+
             Task<bool> IGenericDataManager<Game?>.DeleteItem(Game? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.games.DeleteItem(item);
 
             Task<IEnumerable<Game?>> IGenericDataManager<Game?>.GetItems(int index, int count, string? orderingPropertyName, bool descending)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.games.GetItemsWithFilterAndOrdering(
+                    g => true,
+                    index, count,
+                    orderingPropertyName, descending);
 
             Task<int> IGenericDataManager<Game?>.GetNbItems()
-            {
-                throw new NotImplementedException();
-            }
+                => Task.FromResult(parent.games.Count());
 
             Task<Game?> IGenericDataManager<Game?>.UpdateItem(Game? oldItem, Game? newItem)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.games.UpdateItem(oldItem, newItem);
         }
     }
 }

Sources/Stub/Stub/StubData.GamesMode.cs

@@ -23,29 +23,22 @@ namespace Stub
                 => this.parent = parent;
 
             public Task<GameMode?> AddItem(GameMode? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.GamesMode.AddItem(item);
 
             public Task<bool> DeleteItem(GameMode? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.GamesMode.DeleteItem(item);
 
             public Task<IEnumerable<GameMode?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.GamesMode.GetItemsWithFilterAndOrdering(
+                    g => true,
+                    index, count,
+                    orderingPropertyName, descending);
 
             public Task<int> GetNbItems()
-            {
-                throw new NotImplementedException();
-            }
+                => Task.FromResult(parent.GamesMode.Count());
 
             public Task<GameMode?> UpdateItem(GameMode? oldItem, GameMode? newItem)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.GamesMode.UpdateItem(oldItem, newItem);
         }
     }
 }

Sources/Stub/Stub/StubData.Grilles.cs

@@ -24,22 +24,22 @@ namespace Stub
                 => this.parent = parent;
 
             public Task<Grille?> AddItem(Grille? item)
-             => parent.grilles.AddItem(item);
+                => parent.grilles.AddItem(item);
 
             public Task<bool> DeleteItem(Grille? item)
-             => parent.grilles.DeleteItem(item);
+                => parent.grilles.DeleteItem(item);
 
             public Task<IEnumerable<Grille?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
-            => parent.grilles.GetItemsWithFilterAndOrdering(
+                => parent.grilles.GetItemsWithFilterAndOrdering(
                         c => true,
                         index, count,
                         orderingPropertyName, descending);
 
             public Task<int> GetNbItems()
-            => Task.FromResult(parent.grilles.Count);
+                => Task.FromResult(parent.grilles.Count);
 
             public Task<Grille?> UpdateItem(Grille? oldItem, Grille? newItem)
-             => parent.grilles.UpdateItem(oldItem,newItem);
+                => parent.grilles.UpdateItem(oldItem,newItem);
         }
     }
 }

Sources/Stub/Stub/StubData.Players.cs

@@ -28,10 +28,10 @@ namespace Stub
                 => parent.players.AddItem(item);
 
             public Task<bool> DeleteItem(Player? item)
-             => parent.players.DeleteItem(item);
+                => parent.players.DeleteItem(item);
 
             public Task<IEnumerable<Player?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
-            => parent.players.GetItemsWithFilterAndOrdering(
+                => parent.players.GetItemsWithFilterAndOrdering(
                         c => true,
                         index, count,
                         orderingPropertyName, descending);
@@ -40,14 +40,14 @@ namespace Stub
                 => Task.FromResult(parent.players.Count());
 
             public Task<Player?> UpdateItem(Player? oldItem, Player? newItem)
-             => parent.players.UpdateItem(oldItem, newItem);
+                => parent.players.UpdateItem(oldItem, newItem);
 
             private Func<Player, string, bool> filterByPseudo = (player, substring) => player.Pseudo.Contains(substring, StringComparison.InvariantCultureIgnoreCase);
             private Func<Player, int, bool> filterById = (player, id) => player.Id.Equals(id);
 
 
             public Task<IEnumerable<Player?>> GetItemsByPseudo(string charPseudo, int index, int count, string? orderingPropertyName, bool descending = false)
-               => parent.players.GetItemsWithFilterAndOrdering(player => filterByPseudo(player, charPseudo), index, count, orderingPropertyName, descending);
+                => parent.players.GetItemsWithFilterAndOrdering(player => filterByPseudo(player, charPseudo), index, count, orderingPropertyName, descending);
 
             public Task<int> GetNbItemsByPseudo(string charPseudo)
             {

Sources/Stub/Stub/StubData.Stats.cs

@@ -23,14 +23,10 @@ namespace Stub
                 => this.parent = parent;
 
             public Task<Stats?> AddItem(Stats? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.stats.AddItem(item);
 
             public Task<bool> DeleteItem(Stats? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.stats.DeleteItem(item);
 
             public Task<IEnumerable<Stats?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
             => parent.stats.GetItemsWithFilterAndOrdering(
@@ -39,14 +35,10 @@ namespace Stub
                         orderingPropertyName, descending);
 
             public Task<int> GetNbItems()
-            {
-                throw new NotImplementedException();
-            }
+                => Task.FromResult(parent.stats.Count());
 
             public Task<Stats?> UpdateItem(Stats? oldItem, Stats? newItem)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.stats.UpdateItem(oldItem, newItem);
         }
     }
 }

Sources/Stub/Stub/StubData.Turns.cs

@@ -23,29 +23,22 @@ namespace Stub
                 => this.parent = parent;
 
             public Task<Turn?> AddItem(Turn? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.Turns.AddItem(item);
 
             public Task<bool> DeleteItem(Turn? item)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.Turns.DeleteItem(item);
 
             public Task<IEnumerable<Turn?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.Turns.GetItemsWithFilterAndOrdering(
+                    t => true,
+                    index, count,
+                    orderingPropertyName, descending);
 
             public Task<int> GetNbItems()
-            {
-                throw new NotImplementedException();
-            }
+                => Task.FromResult(parent.Turns.Count());
 
             public Task<Turn?> UpdateItem(Turn? oldItem, Turn? newItem)
-            {
-                throw new NotImplementedException();
-            }
+                => parent.Turns.UpdateItem(oldItem, newItem);
         }
     }
 }

Sources/Trek12_API/Converter/GameConverter.cs

@@ -1,9 +1,32 @@
 using Model;
+using System.Collections.Generic;
 using Trek12_API.DTO;
 
 namespace Trek12_API.Converter
 {
-    public class GameConverter
+    public static class GameConverter
     {
+        public static GameDTO toDTO(this Game game) 
+        {
+            var gameDTO = new GameDTO(game.Id, game.Date, game.Player.toDTO(), game.GameMode.toDTO());
+            gameDTO.Duration = game.Duration;
+            gameDTO.Date = game.Date;
+            gameDTO.Turns = new List<TurnDTO>();
+            foreach (var turn in game.Turns)
+            {
+                gameDTO.Turns.Add(turn.toDTO());
+            }
+            gameDTO.Grilles = new Dictionary<PlayerDTO, GrilleDTO>();
+            foreach ( var grille in game.Grilles)
+            {
+                gameDTO.Grilles.Add(grille.Key.toDTO(), grille.Value.toDTO());
+            }
+            gameDTO.Scores = new Dictionary<PlayerDTO, int>();
+            foreach ( var score in game.Scores)
+            {
+                gameDTO.Scores.Add(score.Key.toDTO(), score.Value);
+            }
+            return gameDTO;
+        }
     }
 }

Sources/Trek12_API/Converter/GameModeConverter.cs

@@ -0,0 +1,17 @@
+using Model;
+using Trek12_API.DTO;
+
+namespace Trek12_API.Converter
+{
+    public static class GameModeConverter
+    {
+        public static GamemodeDTO toDTO(this GameMode gameMode)
+        {
+            return new GamemodeDTO()
+            {
+                Id = gameMode.Id,
+                Name = gameMode.Name,
+            };
+        }
+    }
+}

Sources/Trek12_API/Converter/GrilleConverter.cs

@@ -0,0 +1,20 @@
+using Model;
+using Trek12_API.DTO;
+
+namespace Trek12_API.Converter
+{
+    public static class GrilleConverter
+    {
+        public static GrilleDTO toDTO(this Grille grille)
+        {
+            return new GrilleDTO()
+            {
+                Id = grille.Id,
+                NbChaines = grille.NbChaine,
+                NbZones = grille.NbZone,
+                MaxChaines = grille.MaxChaine,
+                MaxZones = grille.MaxZone
+            };
+        }
+    }
+}

Sources/Trek12_API/Converter/TurnConverter.cs

@@ -0,0 +1,18 @@
+using Model;
+using Trek12_API.DTO;
+
+namespace Trek12_API.Converter
+{
+    public static class TurnConverter
+    {
+        public static TurnDTO toDTO(this Turn turn)
+        {
+            return new TurnDTO()
+            {
+                Id = turn.Id,
+                diceValue1 = turn.DiceValue1,
+                diceValue2 = turn.DiceValue2,
+            };
+        }
+    }
+}

Sources/Trek12_API/DTO/GameDTO.cs

@@ -9,12 +9,10 @@ namespace Trek12_API.DTO
         public TimeSpan Duration { get; set; }
         public DateOnly Date { get; set; }
         public List<TurnDTO> Turns { get; set; }
-
         public Dictionary<PlayerDTO, GrilleDTO> Grilles { get; set; }
-
         public Dictionary<PlayerDTO, int> Scores { get; set; }
-
         public GamemodeDTO GameMode { get; set; }
+        public PlayerDTO Player { get; set; }
 
         public GameDTO(int id, DateOnly date, PlayerDTO owner, GamemodeDTO gameMode)
         {
@@ -26,6 +24,7 @@ namespace Trek12_API.DTO
             Scores.Add(owner, 0);
             GameMode = gameMode;
             Id = id;
+            Player = owner;
         }
     }
 }

Sources/Trek12_API/DTO/TurnDTO.cs

@@ -4,7 +4,6 @@
     {
         public int Id { get; set; }
         public int diceValue1 { get; set; }
-        public string diceValue2 { get; set; }
-
+        public int diceValue2 { get; set; }
     }
 }