🔨🔨 ajout de masse méthode converters et DTO + changements Model ( principalement leurs constructeurs )

Sources/Model/Game.cs

@@ -16,16 +16,16 @@ namespace Model
         public DateOnly Date { get; set; }
 
         public ReadOnlyCollection<Player> Players { get; private set; }
-        private List<Player> players = new();
+        private List<Player> players;
 
         public ReadOnlyCollection<Turn> Turns { get; private set; }
-        private List<Turn> turns = new();
+        private List<Turn> turns;
 
         public ReadOnlyDictionary<Player, Grille> Grilles { get; private set; }
-        private readonly Dictionary<Player, Grille> grilles = new Dictionary<Player, Grille>();
+        private readonly Dictionary<Player, Grille> grilles;
 
         public ReadOnlyDictionary<Player, int> Scores { get; private set; }
-        private readonly Dictionary<Player, int> scores = new Dictionary<Player, int>();
+        private readonly Dictionary<Player, int> scores;
 
         public GameMode GameMode { get; set; }
 
@@ -45,6 +45,10 @@ namespace Model
         public Game(DateOnly date, Player ?owner, GameMode gameMode, int id = 0)
         {
             Date = date;
+            players = new();
+            turns = new();
+            grilles = new Dictionary<Player, Grille>();
+            scores = new Dictionary<Player, int>();
             Players = new ReadOnlyCollection<Player>(players);
             Grilles = new ReadOnlyDictionary<Player, Grille>(grilles);
             Scores = new ReadOnlyDictionary<Player, int>(scores);
@@ -56,6 +60,22 @@ namespace Model
             Id = id;
         }
 
+        public Game(int id, TimeSpan duration, DateOnly date, List<Player> players, List<Turn> turns,  Dictionary<Player, Grille> grilles,  Dictionary<Player, int> scores, GameMode gameMode)
+        {
+            Id = id;
+            Duration = duration;
+            Date = date;
+            this.players = players;
+            Players = new ReadOnlyCollection<Player>(this.players);
+            this.turns = turns;
+            Turns = new ReadOnlyCollection<Turn>(this.turns);
+            this.grilles = grilles;
+            Grilles = new ReadOnlyDictionary<Player, Grille>(this.grilles);
+            this.scores = scores;
+            Scores = new ReadOnlyDictionary<Player, int>(this.scores);
+            GameMode = gameMode;
+        }
+
         public bool AddPlayerToGame(Player player)
         {
             if(grilles.ContainsKey(player) == false && scores.ContainsKey(player) == false)

Sources/Model/GameMode.cs

@@ -24,10 +24,9 @@ namespace Model
         }
         private string name = "";
 
-        public GameMode(string name, int id =0)
+        public GameMode(int id =0)
         {
             this.Id = id;
-            Name = name;
         }
     }
 }

Sources/Model/Grille.cs

@@ -16,7 +16,7 @@ namespace Model
         public int MaxZone { get; set; }
 
         public ReadOnlyCollection<Case> Cases { get; private set; }
-        private List<Case> cases = new();
+        private List<Case> cases { get; set; }
 
 
         //public Grille(List<Case> cases)
@@ -26,13 +26,15 @@ namespace Model
 
         public Grille(List<Case> cases)
         {
+            this.cases = new();
             Cases = new ReadOnlyCollection<Case>(cases);
             cases.AddRange(Enumerable.Repeat(new Case(), 19));
         }
 
         public Grille()
         {
-
+            this.cases = new();
+            Cases = new ReadOnlyCollection<Case>(this.cases);
         }
 
         public bool AddValueToCase(int value, int index)

Sources/Model/Turn.cs

@@ -38,8 +38,9 @@ namespace Model
         }
         private int diceValue2;
 
-        public Turn(int diceValue1, int diceValue2)
+        public Turn(int Id, int diceValue1, int diceValue2)
         {
+            this.Id = Id;
             DiceValue1 = diceValue1;
             DiceValue2 = diceValue2;
         }

Sources/Stub/Stub/StubData.Games.cs

@@ -13,11 +13,11 @@ namespace Stub
     {
         private List<Game> games = new()
         {
-            new Game(new DateOnly(2023,06,03), new Player("test1"),new GameMode("gamemode test1")),
-            new Game(new DateOnly(2023,06,03), new Player("test2"),new GameMode("gamemode test2")),
-            new Game(new DateOnly(2023,06,03), new Player("test3"),new GameMode("gamemode test3")),
-            new Game(new DateOnly(2023,06,03), new Player("test4"),new GameMode("gamemode test4")),
-            new Game(new DateOnly(2023,06,03), new Player("test5"),new GameMode("gamemode test5")),
+            new Game(new DateOnly(2023,06,03), new Player("test1"),new GameMode()),
+            new Game(new DateOnly(2023,06,03), new Player("test2"),new GameMode()),
+            new Game(new DateOnly(2023,06,03), new Player("test3"),new GameMode()),
+            new Game(new DateOnly(2023,06,03), new Player("test4"),new GameMode()),
+            new Game(new DateOnly(2023,06,03), new Player("test5"),new GameMode()),
 
         };
 

Sources/Trek12_API/Converter/CaseConverter.cs

@@ -0,0 +1,48 @@
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Model;
+using System.Runtime.CompilerServices;
+using Trek12_API.DTO;
+
+namespace Trek12_API.Converter
+{
+    public static class CaseConverter
+    {
+        public static CaseDTO toDTO(this Case caseToConvert)
+        {
+            CaseDTO dto = new CaseDTO();
+            dto.Id = caseToConvert.Id;
+            dto.Value = caseToConvert.Valeur;
+            return dto;
+        }
+
+        public static List<CaseDTO> toDTOs(this List<Case> listParam)
+        {
+            List<CaseDTO> list = new List<CaseDTO>();
+            foreach(var caseToConvert in listParam)
+            {
+                list.Add(caseToConvert.toDTO());
+            }
+
+            return list;
+        }
+
+        public static List<Case> toModels(this List<CaseDTO> listParam)
+        {
+            List<Case> list = new List<Case>();
+            foreach (var caseToConvert in listParam)
+            {
+                list.Add(caseToConvert.toModel());
+            }
+
+            return list;
+        }
+
+        public static Case toModel(this CaseDTO caseToConvert)
+        {
+            Case model = new Case();
+            model.Id = caseToConvert.Id;
+            model.Valeur = caseToConvert.Value;
+            return model;
+        }
+    }
+}

Sources/Trek12_API/Converter/GameConverter.cs

@@ -1,5 +1,4 @@
 using Model;
-using System.Collections.Generic;
 using Trek12_API.DTO;
 
 namespace Trek12_API.Converter
@@ -38,38 +37,36 @@ namespace Trek12_API.Converter
             return gameDTO;
         }
 
-        /*public static Game toModel(this GameDTO gameDTO)
+        public static Game toModel(this GameDTO gameDTO)
         {
             {
-                var game = new Game();
-                game.Duration = gameDTO.Duration;
-                game.Date = gameDTO.Date;
-                game.Turns = new List<Turn>();
-                foreach (var turn in game.Turns)
+                var turnsList = new List<Turn>();
+                foreach (var turn in gameDTO.Turns)
                 {
-                    gameDTO.Turns.Add(turn.toDTO());
+                    turnsList.Add(turn.toModel());
                 }
-                gameDTO.Grilles = new Dictionary<PlayerDTO, GrilleDTO>();
-                foreach (var grille in game.Grilles)
+
+                var playersList = new List<Player>();
+                foreach (var player in gameDTO.Players)
                 {
-                    gameDTO.Grilles.Add(grille.Key.toDTO(), grille.Value.toDTO());
+                    playersList.Add(player.toModel());
                 }
-                gameDTO.Scores = new Dictionary<PlayerDTO, int>();
-                foreach (var score in game.Scores)
+
+                var grillesDict = new Dictionary<Player, Grille>();
+                foreach (var (key, value) in gameDTO.Grilles)
                 {
-                    gameDTO.Scores.Add(score.Key.toDTO(), score.Value);
+                    grillesDict.Add(key.toModel(), value.toModel());
                 }
-                gameDTO.Players = new List<PlayerDTO>();
-                foreach (var player in game.Players)
+
+                var scoresDict = new Dictionary<Player, int>();
+                foreach (var (key, value) in gameDTO.Scores)
                 {
-                    gameDTO.Players.Add(player.toDTO());
+                    scoresDict.Add(key.toModel(), value);
+                }
+
+                var game = new Game(gameDTO.Id, gameDTO.Duration, gameDTO.Date, playersList, turnsList, grillesDict, scoresDict, gameDTO.GameMode.toModel());
+                return game;
+            }
         }
-                gameDTO.GameMode = new GamemodeDTO()
-                {
-                    Id = game.GameMode.Id,
-                    Name = game.GameMode.Name
-                };
-                return gameDTO;
-            }*/
     }
 }

Sources/Trek12_API/Converter/GameModeConverter.cs

@@ -13,5 +13,14 @@ namespace Trek12_API.Converter
                 Name = gameMode.Name,
             };
         }
+
+        public static GameMode toModel( this GamemodeDTO gamemode)
+        {
+            return new GameMode()
+            {
+                Id = gamemode.Id,
+                Name = gamemode.Name
+            };
+        }
     }
 }

Sources/Trek12_API/Converter/GrilleConverter.cs

@@ -1,4 +1,5 @@
 using Model;
+using System.Runtime.CompilerServices;
 using Trek12_API.DTO;
 
 namespace Trek12_API.Converter
@@ -13,8 +14,31 @@ namespace Trek12_API.Converter
                 NbChaines = grille.NbChaine,
                 NbZones = grille.NbZone,
                 MaxChaines = grille.MaxChaine,
-                MaxZones = grille.MaxZone
+                MaxZones = grille.MaxZone,
             };
         }
+
+        public static Grille toModel(this GrilleDTO grilleDTO)
+        {
+            return new Grille(grilleDTO.Cases.toModels())
+            {
+                Id = grilleDTO.Id,
+                NbChaine = grilleDTO.NbChaines,
+                NbZone = grilleDTO.NbZones,
+                MaxChaine = grilleDTO.MaxChaines,
+                MaxZone = grilleDTO.MaxZones
+            };
+        }
+
+        public static IEnumerable<Grille> toModels(this IEnumerable<GrilleDTO> grilles)
+        {
+            var grilleModels = new List<Grille>();
+            foreach( var grille in grilles)
+            {
+                grilleModels.Add(grille.toModel());
+            }
+
+            return grilleModels;
+        }
     }
 }

Sources/Trek12_API/Converter/TurnConverter.cs

@@ -14,5 +14,20 @@ namespace Trek12_API.Converter
                 diceValue2 = turn.DiceValue2,
             };
         }
+
+        public static Turn toModel(this TurnDTO turnDTO)
+        {
+            return new Turn(turnDTO.Id, turnDTO.diceValue1, turnDTO.diceValue2);
+        }
+
+        public static IEnumerable<Turn> toModels(this IEnumerable<TurnDTO> turns)
+        {
+            var turnsList = new List<Turn>();
+            foreach(var turn in turns)
+            {
+                turnsList.Add(turn.toModel());
+            }
+            return turnsList;
+        }
     }
 }

Sources/Trek12_API/DTO/CaseDTO.cs

@@ -0,0 +1,8 @@
+namespace Trek12_API.DTO
+{
+    public class CaseDTO
+    {
+        public int Id { get; set; }
+        public int Value { get; set; }
+    }
+}

Sources/Trek12_API/DTO/GrilleDTO.cs

@@ -1,4 +1,6 @@
-namespace Trek12_API.DTO
+using Model;
+
+namespace Trek12_API.DTO
 {
     public class GrilleDTO
     {
@@ -7,5 +9,7 @@
         public int NbZones { get; set; }
         public int MaxChaines { get; set; }
         public int MaxZones { get; set; }
+        public List<CaseDTO> Cases { get; set; }
+
     }
 }