Transférer les fichiers vers 'Documentation/doc_images'

This reverts commit 1c4d77aed6.

.drone.yml

@@ -31,7 +31,7 @@ steps:
     commands:
       - cd Sources/
       - dotnet restore Solution.sln
-      - dotnet sonarscanner begin /k:BowlingScoreApp /d:sonar.host.url=$${PLUGIN_SONAR_HOST} /d:sonar.coverageReportPaths="coveragereport/SonarQube.xml" /d:sonar.coverage.exclusions="Tests/**" /d:sonar.login=$${PLUGIN_SONAR_TOKEN} 
+      - dotnet sonarscanner begin /k:BowlingScoreApp /d:sonar.host.url=$${PLUGIN_SONAR_HOST} /d:sonar.coverageReportPaths="coveragereport/SonarQube.xml" /d:sonar.coverage.exclusions="Tests/**,BowlingApp/**,BowlingEF/**,Business/**,BowlingMaping/**,BowlingStub/**" /d:sonar.login=$${PLUGIN_SONAR_TOKEN} 
       - dotnet build Solution.sln -c Release --no-restore
       - dotnet test Solution.sln --logger trx --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura --collect "XPlat Code Coverage"
       - reportgenerator -reports:"**/coverage.cobertura.xml" -reporttypes:SonarQube -targetdir:"coveragereport"

.gitignore

@@ -426,3 +426,5 @@ Network Trash Folder
 Temporary Items
 .apdisk
 
+/Sources/BowlingApp/bowling.db-shm
+/Sources/BowlingApp/bowling.db-wal

README.md

@@ -1,15 +1,15 @@
 [![Build Status](https://codefirst.iut.uca.fr/api/badges/victor_perez.ngounou/BowlingScoreApp/status.svg)](https://codefirst.iut.uca.fr/victor_perez.ngounou/BowlingScoreApp)  
-[![Quality Gate Status](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=alert_status&token=squ_8476cf8c9c3d3acdcf6042e2075498afbe697e52)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
-[![Bugs](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=bugs)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
-[![Code Smells](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=code_smells)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
-[![Coverage](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=coverage)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)  
-[![Duplicated Lines (%)](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=duplicated_lines_density)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
-[![Lines of Code](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=ncloc)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
-[![Maintainability Rating](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=sqale_rating)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
-[![Reliability Rating](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=reliability_rating)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)  
-[![Security Rating](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=security_rating)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
-[![Technical Debt](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=sqale_index)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
-[![Vulnerabilities](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=vulnerabilities)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)  
+[![Quality Gate Status](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=alert_status&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+[![Bugs](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=bugs&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+[![Code Smells](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=code_smells&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+[![Coverage](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=coverage&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)  
+[![Duplicated Lines (%)](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=duplicated_lines_density&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+[![Lines of Code](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=ncloc&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+[![Maintainability Rating](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=sqale_rating&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+[![Reliability Rating](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=reliability_rating&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)  
+[![Security Rating](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=security_rating&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+[![Technical Debt](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=sqale_index&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+[![Vulnerabilities](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=vulnerabilities&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)  
  
  
 # BowlingScoreApp
@@ -17,6 +17,82 @@
 Welcome on the BowlingScoreApp project!  
 
 
+<img src="Documentation/doc_images/bowling-157933.png" height=40/>   
 
-_Generated with a_ **Code#0** _template_  
-<img src="Documentation/doc_images/CodeFirst.png" height=40/>   
+## Description
+
+Ce projet est une application de gestion de score de bowling.
+l'application vas permettre de:
+
+* Gérer les scores de plusieurs joueurs en même temps.
+* Gérer les matchs en équipe, en individuel ou en solo.
+* consulter les statistiques des joueurs.
+* consulter les statistiques des matchs.
+* Consulter l'historique des matchs.
+
+
+## Installation
+
+### Requirements
+
+* C# 8.0
+* .NET Core 6.0
+* Visual Studio 2022
+* Entity Framework Core 6.0
+* SQLite 3.36.0
+* xUnit 2.4.1
+
+### Clone
+
+Clone this repo to your local machine using `https://codefirst.iut.uca.fr/git/victor_perez.ngounou/BowlingScoreApp.git`
+
+* [Git](https://git-scm.com) - Download and Install Git.
+* [Visual Studio](https://visualstudio.microsoft.com/fr/) - Download and Install Visual Studio.
+* [SQLite](https://www.sqlite.org/index.html) - Download and Install SQLite.
+* [xUnit](https://xunit.net/) - Download and Install xUnit.
+* [Entity Framework Core](https://docs.microsoft.com/fr-fr/ef/core/) - Download and Install Entity Framework Core.
+
+### Install Entity Framework Core Tools
+
+```shell
+$ dotnet tool install --global dotnet-ef
+```
+
+### Setup
+
+* Ouvrir le projet dans Visual Studio.
+* Lancez le projet en mode debug.
+* Dans le menu déroulant, sélectionnez "BowlingApp" puis "Package Manager Console".
+* Dans la console, tapez la commande suivante:
+
+```shell
+$ dotnet ef database update 
+```
+
+* L'application est prête à être utilisée.
+
+## Usage
+
+* Open the solution in Visual Studio 2022
+* Build the solution
+* Run the application
+
+## Contributeurs
+
+* [Victor Perez NGOUNOU](https://codefirst.iut.uca.fr/git/victor_perez.ngounou)
+* [Mamadou Elaphi ARAFA](https://codefirst.iut.uca.fr/git/mamadou_elaphi.arafa)
+* [Augustin AFFOGNON](https://codefirst.iut.uca.fr/git/augustin.affognon)
+
+
+## Support
+
+Contactez-moi à l'un des endroits suivants !
+
+* Website at <a href="https://codefirst.iut.uca.fr/git/victor_perez.ngounou" target="_blank">`https://codefirst.iut.uca.fr/git/victor_perez.ngounou`</a>
+* Email at <a href="mailto:victor_perez.ngounou@etu.uca.fr" target="_blank">`victor_perez.ngounou@etu.uca.fr`</a>
+
+## License
+
+[![License](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=BowlingScoreApp&metric=license&token=d89d41f6a247037395d41fe6f40f53a402943bd9)](https://codefirst.iut.uca.fr/sonar/dashboard?id=BowlingScoreApp)
+
+- **[MIT license](http://opensource.org/licenses/mit-license.php)**

Sources/BowlingApp/Afficheur.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingApp
+{
+    /// <summary>
+    /// Classe pour gerer l'affichage en console
+    /// </summary>
+    public class Afficheur
+    {
+        #region Méthodes
+        
+        /// <summary>
+        /// Afficher le menu de l'application
+        /// </summary>
+        public static void AfficherMenu()
+        {
+            System.Console.WriteLine("Choisissez le mode de jeux :");
+            System.Console.WriteLine("1 - Solo ? ");
+            System.Console.WriteLine("2 - Indivuduelle?");
+            System.Console.WriteLine("3- Equipe?");
+
+        }
+
+        /// <summary>
+        /// Afficher les erreur de saisie
+        /// </summary>
+        /// <param name="message"></param>
+        public static void AfficherErreur(String message)
+        {
+            Console.WriteLine($"erreur {message}");
+        }
+
+        /// <summary>
+        /// Affiche le numéro de frame
+        /// </summary>
+        /// <param name="i"></param>
+        public static void AfficheNumFrame(int i)
+        {
+            Console.WriteLine($"Frame {i}");
+        }
+
+        public static void InviteNom(string type)
+        {
+            Console.WriteLine($"veillez entrez le nom {type} ");
+        }
+
+        public static void InviteNrb(string type)
+        {
+            Console.WriteLine($"veillez entrez le nombre de {type}");
+        }
+
+        public static void InviteQuilleTombe(int i)
+        {
+            Console.WriteLine($"Entrez le nombre de quilles tombés du lancer {i}");
+        }
+
+        public static void InviteNomJoueur(string pseudoJoueur,string speudoEquipe="")
+        {
+            Console.WriteLine((string.IsNullOrEmpty(speudoEquipe)) ? $"c'est le tour du joueur {pseudoJoueur}" : $"c'est le tour du joueur {pseudoJoueur} de l'équipe {speudoEquipe}");
+        }
+        #endregion
+    }
+}

Sources/BowlingApp/BowlingApp.csproj

@@ -1,11 +1,22 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
+<Project Sdk="Microsoft.NET.Sdk">
+  
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net6.0</TargetFramework>
+    <StartWorkingDirectory >$(MSBuildProjectDirectory)</StartWorkingDirectory>
   </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.10">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\BowlingEF\BowlingEF.csproj" />
     <ProjectReference Include="..\BowlingLib\BowlingLib.csproj" />
+    <ProjectReference Include="..\BowlingMaping\BowlingMaping.csproj" />
+    <ProjectReference Include="..\Business\Business.csproj" />
   </ItemGroup>
 </Project>

Sources/BowlingApp/Match.cs

@@ -0,0 +1,219 @@
+using BowlingLib.Model;
+using BowlingMaping;
+using Business;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingApp
+{
+    /// <summary>
+    /// This class is used to create a match
+    /// </summary>
+    public static class Match
+    {
+        #region Méthodes
+        
+        /// <summary>
+        /// Match en Solo
+        /// </summary>
+        /// <param name="saissiseur"></param>
+        public static void JeuSolo(Saissiseur saissiseur)
+        {
+            Afficheur.InviteNom("Joueur");
+            string Nom = saissiseur.CollecteNom();
+            Joueur joueur = new Joueur(Nom);
+            Partie partie = new Partie(joueur);
+            Manager manager = new Manager(new EquipeDbDataManager(), new PartieDbDataManager(), new JoueurDbDataManager());
+            LancerBoulle(partie, saissiseur);
+            joueur.AddPartie(partie);
+            manager.AddJoueur(joueur);
+        }
+
+
+        /// <summary>
+        /// Match en Individuel
+        /// </summary>
+        /// <param name="saissiseur"></param>
+        public static void JeuIndividuel(Saissiseur saissiseur)
+        {
+
+
+            Manager manager = new Manager(new EquipeDbDataManager(), new PartieDbDataManager(), new JoueurDbDataManager());
+
+
+            Afficheur.InviteNrb("Joueur");
+            int nbrj = saissiseur.CollecteNbr();
+            List<Joueur> joueurs = new List<Joueur>();
+            List<Partie> partiees = new List<Partie>();
+
+            // Création des joueurs et leur partie
+            for (int j = 0; j < nbrj; j++)
+            {
+                Afficheur.InviteNom($"Joueur {j + 1}");
+                string nomJoueur = saissiseur.CollecteNom(); // Nom d'un joueur
+                Joueur joueur = new Joueur(nomJoueur);
+                Partie partie = new Partie(joueur);
+
+                joueurs.Add(joueur);
+                partiees.Add(partie);
+            }
+
+            // Lancement pour chaque partie avce  10 frames
+            for (int j = 0; j < 10; j++) // 
+            {
+                for (int i = 0; i < partiees.Count; i++) // on lance les parties à tour de rôle
+                {
+                    Frame frame = new Frame(j + 1);
+                    Afficheur.InviteNomJoueur(joueurs[i].Pseudo);
+                    LancerFrame(partiees.ElementAt(i), saissiseur, frame);
+
+                }
+            }
+
+            for (int i = 0; i < joueurs.Count; i++)
+            {
+                joueurs[i].AddPartie(partiees[i]);
+                manager.AddJoueur(joueurs[i]);
+            }
+        }
+
+        /// <summary>
+        /// Match en Equipe
+        /// </summary>
+        /// <param name="saissiseur"></param>
+        public static void JeuxEnEquipe(Saissiseur saissiseur)
+        {
+            Manager manager = new Manager(new EquipeDbDataManager(), new PartieDbDataManager(), new JoueurDbDataManager());
+            Afficheur.InviteNrb("Equipe");
+            int nbrE = saissiseur.CollecteNbr();
+            Afficheur.InviteNrb("Joueur par Equipe");
+            int nbrJ = saissiseur.CollecteNbr();
+            List<Equipe> equipes = new List<Equipe>();
+            for (int i = 0; i < nbrE; i++)
+            {
+                Afficheur.InviteNom($"Equipe {i + 1}");//Recuperer le nom de l'equipe
+                string Nom = saissiseur.CollecteNom();
+                Equipe equipe = new Equipe(Nom);
+                for (int j = 0; j < nbrJ; j++)
+                {
+                    Console.WriteLine($"Equipe {i + 1}");
+                    Afficheur.InviteNom($"Joueur {j + 1}"); //Recuperer le nom des joueur de chaque Equipe
+                    string nomJoueur = saissiseur.CollecteNom();
+                    Joueur joueur = new Joueur(nomJoueur);
+                    equipe.AjouterJoueur(joueur);
+                }
+                equipes.Add(equipe);
+            }
+            // Lancement pour chaque partie avce  10 frames
+            for (int j = 0; j < 10; j++) // 
+            {
+                for (int i = 0; i <equipes.Count; i++) // on lance les parties à tour de rôle
+                {
+                    for (int k = 0; k < equipes[i].Joueurs.Count; k++)
+                    {
+                        Frame frame = new Frame(j + 1);
+                        Afficheur.InviteNomJoueur(equipes[i].Joueurs[k].Pseudo);
+                        LancerFrame(equipes[i].Joueurs[k].Parties.Last(), saissiseur, frame);
+                    }
+                }
+            }
+
+            //for (int i = 0; i < joueurs.Count; i++)
+            //{
+            //    joueurs[i].AddPartie(partiees[i]);
+            //    manager.AddJoueur(joueurs[i]);
+            //}
+
+        }
+
+        
+        
+        /// <summary>
+        /// Faire des lancers
+        /// </summary>
+        /// <param name="partie"></param>
+        /// <param name="saissiseur"></param"""
+        private static void LancerBoulle(Partie partie, Saissiseur saissiseur)
+        {
+            //Création des Frames pour la Partie
+            for (int i = 0; i < 10; i++)
+            {
+                Afficheur.AfficheNumFrame(i + 1);
+                Frame frame = new Frame(i + 1);
+                Afficheur.InviteQuilleTombe(1);
+                frame.Lancer(saissiseur.CollectQuilleTomber());//Premier lancer du Frame
+
+                //Faire le deuxième lancer si le premier n'est pas un strike
+                if (!frame.IsStrike)
+                {
+                    Afficheur.InviteQuilleTombe(2);
+                    frame.Lancer(saissiseur.CollectQuilleTomber());
+                }
+
+                //Faire le troisième du dernier frame lancer si le premier est un strike ou le deuxième est un spare
+                if (i == 9 && (frame.IsStrike || frame.IsSpare))
+                {
+                    Afficheur.InviteQuilleTombe(3);
+                    frame.Lancer(saissiseur.CollectQuilleTomber());
+                }
+                partie.AddFrame(frame);//ajout du frame à la partie
+                Console.WriteLine(partie.GetScore());//affichage du score à la fin de chaque frame
+            }
+        }
+
+
+
+        /// <summary>
+        /// Faire des lancers avec des frames spécifiques
+        /// </summary>
+        /// <param name="partie"></param>
+        /// <param name="saissiseur"></param>
+        /// <param name="frame"></param>
+        private static void LancerFrame(Partie partie, Saissiseur saissiseur, Frame frame)
+        {
+            Afficheur.AfficheNumFrame(frame.Numero);
+
+            Afficheur.InviteQuilleTombe(1);
+            frame.Lancer(saissiseur.CollectQuilleTomber());
+
+            if (!frame.IsStrike)
+            {
+                Afficheur.InviteQuilleTombe(2);
+                frame.Lancer(saissiseur.CollectQuilleTomber());
+            }
+            //Faire le troisième lancé si et seulement si il s'agit d'un strike ou spare
+            if (frame.Numero == 10 && (frame.IsStrike || frame.IsSpare))
+            {
+                Afficheur.InviteQuilleTombe(3);
+                frame.Lancer(saissiseur.CollectQuilleTomber());
+            }
+            partie.AddFrame(frame);
+            Console.WriteLine(partie.GetScore());//affichage du score à la fin de chaque frame
+        }
+        #endregion
+
+        /// <summary>
+        /// Match en Equipe
+        /// </summary>
+        /// <param name="saissiseur"></param>
+        //public static void JeuxEnEquipe(Saissiseur saissiseur)
+        //{
+            
+
+        //    for (int i = 0; i < equipes.Count; i++)
+        //    {
+        //        for (int j = 0; j < equipes[i].Joueurs.Count; j++)
+        //        {
+        //            Joueur joueur = equipes[i].Joueurs[j];
+        //            Partie partie = new Partie(joueur);
+        //            manager.AddJoueur(joueur);
+        //            LancerBoulle(partie, saissiseur);
+        //            manager.AddPartie(partie);
+        //        }
+        //    }
+        //}
+    }
+}

Sources/BowlingApp/Program.cs

@@ -1,12 +1,38 @@
-using System;
+using BowlingApp;
+using BowlingLib.Model;
+using BowlingMaping;
+using Business;
+using System;
 
 namespace HelloWorldApp
 {
-    class Program
+    static class Program
     {
+        /// <summary>
+        /// The main entry point for the application.
+        /// </summary>
+        /// <param name="args"></param>
         static void Main(string[] args)
         {
-            Console.WriteLine("Hello World!");
+            int choix=0;
+            while (choix <= 3)
+            {
+                Saissiseur saissiseur = new Saissiseur();
+                Afficheur.AfficherMenu();
+                choix = saissiseur.CollecterReponseMenu();
+                switch (choix)
+                {
+                    case 1:
+                        Match.JeuSolo(saissiseur);
+                        break;
+                    case 2:
+                        Match.JeuIndividuel(saissiseur);
+                        break;
+                    case 3:
+                        Match.JeuxEnEquipe(saissiseur);
+                        break;
+                }
+            }
         }
     }
 }

Sources/BowlingApp/Saissiseur.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingApp
+{
+    /// <summary>
+    /// Classe pour gerer la saisie
+    /// </summary>
+    public class Saissiseur
+    {
+        #region Méthodes
+        /// <summary>
+        /// Récuperer le choix de l'utilisateur
+        /// </summary>
+        /// <returns></returns>
+        public int CollecterReponseMenu()
+        {
+            while (true)
+            {
+                try
+                {
+                    int retour = int.Parse(Console.ReadLine());
+                    return retour;
+                }
+                catch (Exception)
+                {
+                    Afficheur.AfficherErreur("de Saisie veuillez recommencer");
+                }
+            }
+        }
+        
+        /// <summary>
+        /// Recupérer le nom
+        /// </summary>
+        /// <returns></returns>
+        public string CollecteNom()
+        {
+            string nom = Console.ReadLine();
+            return nom;
+        }
+        
+        /// <summary>
+        /// Recupérer le nombre
+        /// </summary>
+        /// <returns></returns>
+        public int CollecteNbr()
+        {
+            return CollectQuilleTomber();
+        }
+    
+    
+        /// <summary>
+        /// Récuperer le nombre de qulles tombé
+        /// </summary>
+        /// <returns></returns>
+        public int CollectQuilleTomber()
+        {
+            while (true)
+            {
+                try
+                {
+                    int nbr = int.Parse(Console.ReadLine());
+                    return nbr;
+                }
+                catch (Exception)
+                {
+                    Afficheur.AfficherErreur("de Saisie veuillez recommencer");
+                }
+            }
+        }
+        #endregion
+    }
+}

Sources/BowlingEF/BowlingEF.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.10" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.10" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="6.0.10">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

Sources/BowlingEF/Context/BowlingContext.cs

@@ -0,0 +1,27 @@
+using BowlingEF.Entities;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingEF.Context
+{
+    /// <summary>
+    /// Cette classe est le contexte de la base de données qui permet de faire le lien entre les objets et la base de données
+    /// </summary>
+    public class BowlingContext : DbContext
+    {
+        public DbSet<JoueurEntity> Joueurs { get; set; }
+        public DbSet<EquipeEntity> Equipes { get; set; }
+        public DbSet<PartieEntity> Parties { get; set; }
+        public DbSet<FrameEntity> Frames { get; set; }
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            optionsBuilder.UseSqlite("Data Source=bowling.db");
+        }
+
+    }
+}

Sources/BowlingEF/Entities/EquipeEntity.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingEF.Entities
+{
+    /// <summary>
+    /// Classe de gestion des equipes
+    /// </summary>
+    public class EquipeEntity
+    {
+        #region Propriétés
+        public long Id { get; set; }
+        public string Nom { get; set; }
+        public ICollection<JoueurEntity> Joueurs { get; set; }
+        #endregion
+
+        #region Constructeurs
+        public EquipeEntity()
+        {
+            Joueurs = new List<JoueurEntity>();
+        }
+        #endregion
+    }
+}

Sources/BowlingEF/Entities/FrameEntity.cs

@@ -0,0 +1,26 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace BowlingEF.Entities
+{
+    /// <summary>
+    /// Classe de gestion des frames
+    /// </summary>
+    public class FrameEntity
+    {
+        #region Properties
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public long Id { get; set; }
+        [Required]
+        public int Numero { get; set; }
+        [Required]
+        public int Lancer1 { get; set; }
+        [Required]
+        public int Lancer2 { get; set; }
+        public int Lancer3 { get; set; }
+
+        public PartieEntity Partie { get; set; }
+        #endregion
+    }
+}

Sources/BowlingEF/Entities/JoueurEntity.cs

@@ -0,0 +1,21 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace BowlingEF.Entities
+{
+    /// <summary>
+    /// Classe de gestion des Joueurs
+    /// </summary>
+    public class JoueurEntity
+    {
+        #region Properties
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public long Id { get; set; }
+
+        [Required]
+        public string Pseudo { get; set; }
+        public ICollection<PartieEntity> PartieEntities { get; set; } = new List<PartieEntity>();
+        #endregion
+    }
+}

Sources/BowlingEF/Entities/PartieEntity.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingEF.Entities
+{
+    /// <summary>
+    /// Classe de gestion des parties
+    /// </summary>
+    public class PartieEntity
+    {
+        #region Properties
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public long Id { get; set; }
+
+        [ForeignKey("JoueurForeignKey")]
+        public JoueurEntity Joueur { get; set; }
+        [Required]
+        public DateTime Date { get; set; }
+        public ICollection<FrameEntity> Frames { get; set; }
+        [Required]
+        public int? Score { get; set; }
+        #endregion
+
+        #region Constructors
+        public PartieEntity()
+        {
+            Frames = new List<FrameEntity>();
+        }
+        #endregion
+    }
+}

Sources/BowlingLib/Interface/IDataManager.cs

@@ -1,18 +0,0 @@
-using BowlingLib.Model;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BowlingLib.Interface
-{
-    public interface IDataManager<Data>
-    {
-        void Add(Data data);
-        void Delete(Data data);
-        void Update(Data data);
-        IEnumerable<Data> GetAll();
-        IEnumerable<Data> GetAll(int n, int j);
-    }
-}

Sources/BowlingLib/Model/Equipe.cs

@@ -4,89 +4,120 @@ using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
-using System.Threading.Tasks; 
-using System.Collections.ObjectModel;
+using System.Threading.Tasks;
 
 namespace BowlingLib.Model
 {
-    public class Equipe
+    /// <summary>
+    /// Classe Model Equipe
+    /// </summary>
+    public class Equipe:IEquatable<Equipe>
     {
-        private string nom;
+        #region Propiéters
+        public string Nom { get; private set; }
+        public  long Id { get; private set; }
 
-        public List<Joueur> Joueurs = new List<Joueur>();
+        public ReadOnlyCollection<Joueur> Joueurs { get; private set; }
 
-        
-        public string Nom
-        {
-            get { return nom; }
-            set { nom = value; }
-        }
+        private readonly List<Joueur> joueurs = new List<Joueur>();
+        #endregion
 
- 
+        #region Construteurs
 
+        public Equipe(string nom)
+        {
+            Nom = nom;
+            Joueurs = new ReadOnlyCollection<Joueur>(this.joueurs);
+        }
 
-        public Equipe(string nom, params Joueur[] joueurs)
+        public Equipe(long id, string nom, params Joueur[] joueurs)
         {
-            this.nom = nom;
+            Id = id;
+            Nom = nom;
+            Joueurs = new ReadOnlyCollection<Joueur>(this.joueurs);
             AjouterJoueurs(joueurs);
-         //  foreach (Joueur nouv in joueurs) AjouterJoueur(nouv);           
-
         }
-        public object Id { get; set; }
 
-        private int numero;
+        public Equipe(string nom, params Joueur[] joueurs)
+            : this(0, nom, joueurs) {}
 
-        public Equipe(string nom)
-        {
-            this.nom = nom;
-        }
+        #endregion
+
+        #region Méthodes
 
-       
-       public void AjouterJoueurs(params Joueur[] joueurs)
+        /// <summary>
+        /// Ajoute une liste de joueur à l'équipe
+        /// </summary>
+        /// <param name="joueurs"></param>
+        /// <returns></returns>
+        public IEnumerable<Joueur> AjouterJoueurs(params Joueur[] joueurs)
         {
-            foreach(var j in joueurs)
-            {
-                AjouterJoueur(j);
-            }
+            List<Joueur> result = new();
+            result.AddRange(joueurs.Where(a => AjouterJoueur(a)));
+            return result;
+
+
         }
 
+        /// <summary>
+        /// Ajouter un joueur s'il n'exciste pas dans la bd
+        /// </summary>
+        /// <param name="joueur"></param>
+        /// <returns></returns>
+
         public bool AjouterJoueur(Joueur joueur)
         {
-            if(!isExist(joueur))
+            if (!IsExist(joueur))
             {
-                Joueurs.Add(joueur);
+                joueurs.Add(joueur);
                 return true;
-            }else
+            }
+            else
             {
                 return false;
             }
         }
 
+        /// <summary>
+        /// Supprimer un joueur
+        /// </summary>
+        /// <param name="joueur"></param>
+
         public void SupprimerJoueur(Joueur joueur)
         {
-            Joueurs.Remove(joueur);
+            joueurs.Remove(joueur);
         }
+        
 
-        //retourner la liste non modifiable des joueurs de l'équipe
-        public List<Joueur> GetJoueurs()
+        /// <summary>
+        /// Fonction permettant de vérifier si un joueur existe déjà dans la liste (l'équipe)
+        /// </summary>
+        /// <param name="nouvJoueur"></param>
+        /// <returns></returns>
+        public bool IsExist(Joueur nouvJoueur)
         {
-            return Joueurs;
+            if (joueurs.Contains(nouvJoueur))
+                return true;
+            return false;
+        }
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(obj, null)) return false;
+            if (ReferenceEquals(obj, this)) return true;
+            if (GetType() != obj.GetType()) return false;
+            return Equals(obj as Equipe);
         }
 
-
-        // Fonction permettant de vérifier si un joueur existe déjà dans la liste (l'équipe)
-        public bool isExist(Joueur nouvJoueur)
+        public override int GetHashCode()
         {
-            if (Joueurs.Count > 0) {
+            return joueurs.GetHashCode();
+        }
 
-                {
-                    if (Joueurs.Contains(nouvJoueur)) return true;
-                } 
-            }
-            
-            
-            return false;
+        public bool Equals(Equipe other)
+        {
+            return joueurs.Equals(other.joueurs);
         }
+        #endregion
 
     }
 }

Sources/BowlingLib/Model/Frame.cs

@@ -1,16 +1,21 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace BowlingLib.Model
 {
-    public class Frame
+    /// <summary>
+    /// Classe Model Frame
+    /// </summary>
+    public class Frame:IEquatable<Frame>
     {
         const int MAX_QUILLE = 10;
-        public int Numero {
+        public int Numero
+        {
             get
             { return numero; }
             set
@@ -21,25 +26,33 @@ namespace BowlingLib.Model
         }
         private int numero;
 
+        private readonly long id;
+        public long Id
+        {
+            get { return id; }
+        }
+
 
-        public int QuillesRestantes 
-        { get
+        public int QuillesRestantes
+        {
+            get
             {
                 return quillesRestantes;
             }
-            set
+            private set
             {
                 this.quillesRestantes = value;
             }
         }
+        
         private int quillesRestantes;
 
-        public int QuillesTombees 
+        public int QuillesTombees
         {
             get
             {
                 return quillesTombees;
-            } 
+            }
             set
             {
                 this.quillesTombees = value;
@@ -47,51 +60,55 @@ namespace BowlingLib.Model
         }
         private int quillesTombees;
 
-        public bool IsStrike { 
-            get {
+        public bool IsStrike
+        {
+            get
+            {
                 return isStrike;
-            } 
-            set{
+            }
+            set
+            {
                 this.isStrike = value;
-               } 
+            }
         }
         private bool isStrike;
 
-        public bool IsSpare 
-        { 
-            get 
+        public bool IsSpare
+        {
+            get
             {
                 return isPark;
-            } 
+            }
             set
             {
                 this.isPark = value;
-            } 
+            }
         }
         private bool isPark;
 
         public bool IsFinished
         {
             get
-            { 
-                return isFinished; 
-            } 
-            set 
+            {
+                return isFinished;
+            }
+            set
             {
                 this.isFinished = value;
             }
 
         }
+
         private bool isFinished;
 
-        public Lancer Lancer1 
+        public Lancer Lancer1
         {
             get
-            { 
-                return lancer1; 
+            {
+                return lancer1;
             }
-            set 
-            { 
+            set
+            {
                 this.lancer1 = value;
             }
         }
@@ -110,6 +127,10 @@ namespace BowlingLib.Model
         }
         private Lancer lancer3;
 
+        /// <summary>
+        /// Constructeur destiné à Initialisé un Frame
+        /// </summary>
+        /// <param name="numero"></param>
         public Frame(int numero)
         {
             this.Numero = numero;
@@ -117,6 +138,23 @@ namespace BowlingLib.Model
             this.IsFinished = false;
             this.IsStrike = false;
             this.IsSpare = false;
+            this.QuillesTombees = 0;
+        }
+
+        /// <summary>
+        /// Constructeur destiné à la récupération des données en base
+        /// </summary>
+        /// <param name="numero"></param>
+        /// <param name="id"></param>
+        /// <param name="lancer1"></param>
+        /// <param name="lancer2"></param>
+        /// <param name="lancer3"></param>
+        public Frame(long id, int numero, int lancer1, int lancer2, int lancer3) : this(numero)
+        {
+            this.id = id;
+            Lancer1 = new Lancer(lancer1);
+            Lancer2 = new Lancer(lancer2);
+            Lancer3 = new Lancer(lancer3);
         }
 
         /// <summary>
@@ -135,7 +173,7 @@ namespace BowlingLib.Model
                 throw new ArgumentException("Le nombre de quilles tombees doit et etre positif");
             }
 
-            if (this.Numero == 10)
+            if (this.Numero == MAX_QUILLE)
             {
                 if (this.Lancer1 == null)
                 {
@@ -145,6 +183,7 @@ namespace BowlingLib.Model
                     if (quillesTombees == MAX_QUILLE)
                     {
                         this.IsStrike = true;
+                        QuillesRestantes = MAX_QUILLE;
                     }
                 }
                 else if (this.Lancer2 == null)
@@ -152,11 +191,14 @@ namespace BowlingLib.Model
                     this.Lancer2 = new Lancer(quillesTombees);
                     this.QuillesRestantes -= quillesTombees;
                     this.QuillesTombees += quillesTombees;
+                    //lorsque le premier lancer est un strike
                     if (this.IsStrike)
                     {
                         if (quillesTombees == MAX_QUILLE)
                         {
+                            //lorsque le lancer actuel est un strike
                             this.IsStrike = true;
+                            QuillesRestantes = MAX_QUILLE;//Remetre le nombre de quilles restantes à 10 pour le lancer 3
                         }
                         else
                         {
@@ -167,8 +209,9 @@ namespace BowlingLib.Model
                     {
                         if (quillesTombees + this.Lancer1.QuillesTombees == MAX_QUILLE)
                         {
+                            //lorsque le lancer actuel est un spare
                             this.IsSpare = true;
-                            QuillesRestantes = 10;
+                            QuillesRestantes = MAX_QUILLE;//Remetre le nombre de quilles restantes à 10 pour le lancer 3
                         }
                     }
                 }
@@ -177,22 +220,22 @@ namespace BowlingLib.Model
                     this.Lancer3 = new Lancer(quillesTombees);
                     this.QuillesRestantes -= quillesTombees;
                     this.QuillesTombees += quillesTombees;
-                    if (this.IsStrike)
+                    if (this.IsStrike)//si le deuxième lancer etait un strike
                     {
                         if (quillesTombees == MAX_QUILLE)
                         {
-                            this.IsStrike = true;
+                            this.IsStrike = true;//cas ou il effectue un 3eme strike
                         }
                         else
                         {
                             this.IsStrike = false;
                         }
                     }
-                    else if (this.IsSpare)
+                    else if (this.IsSpare)//si le deuxième lancer etait un spare
                     {
                         if (quillesTombees + this.Lancer2.QuillesTombees == MAX_QUILLE)
                         {
-                            this.IsSpare = true;
+                            this.IsSpare = true;//cas ou il effectue un 3eme spare
                         }
                         else
                         {
@@ -237,10 +280,28 @@ namespace BowlingLib.Model
                     this.IsSpare = true;
                 }
             }
-            if (this.QuillesRestantes == 0 || (this.Lancer2 != null && this.Numero != 10))
+            if (this.QuillesRestantes == 0 || (this.Lancer2 != null && this.Numero != MAX_QUILLE))
             {
                 this.IsFinished = true;
             }
         }
+
+        public bool Equals(Frame other)
+        {
+            return Numero.Equals(other.Numero);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(obj, null)) return false;
+            if (ReferenceEquals(obj, this)) return true;
+            if (GetType() != obj.GetType()) return false;
+            return Equals(obj as Frame);
+        }
+
+        public override int GetHashCode()
+        {
+            return Numero.GetHashCode();
+        }
     }
 }

Sources/BowlingLib/Model/Joueur.cs

@@ -1,40 +1,100 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
 
 namespace BowlingLib.Model
 {
-    public class Joueur
+    /// <summary>
+    /// Classe Model Joueur
+    /// </summary>
+    public class Joueur : IEquatable<Joueur>
     {
+        #region Propriétés
         private string pseudo;
+        private readonly long id;
 
+        private readonly List<Partie> parties=new();
+        public ReadOnlyCollection<Partie> Parties { get; }
+        #endregion
+
+        #region Constructeurs
         public Joueur(string pseudo)
         {
             this.Pseudo = pseudo;
+            Parties = new ReadOnlyCollection<Partie>(parties);
+        }
+
+        public Joueur(long id, string pseudo) : this(pseudo)
+        {
+            this.id = id;
+        }
+        #endregion
+
+        #region Accesseurs
+        public long Id
+        {
+            get { return id; }
         }
 
+        
+
         public string Pseudo
         {
             get { return pseudo; }
-            set 
+           private set 
             {
 
                 pseudo = value;
-                if (pseudo == null || pseudo == "" || pseudo.Length < 3)
+                if (string.IsNullOrWhiteSpace(pseudo) || pseudo.Length < 3)
                 {
                     throw new ArgumentException("Le pseudo ne peut pas être vide");
                 }
             }
         }
+        #endregion
+
+        #region Méthodes
+
+        public bool Equals(Joueur other)
+        {
+            return Pseudo.Equals(other.Pseudo);
+        }
+
+        public void setNom(string nom)
+        {
+            Pseudo = nom;
+        }
 
         public override bool Equals(object obj)
         {
-            return obj is Joueur joueur &&
-                   pseudo == joueur.pseudo &&
-                   Pseudo == joueur.Pseudo;
+            if(ReferenceEquals(obj, null)) return false;
+            if(ReferenceEquals(obj, this)) return true;
+            if(GetType() != obj.GetType()) return false;
+            return Equals(obj as Joueur);
+        }
+
+        public override int GetHashCode()
+        {
+            return Pseudo.GetHashCode();
+        }
+
+        public void AddPartie(Partie p)
+        {
+            if(Parties.Contains(p))
+                throw new ArgumentException("la partie existe deja");
+            parties.Add(p);
+        }
+
+        private string GetDebuggerDisplay()
+        {
+            return ToString();
         }
-        public int Id { get; set; }
+
+        #endregion
     }
 }

Sources/BowlingLib/Model/Manager.cs

@@ -1,147 +0,0 @@
-using BowlingLib.Interface;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BowlingLib.Model
-{
-    public class Manager
-    {
-        public IDataManager<Joueur> joueurManager { get; private set; }
-        public IDataManager<Partie> partieManager { get; private set; }
-        public IDataManager<Equipe> equipeManager { get; private set; }
-
-        public Manager(IDataManager<Joueur> joueurManager)
-        {
-            this.joueurManager = joueurManager;
-        }
-
-        public Manager(IDataManager<Partie> partieManager)
-        {
-            this.partieManager = partieManager;
-        }
-
-        /// <summary>
-        /// Ajoute un joueur à la liste des joueurs
-        /// </summary>
-        /// <param name="equipeManager"></param>
-        public Manager(IDataManager<Equipe> equipeManager)
-        {
-            this.equipeManager = equipeManager;
-        }
-
-        /// <summary>
-        /// Ajoute un joueur à la liste des joueurs
-        /// </summary>
-        /// <param name="joueur"></param>
-        public void AddJoueur(Joueur joueur)
-        {
-            joueurManager.Add(joueur);
-        }
-
-        /// <summary>
-        /// Ajoute une partie à la liste des parties
-        /// </summary>
-        /// <param name="partie"></param>
-        public void AddPartie(Partie partie)
-        {
-            partieManager.Add(partie);
-        }
-
-        /// <summary>
-        /// Ajoute une équipe à la liste des équipes
-        /// </summary>
-        /// <param name="equipe"></param>
-        public void AddEquipe(Equipe equipe)
-        {
-            equipeManager.Add(equipe);
-        }
-
-        /// <summary>
-        /// Retourne la liste des joueurs
-        /// </summary>
-        /// <param name="joueur"></param>
-        public void DeleteJoueur(Joueur joueur)
-        {
-            joueurManager.Delete(joueur);
-        }
-
-        /// <summary>
-        /// Supprime une partie
-        /// </summary>
-        /// <param name="partie"></param>
-        public void DeletePartie(Partie partie)
-        {
-            partieManager.Delete(partie);
-        }
-
-        /// <summary>
-        /// Supprime une équipe
-        /// </summary>
-        /// <param name="equipe"></param>
-        public void DeleteEquipe(Equipe equipe)
-        {
-            equipeManager.Delete(equipe);
-        }
-
-        /// <summary>
-        /// Retourne la liste des joueurs
-        /// </summary>
-        /// <param name="joueur"></param>
-        public void UpdateJoueur(Joueur joueur)
-        {
-            joueurManager.Update(joueur);
-        }
-
-        /// <summary>
-        /// Met à jour une partie
-        /// </summary>
-        /// <param name="partie"></param>
-        public void UpdatePartie(Partie partie)
-        {
-            partieManager.Update(partie);
-        }
-
-        /// <summary>
-        /// Met à jour une équipe
-        /// </summary>
-        /// <param name="equipe"></param>
-        public void UpdateEquipe(Equipe equipe)
-        {
-            equipeManager.Update(equipe);
-        }
-
-        /// <summary>
-        /// Retourne la liste des joueurs
-        /// </summary>
-        /// <returns></returns>
-        public IEnumerable<Joueur> GetAllJoueur()
-        {
-            return joueurManager.GetAll();
-        }
-
-        /// <summary>
-        /// Retourne les dernières parties du joueur
-        /// </summary>
-        /// <returns></returns>
-        public IEnumerable<Partie> GetAllPartie()
-        {
-            return partieManager.GetAll();
-        }
-
-        /// <summary>
-        /// Retourne les Equipe d'une partie
-        /// </summary>
-        /// <returns></returns>
-        public IEnumerable<Equipe> GetAllEquipe()
-        {
-            return equipeManager.GetAll();
-        }
-        
-        
-
-
-    }
-}

Sources/BowlingLib/Model/Partie.cs

@@ -7,13 +7,37 @@ using System.Threading.Tasks;
 
 namespace BowlingLib.Model
 {
-    public class Partie
+    /// <summary>
+    /// Classe Model Partie
+    /// </summary>
+    public class Partie:IEquatable<Partie>
     {
-        //public ReadOnlyCollection<Frame> Frames;
+        #region Propriétés
+        public ReadOnlyCollection<Frame> Frames { get; }
         public Joueur Joueur { get; private set; }
-        public object Id { get; set; }
+        private readonly long id;
+        private DateTime date;
+        private int? score = 0;
+        private readonly List<Frame> frames = new();
+        #endregion
 
-        public List<Frame> Frames;
+        #region Encapsulation
+        public int? Score { 
+            get 
+            {
+                return GetScore();
+            }
+            private set { score = value; }
+        }
+        public DateTime Date
+        {
+            get { return date; }
+            private set { date = value; }
+        }
+        public long Id => id;
+        #endregion
+
+        #region Constructeurs
 
         /// <summary>
         ///  Constructeur
@@ -22,16 +46,30 @@ namespace BowlingLib.Model
         public Partie(Joueur joueur)
         {
             this.Joueur = joueur;
-            Frames = new List<Frame>();
+            Date = DateTime.Now;
+            Frames = new ReadOnlyCollection<Frame>(frames);
+        }
+
+        public Partie(long id, Joueur joueur, List<Frame> frames,DateTime date, int? score) : this(joueur)
+        {
+            this.id = id;
+            this.frames = frames;
+            this.date = date;
+            this.Score = score;
         }
+        #endregion
 
+
+        #region Méthodes
         /// <summary>
         /// Ajoute un frame à la partie
         /// </summary>
         /// <param name="frame"></param>
         public void AddFrame(Frame frame)
         {
-            Frames.Add(frame);
+            if (Frames.Contains(frame))
+                throw new ArgumentException("Le frame existe déjà");
+            frames.Add(frame);
         }
 
 
@@ -41,7 +79,7 @@ namespace BowlingLib.Model
         /// <returns>le Score d'une partie</returns>
         public int? GetScore()
         {
-            int? score = 0;
+            score = 0;
             for (int i = 0; i < Frames.Count; i++)
             {
                 score += Frames[i].QuillesTombees;
@@ -60,5 +98,23 @@ namespace BowlingLib.Model
             }
             return score;
         }
+
+        public bool Equals(Partie other)
+        {
+            return Joueur.Equals(Joueur) && Date.Equals(other.Date);
+        }
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(obj, null)) return false;
+            if (ReferenceEquals(obj, this)) return true;
+            if (GetType() != obj.GetType()) return false;
+            return Equals(obj as Partie);
+        }
+
+        public override int GetHashCode()
+        {
+            return Joueur.GetHashCode();
+        }
+        #endregion
     }
 }

Sources/BowlingMaping/BowlingMaping.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\BowlingEF\BowlingEF.csproj" />
+    <ProjectReference Include="..\Business\Business.csproj" />
+  </ItemGroup>
+
+</Project>

Sources/BowlingMaping/EquipeDbDataManager.cs

@@ -0,0 +1,134 @@
+
+using BowlingEF.Context;
+using BowlingEF.Entities;
+using BowlingLib.Model;
+using Business;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingMaping
+{
+    public class EquipeDbDataManager : IDataManager<Equipe>
+    {
+        #region Méthodes
+        public async Task<bool> Add(Equipe _equipe)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                EquipeEntity entity = new EquipeEntity
+                {
+                    Id = _equipe.Id,
+                    Nom = _equipe.Nom,
+                    
+                };
+
+                for (int i = 0; i < _equipe.Joueurs.Count; i++)
+                {
+                    //Mapping entre la classe joueur et la classe joueurEntity
+                    JoueurEntity joueurEntity = new JoueurEntity
+                    {
+                        Id = _equipe.Joueurs[i].Id,
+                        Pseudo = _equipe.Joueurs[i].Pseudo,
+                    };
+
+                    //Parcourt de la liste des parties d'un joueur
+                    for (int j = 0; j < _equipe.Joueurs[i].Parties.Count; j++)
+                    {
+                        //Mapping entre les parties d'un joueur et les partieEntity d'une partieEntity
+                        PartieEntity partieEntity = new PartieEntity
+                        {
+                            Joueur = joueurEntity,
+                            Date = _equipe.Joueurs[i].Parties[j].Date,
+                            Score = _equipe.Joueurs[i].Parties[j].Score
+
+                        };
+
+                        //Parcourt de la liste des frames d'une partie
+                        for (int k = 0; k < _equipe.Joueurs[i].Parties[j].Frames.Count; k++)
+                        {
+                            //Mapping entre les frames d'une partie et les frameEntity d'une partieEntity
+                            FrameEntity frameEntity = new FrameEntity
+                            {
+                                Id = _equipe.Joueurs[i].Parties[j].Frames[k].Id,
+                                Lancer1 = _equipe.Joueurs[i].Parties[j].Frames[k].Lancer1.QuillesTombees,
+                                Lancer2 = _equipe.Joueurs[i].Parties[j].Frames[k].Lancer2.QuillesTombees,
+                                Lancer3 = _equipe.Joueurs[i].Parties[j].Frames[k].Lancer3.QuillesTombees,
+                                Partie = partieEntity
+                            };
+                            partieEntity.Frames.Add(frameEntity);
+                        }
+                        joueurEntity.PartieEntities.Add(partieEntity);
+                    }
+                    entity.Joueurs.Add(joueurEntity);
+
+
+                }
+                context.Equipes.Add(entity);
+                await context.SaveChangesAsync();
+                result = true;
+            }
+            return result;
+        }
+
+        public async Task<bool> Delete(Equipe _equipe)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                EquipeEntity entity = context.Equipes.Find(_equipe.Id);
+                context.Equipes.Remove(entity);
+                result = await context.SaveChangesAsync() > 0;
+            }
+            return result;
+        }
+
+        public async Task<IEnumerable<Equipe>> GetAll()
+        {
+            using (var context = new BowlingContext())
+            {
+                return await  context.Equipes.Select(e => new Equipe 
+                (
+                    e.Id,
+                    e.Nom,
+                    e.Joueurs.Select(j => new Joueur(j.Id, j.Pseudo)).ToArray()
+                )).ToListAsync();
+            }
+        }
+
+        public async Task<Equipe> GetDataWithName(string name)
+        {
+            using (var context = new BowlingContext())
+            {
+                return await context.Equipes.Where(e => e.Nom == name).Select(e => new Equipe
+                (
+                    e.Id,
+                    e.Nom,
+                    e.Joueurs.Select(j => new Joueur(j.Id, j.Pseudo)).ToArray()
+                )).FirstOrDefaultAsync();
+            }
+        }
+
+        public async Task< bool> Update(Equipe data)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                EquipeEntity entity =  context.Equipes.Find(data.Id);
+                entity.Nom = data.Nom;
+                entity.Joueurs = data.Joueurs.Select(j => new JoueurEntity
+                {
+                    Id = j.Id,
+                    Pseudo = j.Pseudo
+                }).ToList();
+                result = await context.SaveChangesAsync() > 0;
+            }
+            return result;
+        }
+        #endregion
+    }
+}

Sources/BowlingMaping/JoueurDbDataManager.cs

@@ -0,0 +1,150 @@
+using BowlingEF.Context;
+using BowlingEF.Entities;
+using BowlingLib.Model;
+using Business;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingMaping
+{
+    /// <summary>
+    /// Classe de gestion des données des joueurs
+    /// </summary>
+    public class JoueurDbDataManager : IDataManager<Joueur>
+    {
+        #region Méthodes
+        /// <summary>
+        /// Ajoute un joueur à la liste des joueurs
+        /// </summary>
+        /// <param name="_joueur"></param>
+        /// <returns></returns>
+        public async Task<bool> Add(Joueur _joueur)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                try
+                {
+                    //Mapping entre la classe joueur et la classe joueurEntity
+                    JoueurEntity entity = new JoueurEntity
+                    {
+                        Id = _joueur.Id,
+                        Pseudo = _joueur.Pseudo,
+                    };
+
+                    //Parcourt de la liste des parties d'un joueur
+                    for (int i = 0; i < _joueur.Parties.Count; i++)
+                    {
+                        //Mapping entre les parties d'un joueur et les partieEntity d'une partieEntity
+                        PartieEntity partieEntity = new PartieEntity
+                        {
+                            Joueur = entity,
+                            Date = _joueur.Parties[i].Date,
+                            Score = _joueur.Parties[i].Score
+
+                        };
+
+                        //Parcourt de la liste des frames d'une partie
+                        for (int j = 0; j < _joueur.Parties[i].Frames.Count; j++)
+                        {
+                            //Mapping entre les frames d'une partie et les frameEntity d'une partieEntity
+                            FrameEntity frameEntity = new FrameEntity
+                            {
+                                Id = _joueur.Parties[i].Frames[j].Id,
+                                Lancer1 = _joueur.Parties[i].Frames[j].Lancer1.QuillesTombees,
+                                Lancer2 = (_joueur.Parties[i].Frames[j].Lancer2 == null) ? 0 : _joueur.Parties[i].Frames[j].Lancer2.QuillesTombees,
+                                Lancer3 = (_joueur.Parties[i].Frames[j].Lancer3 == null) ? 0 : _joueur.Parties[i].Frames[j].Lancer3.QuillesTombees,//si Lancer3 est null il prend la valeur Zero
+                                Partie = partieEntity
+                            };
+                            partieEntity.Frames.Add(frameEntity);
+                        }
+                        entity.PartieEntities.Add(partieEntity);
+                    }
+                    context.Joueurs.Add(entity);
+                    result = await context.SaveChangesAsync()  > 0;
+                }
+                catch (Exception ex)
+                {
+                    Debug.WriteLine(ex);
+                    throw;
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Supprime un joueur de la liste des joueurs
+        /// </summary>
+        /// <param name="_joueur"></param>
+        /// <returns></returns>
+        public async Task< bool> Delete(Joueur _joueur)
+        {
+            bool result = false;
+           
+           
+          
+                using (var context = new BowlingContext())
+                {
+                    JoueurEntity entity = context.Joueurs.Find(_joueur.Id);
+                    context.Joueurs.Remove(entity);
+                result = await context.SaveChangesAsync() > 0;
+                }
+                return result;
+        }
+
+        /// <summary>
+        /// recupère tous les joueurs de la Base de données
+        /// </summary>
+        /// <returns></returns>
+        public  async Task<IEnumerable<Joueur>> GetAll()
+        {
+            using (var context = new BowlingContext())
+            {
+                List<Joueur> joueurs = new  List<Joueur>();
+                foreach (var item in await context.Joueurs.ToListAsync())
+                    joueurs.Add(new Joueur(item.Id, item.Pseudo));
+                return joueurs;
+            }
+        }
+
+        /// <summary>
+        /// recupère un joueur de la Base de données par son pseudo
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public async Task<Joueur> GetDataWithName(string name)
+        {
+            using (var context = new BowlingContext())
+            {
+                Joueur _joueur = null;
+
+                var query = await context.Joueurs.FirstOrDefaultAsync(n => n.Pseudo == name);
+                _joueur = new Joueur(query.Id, query.Pseudo);
+                return _joueur;
+            }
+        }
+
+        public async Task<bool> Update(Joueur _joueur)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                JoueurEntity entity = context.Joueurs?.Find(_joueur.Id);
+                if (entity!=null)
+                {
+                    entity.Pseudo = _joueur.Pseudo;
+                    result = await context.SaveChangesAsync() > 0;
+                }
+            }
+            return result;
+        }
+        #endregion
+
+    }
+}

Sources/BowlingMaping/PartieDbDataManager.cs

@@ -0,0 +1,166 @@
+using BowlingEF.Context;
+using BowlingEF.Entities;
+using BowlingLib.Model;
+using Business;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BowlingMaping
+{
+    /// <summary>
+    /// Classe de gestion des données des parties
+    /// </summary>
+    public class PartieDbDataManager : IPartieDbDataManager
+    {
+        #region Méthodes
+        /// <summary>
+        /// Ajoute une partie Dans la base de données
+        /// </summary>
+        /// <param name="_partie"></param>
+        /// <returns></returns>
+        public async Task<bool> Add(Partie _partie)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                PartieEntity entity = new PartieEntity
+                {
+                    Id = _partie.Id,
+                    Date = _partie.Date,
+                    Score = _partie.Score
+                };
+                context.Parties.Add(entity);
+                try
+                {
+                    var data = await context.SaveChangesAsync();
+                    result = data == 1;
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine(ex);
+                    throw;
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Supprime une partie de la base de données
+        /// </summary>
+        /// <param name="_partie"></param>
+        /// <returns></returns>
+        public async Task<bool> Delete(Partie _partie)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                PartieEntity entity = context.Parties.Find(_partie.Id);
+                context.Parties.Remove(entity);
+                result = await context.SaveChangesAsync() == 1;
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Modifie une partie dans la base de données
+        /// </summary>
+        /// <param name="_partie"></param>
+        /// <returns></returns>
+        public async Task<bool> Update(Partie _partie)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                PartieEntity entity = context.Parties.Find(_partie.Id);
+                entity.Date = _partie.Date;
+                //entity.JoueurId = _partie.Joueur.Id;
+                entity.Score = _partie.Score;
+                result =await context.SaveChangesAsync() == 1;
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Retourne une partie de la base de données en fonction de son nom
+        /// </summary>
+        /// <param name="_partie"></param>
+        /// <returns></returns>
+        public async Task<Partie> GetDataWithName(string name)
+        {
+            Partie result = null;
+            using (var context = new BowlingContext())
+            {
+                PartieEntity entity = await context.Parties.FindAsync(name);
+                Joueur joueur = new Joueur(entity.Joueur.Id, entity.Joueur.Pseudo);
+                List<Frame> frames = new List<Frame>();
+                foreach (FrameEntity frameEntity in entity.Frames)
+                {
+                    Frame frame = new Frame(frameEntity.Id, frameEntity.Numero, frameEntity.Lancer1, frameEntity.Lancer2, frameEntity.Lancer3);
+                    frames.Add(frame);
+                }
+                result = new Partie(entity.Id, joueur, frames, entity.Date, entity.Score);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Retourne Toutes les parties en base de donné
+        /// </summary>
+        /// <returns></returns>
+        public async Task<IEnumerable<Partie>> GetAll()
+        {
+            List<Partie> result = new List<Partie>();
+            using (var context = new BowlingContext())
+            {
+                foreach (PartieEntity entity in await context.Parties.ToListAsync())
+                {
+                    Joueur joueur = new Joueur(entity.Joueur.Id, entity.Joueur.Pseudo);
+                    List<Frame> frames = new List<Frame>();
+                    foreach (FrameEntity frameEntity in entity.Frames)
+                    {
+                        Frame frame = new Frame(frameEntity.Id, frameEntity.Numero, frameEntity.Lancer1, frameEntity.Lancer2, frameEntity.Lancer3);
+                        frames.Add(frame);
+                    }
+                    result.Add(new Partie(entity.Id, joueur, frames, entity.Date, entity.Score));
+                }
+            }
+            return result.OrderBy(item => item.Date);
+        }
+
+        /// <summary>
+        /// Retourne les parties à une date donnée
+        /// </summary>
+        /// <param name="date"></param>
+        /// <returns></returns>
+        public async Task<IEnumerable<Partie>> GetAllWithDate(DateTime date)
+        {
+            List<Partie> result = new List<Partie>();
+            using (var context = new BowlingContext())
+            {
+                var query =  context.Parties.Where(item => item.Date == date);
+                foreach (PartieEntity entity in await context.Parties.ToListAsync())
+                {
+                    if (entity.Date.Date == date.Date)
+                    {
+                        Joueur joueur = new Joueur(entity.Joueur.Id, entity.Joueur.Pseudo);
+                        List<Frame> frames = new List<Frame>();
+                        foreach (FrameEntity frameEntity in entity.Frames)
+                        {
+                            Frame frame = new Frame(frameEntity.Id, frameEntity.Numero, frameEntity.Lancer1, frameEntity.Lancer2, frameEntity.Lancer3);
+                            frames.Add(frame);
+                        }
+                        result.Add(new Partie(entity.Id, joueur, frames, entity.Date, entity.Score));
+                    }
+                }
+            }
+            return result.OrderBy(item => item.Date);
+        }
+        #endregion
+
+    }
+}

Sources/BowlingStub/BowlingStub.csproj

@@ -8,6 +8,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\BowlingLib\BowlingLib.csproj" />
+    <ProjectReference Include="..\Business\Business.csproj" />
   </ItemGroup>
 
 </Project>

Sources/BowlingStub/StubEquipe.cs

@@ -1,49 +1,83 @@
-using BowlingLib.Model;
-using BowlingLib.Interface;
-using System;
-
-public class StubEquipe:IDataManager<Equipe>
-{
-    private List<Equipe> listEquipes = new List<Equipe>();
-    public StubEquipe()
-    {
-    }
-
-    public void Add(Equipe data)
-    {
-        listEquipes.Add(data);
-    }
-
-    public void Delete(Equipe data)
-    {
-        listEquipes.Remove(data);
-    }
-
-    public IEnumerable<Equipe> GetAll(int n = 10, int j = 2)
-    {
-        for (int i = 0; i < n; i++)
-        {
-            this.Add(new Equipe("Equipe " + i + 1));
-
-            for (int k = 0; k < j; k++)
-            {
-                listEquipes.ElementAt(i).AjouterJoueur(new Joueur("Joueur " + i + 1 + "-" + k + 1));
-
-            }
-        }
-        return listEquipes;
-    }
-
-    public IEnumerable<Equipe> GetAll()
-    {
-        return listEquipes;
-    }
-
-    //mise à jour d'une équipe
-    public void Update(Equipe data)
-    {
-        int index = listEquipes.FindIndex(x => x.Id == data.Id);
-        listEquipes[index] = data;
-    }
-
-}
+using BowlingLib.Model;
+using Business;
+using System;
+
+namespace BowlingStub
+{
+    public class StubEquipe : IDataManager<Equipe>
+    {
+        private List<Equipe> listEquipes = new List<Equipe>();
+        public int nbrJ = 10,nbrE = 2;
+        public StubEquipe()
+        {
+            
+        }
+
+        public async Task<bool> Add(Equipe data)
+        {
+            if (data != null)
+            {
+                listEquipes.Add(data);
+                return true;
+            }
+            return false;
+        }
+
+        public async Task<bool> Delete(Equipe data)
+        {
+            if (data != null)
+            {
+                listEquipes.Remove(data);
+                return true;
+            }
+            return false;
+        }
+
+        public void Load()
+        {
+            for (int i = 0; i < nbrE; i++)
+            {
+                this.Add(new Equipe("Equipe " + i + 1));
+
+                for (int k = 0; k < nbrJ; k++)
+                {
+                    listEquipes.ElementAt(i).AjouterJoueur(new Joueur("Joueur " + i + 1 + "-" + k + 1));
+
+                }
+            }
+        }
+        
+
+        public async Task<IEnumerable<Equipe>>  GetAll()
+        {
+            Load();
+            return listEquipes;
+        }
+
+
+        //mise à jour d'une équipe
+        public async Task<bool> Update(Equipe data)
+        {
+            if (data != null)
+            {
+                int index = listEquipes.FindIndex(x => x.Id == data.Id);
+                listEquipes[index] = data;
+                return true;
+            }
+            return false;
+
+
+        }
+        
+
+        public async Task<Equipe>  GetDataWithName(string name)
+        {
+            throw new NotImplementedException();
+        }
+
+        public async Task<IEnumerable<Equipe>> GetAllWithDate(DateTime date)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Sources/BowlingStub/StubJoueur.cs

@@ -1,41 +1,70 @@
-using BowlingLib.Model;
-using BowlingLib.Interface;
-using System;
-
-public class StubJoueur : IDataManager<Joueur>
-
-{
-    private List<Joueur> listJoueurs = new List<Joueur>();
-    
-
-    public void Add(Joueur data)
-    {
-        listJoueurs.Add(data);
-    }
-
-    public void Delete(Joueur data)
-    {
-        listJoueurs.Remove(data);
-    }
-
-    public IEnumerable<Joueur> GetAll()
-    {
-        return listJoueurs;
-    }
-
-    public IEnumerable<Joueur> GetAll(int n=10, int j=0)
-    {
-        for (int i = 0; i < n; i++)
-        {
-            Add(new Joueur("Joueur " + i + 1));
-        }
-        return listJoueurs;
-    }
-
-    public void Update(Joueur data)
-    {
-        int index = listJoueurs.FindIndex(x => x.Id == data.Id);
-        listJoueurs[index] = data;
-    }
-
-}
+using BowlingLib.Model;
+using Business;
+using System;
+
+namespace BowlingStub
+{
+    public class StubJoueur : IDataManager<Joueur>
+
+    {
+        private List<Joueur> listJoueurs = new List<Joueur>();
+
+
+        public async Task<bool> Add(Joueur data)
+        {
+            if (data != null)
+            {
+                listJoueurs.Add(data);
+                return true;
+            }
+            return false;
+        }
+
+        public async Task<bool> Delete(Joueur data)
+        {
+            if (data != null)
+            {
+                listJoueurs.Remove(data);
+                return  true;
+            }
+            return false;
+        }
+
+        public async Task<IEnumerable<Joueur>> GetAll()
+        {
+            return listJoueurs;
+        }
+        //n represente le nbr de joueurs a creer dans la liste
+        public async Task<IEnumerable<Joueur> >GetAllJoueur(int n = 10)
+        {
+            for (int i = 0; i < n; i++)
+            {
+                Add(new Joueur("Joueur " + i + 1));
+            }
+            return listJoueurs;
+        }
+        ///ged 
+        public async Task<Joueur >GetDataWithId (int id)
+        {
+            throw new NotImplementedException();
+        }
+
+        public async Task<Joueur> GetDataWithName(string name)
+        {
+            throw new NotImplementedException();
+        }//
+
+        public async Task<bool> Update(Joueur data)
+        {
+            if (data != null)
+            {
+
+                int index = listJoueurs.FindIndex(x => x.Id == data.Id);
+                listJoueurs[index] = data;
+                return true;
+            }
+            return false;
+        }
+
+    }
+}

Sources/BowlingStub/StubManager.cs

@@ -1,27 +0,0 @@
-using BowlingLib.Model;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BowlingStub
-{
-    internal class StubManager
-    {
-        private List<Joueur> lesjoueurs = new List<Joueur>();
-        private List<Partie> parties = new List<Partie>();
-        private List<Equipe> equipes = new List<Equipe>();
-
-        public void Add(Manager data)
-        {
-            
-        }
-
-        public void Delete(Manager data)
-        {
-            
-        }
-
-    }
-}

Sources/BowlingStub/StubPartie.cs

@@ -1,5 +1,5 @@
 using BowlingLib.Model;
-using BowlingLib.Interface;
+using Business;
 
 namespace BowlingStub
 {
@@ -7,22 +7,32 @@ namespace BowlingStub
     {
         private List<Partie> listParties = new List<Partie>();
        
-        public void Add(Partie data)
+        public async Task<bool> Add(Partie data)
         {
-            listParties.Add(data);
+            if (data != null)
+            {
+                listParties.Add(data);
+                return true;
+            }
+            return false;
         }
 
-        public void Delete(Partie data)
+        public async Task<bool> Delete(Partie data)
         {
-            listParties.Remove(data);
+            if (data != null)
+            {
+                listParties.Remove(data);
+                return true;
+            }
+            return false;
         }
 
-        public IEnumerable<Partie> GetAll()
+        public async Task<IEnumerable<Partie>> GetAll()
         {
             return listParties;
         }
 
-        public IEnumerable<Partie> GetAll(int n=10, int j=0)
+        public IEnumerable<Partie> GetAllPartie(int n=10, int j=0)
         {
             for (int i = 0; i < n; i++)
             {
@@ -30,11 +40,27 @@ namespace BowlingStub
             }
             return listParties;
         }
+        //GDW?
+
+        public async Task<Partie> GetDataWithId(int id)
+        {
+            throw new NotImplementedException();
+        }
 
-        public void Update(Partie data)
+        public async Task<Partie> GetDataWithName(string name)
         {
-            int index = listParties.FindIndex(x => x.Id == data.Id);
-            listParties[index] = data;
+            throw new NotImplementedException();
+        }
+
+        public async Task<bool> Update(Partie data)
+        {
+            if (data != null)
+            {
+
+                int index = listParties. FindIndex(x => x.Id == data.Id);
+                listParties[index] = data;
+            }
+            return false;
         }
         
     }

Sources/Business/Business.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\BowlingLib\BowlingLib.csproj" />
+  </ItemGroup>
+
+</Project>

Sources/Business/IDataManager.cs

@@ -0,0 +1,22 @@
+using BowlingLib.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Business
+{
+    /// <summary>
+    /// Interface d'abstraction pour les donné
+    /// </summary>
+    /// <typeparam name="Data"></typeparam>
+    public interface IDataManager<Data>
+    {
+        Task<bool> Add(Data data);
+        Task<bool> Delete(Data data);
+        Task<bool> Update(Data data);
+        Task<Data> GetDataWithName(string name);
+        Task<IEnumerable<Data>> GetAll();
+    }
+}

Sources/Business/IPartieDbDataManager.cs

@@ -0,0 +1,17 @@
+using BowlingLib.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Business
+{
+    /// <summary>
+    /// Classe d'abstraction pour les données de la partie
+    /// </summary>
+    public interface IPartieDbDataManager : IDataManager<Partie>
+    {
+        Task<IEnumerable<Partie>> GetAllWithDate(DateTime date);
+    }
+}

Sources/Business/Manager.cs

@@ -0,0 +1,219 @@
+using BowlingLib.Model;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Business
+{
+    /// <summary>
+    /// Classe pour gerer le jeux
+    /// </summary>
+    public class Manager
+    {
+        #region propriétés
+        public ReadOnlyCollection<Partie> Parties { get; private set; }
+        private readonly List<Partie> parties = new();
+        public ReadOnlyCollection<Equipe> Equipes { get; private set; }
+        private readonly List<Equipe> equipes = new();
+        public ReadOnlyCollection<Joueur> Joueurs { get; private set; }
+        private readonly List<Joueur> joueurs = new();
+        
+
+        public IDataManager<Joueur> JoueurDataManager => joueurDataManager;
+        private readonly IDataManager<Joueur> joueurDataManager;
+        public IDataManager<Partie> PartieDataManager => partieDataManager;
+        private readonly IDataManager<Partie> partieDataManager;
+        public IDataManager<Equipe> EquipeDataManager => equipeDataManager;
+        private readonly IDataManager<Equipe> equipeDataManager;
+        #endregion
+
+        #region Constructeurs
+
+        public Manager(IDataManager<Joueur> joueurManager)
+        {
+            this.joueurDataManager = joueurManager;
+            Joueurs = new ReadOnlyCollection<Joueur>(joueurs);
+
+        }
+
+        public Manager(IDataManager<Partie> partieDataManager)
+        {
+            this.partieDataManager = partieDataManager;
+            Parties = new ReadOnlyCollection<Partie>(parties);
+        }
+        
+        
+        public Manager(IDataManager<Equipe> equipeDataManager)
+        {
+            this.equipeDataManager = equipeDataManager;
+            Equipes = new ReadOnlyCollection<Equipe>(equipes);
+        }
+
+        public Manager(IDataManager<Equipe> equipeDataManager, IDataManager<Partie> partieDataManager, IDataManager<Joueur> joueurManager)
+        {
+            this.equipeDataManager = equipeDataManager;
+            Equipes = new ReadOnlyCollection<Equipe>(equipes);
+            this.partieDataManager = partieDataManager;
+            Parties = new ReadOnlyCollection<Partie>(parties);
+            this.joueurDataManager = joueurManager;
+            Joueurs = new ReadOnlyCollection<Joueur>(joueurs);
+        }
+        #endregion
+
+        #region Methodes
+
+        /// <summary>
+        /// Ajoute un joueur à la liste des joueurs
+        /// </summary>
+        /// <param name="joueur"></param>
+        /// <returns></returns>
+        public Task<bool> AddJoueur(Joueur joueur)
+        {
+            if (joueurDataManager == null)
+            {
+                return Task.FromResult(false);
+            }
+                return joueurDataManager.Add(joueur);
+            
+
+        }
+
+        /// <summary>
+        /// Ajoute une partie à la liste des parties
+        /// </summary>
+        /// <param name="partie"></param>
+        /// <returns></returns>
+        public Task<bool> AddPartie(Partie partie)
+        {
+            if (partieDataManager == null)
+            {
+                return Task.FromResult( false);
+            }
+            return partieDataManager.Add(partie);
+        }
+
+        /// <summary>
+        /// Ajoute une équipe à la liste des équipes
+        /// </summary>
+        /// <param name="equipe"></param>
+        /// <returns></returns>
+        public async Task<bool> AddEquipe(Equipe equipe)
+        {
+            if (equipeDataManager == null)
+            {
+                return false;
+            }
+            return await equipeDataManager.Add(equipe);
+        }
+
+        /// <summary>
+        /// Retourne la liste des joueurs
+        /// </summary>
+        /// <param name="joueur"></param>
+        public async Task<bool> DeleteJoueur(Joueur joueur)
+        {
+            if (joueurDataManager == null)
+            {
+                return false;
+            }
+            return await JoueurDataManager.Delete(joueur);
+        }
+
+        /// <summary>
+        /// Supprime une partie
+        /// </summary>
+        /// <param name="partie"></param>
+        public async Task<bool> DeletePartie(Partie partie)
+        {
+            if (partieDataManager == null)
+            {
+                return false;
+            }
+            return await partieDataManager.Delete(partie);
+        }
+
+        /// <summary>
+        /// Supprime une équipe
+        /// </summary>
+        /// <param name="equipe"></param>
+        public async Task<bool> DeleteEquipe(Equipe equipe)
+        {
+            if (equipeDataManager == null)
+            {
+                return false;
+            }
+            return await equipeDataManager.Delete(equipe);
+        }
+
+        /// <summary>
+        /// Retourne la liste des joueurs
+        /// </summary>
+        /// <param name="joueur"></param>
+        public async Task<bool> UpdateJoueur(Joueur joueur)
+        {
+            if (joueurDataManager == null)
+            {
+                return false;
+            }
+            return await  JoueurDataManager.Update(joueur);
+        }
+
+        /// <summary>
+        /// Met à jour une partie
+        /// </summary>
+        /// <param name="partie"></param>
+        public async Task<bool> UpdatePartie(Partie partie)
+        {
+            if (partieDataManager == null)
+            {
+                return false;
+            }
+            return await partieDataManager.Update(partie);
+        }
+
+        /// <summary>
+        /// Met à jour une équipe
+        /// </summary>
+        /// <param name="equipe"></param>
+        public async Task<bool> UpdateEquipe(Equipe equipe)
+        {
+            if (equipeDataManager == null)
+            {
+                return false;
+            }
+            return await equipeDataManager.Update(equipe);
+        }
+
+        /// <summary>
+        /// Retourne la liste des joueurs
+        /// </summary>
+        /// <returns></returns>
+        public async Task<IEnumerable<Joueur>> GetAllJoueur()
+        {
+            return await JoueurDataManager.GetAll();
+        }
+
+        /// <summary>
+        /// Retourne les dernières parties du joueur
+        /// </summary>
+        /// <returns></returns>
+        public async Task<IEnumerable<Partie>> GetAllPartie()
+        {
+            return await partieDataManager.GetAll();
+        }
+
+        /// <summary>
+        /// Retourne les Equipe en fonction d'une partie
+        /// </summary>
+        /// <returns></returns>
+        public async Task<IEnumerable<Equipe>> GetAllEquipe()
+        {
+            return await equipeDataManager.GetAll();
+        }
+        #endregion
+
+    }
+}

Sources/Solution.sln

@@ -13,6 +13,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BowlingAppUnitTest", "Tests
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BowlingStub", "BowlingStub\BowlingStub.csproj", "{B50615A5-ABFD-4A9C-B236-DBAEDE62AB2E}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Business", "Business\Business.csproj", "{4F0C1B08-1DB7-4424-9521-EB13A858D09B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BowlingEF", "BowlingEF\BowlingEF.csproj", "{1E42224B-45E4-433C-9D20-0A61023790ED}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BowlingMaping", "BowlingMaping\BowlingMaping.csproj", "{874DDEF3-1FDA-4ECE-826F-F67143823544}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -35,6 +41,18 @@ Global
 		{B50615A5-ABFD-4A9C-B236-DBAEDE62AB2E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B50615A5-ABFD-4A9C-B236-DBAEDE62AB2E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B50615A5-ABFD-4A9C-B236-DBAEDE62AB2E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4F0C1B08-1DB7-4424-9521-EB13A858D09B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4F0C1B08-1DB7-4424-9521-EB13A858D09B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4F0C1B08-1DB7-4424-9521-EB13A858D09B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4F0C1B08-1DB7-4424-9521-EB13A858D09B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1E42224B-45E4-433C-9D20-0A61023790ED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1E42224B-45E4-433C-9D20-0A61023790ED}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1E42224B-45E4-433C-9D20-0A61023790ED}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1E42224B-45E4-433C-9D20-0A61023790ED}.Release|Any CPU.Build.0 = Release|Any CPU
+		{874DDEF3-1FDA-4ECE-826F-F67143823544}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{874DDEF3-1FDA-4ECE-826F-F67143823544}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{874DDEF3-1FDA-4ECE-826F-F67143823544}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{874DDEF3-1FDA-4ECE-826F-F67143823544}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Sources/Tests/BowlingAppUnitTest/BowlingAppUnitTest.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FsCheck" Version="2.16.5" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.1" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">

Sources/Tests/BowlingAppUnitTest/TestData.cs

@@ -0,0 +1,86 @@
+using BowlingLib.Model;
+using System;
+using System.Collections.Generic;
+
+namespace Test.BowlingAppUnitTest
+{
+    public static class TestData
+    {
+        public static IEnumerable<object[]> Data_AddJoueurToEquipe()
+        {
+            yield return new object[]
+            {
+                1,
+                new Joueur[]
+                {
+                    new Joueur("Alys"),
+                    new Joueur("Bénita"),
+                    new Joueur("Regis"),
+                    new Joueur("Mania"),
+                    new Joueur("Augustin")
+                },
+                new Joueur[]
+                {
+                    new Joueur("Augustin")
+                },
+                 new Equipe("ABRMC",
+                    new Joueur("Alys"),
+                    new Joueur("Bénita"),
+                    new Joueur("Regis"),
+                    new Joueur("Mania")),
+                    new Joueur("Augustin")
+            };
+
+            yield return new object[]
+            {
+                2,
+                new Joueur[]
+                {
+                    new Joueur("Alys"),
+                    new Joueur("Bénita"),
+                    new Joueur("Regis"),
+                    new Joueur("Mania"),
+                    new Joueur("Augustin")
+                },
+                new Joueur[]
+                {
+                    new Joueur("Mania"),
+                    new Joueur("Augustin")
+                },
+                new Equipe("ABRMC",
+                    new Joueur("Alys"),
+                    new Joueur("Bénita"),
+                    new Joueur("Regis")),
+
+                    
+                    new Joueur("Mania"),
+                    new Joueur("Alys"),
+                    new Joueur("Augustin")
+            };
+
+            yield return new object[]
+            {
+                1,
+                new Joueur[]
+                {
+                    new Joueur("Alys"),
+                    new Joueur("Bénita"),
+                    new Joueur("Regis"),
+                    new Joueur("Mania"),
+                    new Joueur("Augustin")
+                },
+                new Joueur[]
+                {
+                    new Joueur("Augustin")
+                },
+                new Equipe("ABRMC",
+                    new Joueur("Alys"),
+                    new Joueur("Bénita"),
+                    new Joueur("Regis"),
+                    new Joueur("Mania")),
+                new Joueur("Augustin"),
+                new Joueur("Augustin")
+            };
+        }
+    }
+}

Sources/Tests/BowlingAppUnitTest/UTFrame.cs

@@ -0,0 +1,104 @@
+using BowlingLib.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace BowlingAppUnitTest
+{
+    public class UTFrame
+    {
+        [Fact]
+        public void TestFrame()
+        {
+            Frame frame = new Frame(1);
+            Assert.Equal(1, frame.Numero);
+            Assert.Equal(10, frame.QuillesRestantes);
+            Assert.Equal(0, frame.QuillesTombees);
+            Assert.False(frame.IsStrike);
+            Assert.False(frame.IsSpare);
+        }
+
+        [Fact]
+        public void TestLancer()
+        {
+            Frame frame = new Frame(1);
+            frame.Lancer(5);
+            Assert.Equal(5, frame.QuillesTombees);
+            Assert.Equal(5, frame.QuillesRestantes);
+            Assert.False(frame.IsStrike);
+            Assert.False(frame.IsSpare);
+        }
+
+        [Fact]
+        public void TestLancer2()
+        {
+            Frame frame = new Frame(1);
+            frame.Lancer(10);
+            Assert.Equal(10, frame.QuillesTombees);
+            Assert.Equal(0, frame.QuillesRestantes);
+            Assert.True(frame.IsStrike);
+            Assert.False(frame.IsSpare);
+        }
+
+        [Fact]
+        public void TestLancer3()
+        {
+            Frame frame = new Frame(1);
+            frame.Lancer(5);
+            frame.Lancer(5);
+            Assert.Equal(10, frame.QuillesTombees);
+            Assert.Equal(0, frame.QuillesRestantes);
+            Assert.False(frame.IsStrike);
+            Assert.True(frame.IsSpare);
+        }
+
+        //test Avec un lancé négatif
+        [Fact]
+        public void TestLancer4()
+        {
+            Frame frame = new Frame(1);
+            Assert.Throws<ArgumentException>(() => frame.Lancer(-5));
+        }
+
+        //test Avec un lancé supérieur à 10
+        [Fact]
+        public void TestLancer5()
+        {
+            Frame frame = new Frame(1);
+            Assert.Throws<ArgumentException>(() => frame.Lancer(15));
+        }
+
+        //test avec le deuxième lancé du dernier frame est un strike
+        [Fact]
+        public void TestLancer6()
+        {
+            Frame frame = new Frame(10);
+            frame.Lancer(0);
+            frame.Lancer(10);
+            Assert.False(frame.IsStrike);
+        }
+
+        //test avec le deuxième lancé du dernier frame est un spare
+        [Fact]
+        public void TestLancer7()
+        {
+            Frame frame = new Frame(10);
+            frame.Lancer(5);
+            frame.Lancer(5);
+            Assert.True(frame.IsSpare);
+        }
+
+        //[Fact]
+        //public void TestLancer8()
+        //{
+        //    Frame frame = new Frame(10);
+        //    frame.Lancer(0);
+        //    frame.Lancer(10);
+        //    frame.Lancer(10);
+        //    Assert.True(frame.IsStrike);
+        //}
+    }
+}

Sources/Tests/BowlingAppUnitTest/UTManager.cs

@@ -1,5 +1,6 @@
 using BowlingLib.Model;
 using BowlingStub;
+using Business;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -23,7 +24,7 @@ namespace BowlingAppUnitTest
             manager.AddJoueur(joueur);
 
             //Assert
-            Assert.Single(manager.joueurManager.GetAll());
+            Assert.Single(manager.JoueurDataManager.GetAll().Result);
         }
 
         //Test de la méthode AddPartie
@@ -38,25 +39,9 @@ namespace BowlingAppUnitTest
             manager.AddPartie(partie);
 
             //Assert
-            Assert.Single(manager.partieManager.GetAll());
+            Assert.Single(manager.PartieDataManager.GetAll().Result);
         }
 
-        //Test de la méthode AddEquipe
-        //[Fact]
-
-        //public void TestAddEquipe() //Test de la méthode AddEquipe
-        //{
-        //    //Arrange
-        //    Equipe equipe = new Equipe("Equipe 1");
-        //    Manager manager = new Manager(new StubEquipe());
-
-        //    //Act
-        //    manager.AddEquipe(equipe);
-
-        //    //Assert
-        //    Assert.Single(manager.equipeManager.GetAll());
-        //}
-
 
     }
 }

Sources/Tests/BowlingAppUnitTest/UTPartie.cs

@@ -17,7 +17,7 @@ namespace BowlingAppUnitTest
         {
             //Arrange
             StubPartie stubPartie = new StubPartie();
-            IEnumerable<Partie> listParties = stubPartie.GetAll(1);
+            IEnumerable<Partie> listParties = stubPartie.GetAllPartie(1);
             Partie partie = listParties.ElementAt(0);
             partie.AddFrame(new Frame(1));
             partie.AddFrame(new Frame(2));
@@ -29,11 +29,14 @@ namespace BowlingAppUnitTest
             partie.AddFrame(new Frame(8));
             partie.AddFrame(new Frame(9));
             partie.AddFrame(new Frame(10));
-            partie.AddFrame(new Frame(11));
 
             for (int i = 0; i < partie.Frames.Count; i++)
             {
                 partie.Frames[i].Lancer(10);
+                if (i==9)
+                {
+                    partie.Frames[i].Lancer(10);
+                }
             }
 
             //Act
@@ -51,7 +54,7 @@ namespace BowlingAppUnitTest
         {
             //Arrange
             StubPartie stubPartie = new StubPartie();
-            IEnumerable<Partie> listParties = stubPartie.GetAll(1);
+            IEnumerable<Partie> listParties = stubPartie.GetAllPartie(1);
             Partie partie = listParties.ElementAt(0);
             partie.AddFrame(new Frame(1));
             partie.AddFrame(new Frame(2));
@@ -90,7 +93,7 @@ namespace BowlingAppUnitTest
         {
             //Arrange
             StubPartie stubPartie = new StubPartie();
-            IEnumerable<Partie> listParties = stubPartie.GetAll(1);
+            IEnumerable<Partie> listParties = stubPartie.GetAllPartie(1);
             Partie partie = listParties.ElementAt(0);
             partie.AddFrame(new Frame(1));
             partie.AddFrame(new Frame(2));
@@ -135,7 +138,7 @@ namespace BowlingAppUnitTest
         {
             //Arrange
             StubPartie stubPartie = new StubPartie();
-            IEnumerable<Partie> listParties = stubPartie.GetAll(1);
+            IEnumerable<Partie> listParties = stubPartie.GetAllPartie(1);
             Partie partie = listParties.ElementAt(0);
             partie.AddFrame(new Frame(1));
             partie.AddFrame(new Frame(2));
@@ -160,5 +163,127 @@ namespace BowlingAppUnitTest
             //Assert
             Assert.Equal(90, score);
         }
+
+        //le cas ou le joueur fait un strike au dernier lancer
+
+        [Fact]
+
+        public void TestGetScore5()
+        {
+            //Arrange
+            StubPartie stubPartie = new StubPartie();
+            IEnumerable<Partie> listParties = stubPartie.GetAllPartie(1);
+            Partie partie = listParties.ElementAt(0);
+            partie.AddFrame(new Frame(1));
+            partie.AddFrame(new Frame(2));
+            partie.AddFrame(new Frame(3));
+            partie.AddFrame(new Frame(4));
+            partie.AddFrame(new Frame(5));
+            partie.AddFrame(new Frame(6));
+            partie.AddFrame(new Frame(7));
+            partie.AddFrame(new Frame(8));
+            partie.AddFrame(new Frame(9));
+            partie.AddFrame(new Frame(10));
+
+            for (int i = 0; i < partie.Frames.Count; i++)
+            {
+                if (i < 9)
+                {
+                    partie.Frames[i].Lancer(5);
+                    partie.Frames[i].Lancer(4);
+                    continue;
+                }
+                partie.Frames[i].Lancer(10);
+                if (partie.Frames[i].IsStrike)
+                {
+                    partie.Frames[i].Lancer(5);
+                    partie.Frames[i].Lancer(4);
+                }
+            }
+
+            //Act
+            int? score = partie.GetScore();
+
+            //Assert
+            Assert.Equal(100, score);
+        }
+
+        //le cas ou le joueur fait un spare au deuxieme lancer du dernier frame
+
+        [Fact]
+
+        public void TestGetScore6()
+        {
+            //Arrange
+            StubPartie stubPartie = new StubPartie();
+            IEnumerable<Partie> listParties = stubPartie.GetAllPartie(1);
+            Partie partie = listParties.ElementAt(0);
+            partie.AddFrame(new Frame(1));
+            partie.AddFrame(new Frame(2));
+            partie.AddFrame(new Frame(3));
+            partie.AddFrame(new Frame(4));
+            partie.AddFrame(new Frame(5));
+            partie.AddFrame(new Frame(6));
+            partie.AddFrame(new Frame(7));
+            partie.AddFrame(new Frame(8));
+            partie.AddFrame(new Frame(9));
+            partie.AddFrame(new Frame(10));
+
+            for (int i = 0; i < partie.Frames.Count; i++)
+            {
+                if (i < 9)
+                {
+                    partie.Frames[i].Lancer(5);
+                    partie.Frames[i].Lancer(4);
+                    continue;
+                }
+                partie.Frames[i].Lancer(5);
+                partie.Frames[i].Lancer(5);
+                if (partie.Frames[i].IsSpare)
+                {
+                    partie.Frames[i].Lancer(5);
+                }
+            }
+
+            //Act
+            int? score = partie.GetScore();
+
+            //Assert
+            Assert.Equal(96, score);
+        }
+
+        //le cas ou le nombre de lancer est atteind 2 eme frames
+
+        [Fact]
+
+        public void TestGetScore7()
+        {
+            //Arrange
+            StubPartie stubPartie = new StubPartie();
+            IEnumerable<Partie> listParties = stubPartie.GetAllPartie(1);
+            Partie partie = listParties.ElementAt(0);
+            partie.AddFrame(new Frame(1));
+            
+            partie.Frames[0].Lancer(5);
+            partie.Frames[0].Lancer(5);
+            Assert.Throws<ArgumentException>
+                (() => partie.Frames[0].Lancer(5));
+        }
+
+        //le cas ou les lancer sont finis
+
+        [Fact]
+
+        public void TestGetScore8()
+        {
+            //Arrange
+            StubPartie stubPartie = new StubPartie();
+            IEnumerable<Partie> listParties = stubPartie.GetAllPartie(1);
+            Partie partie = listParties.ElementAt(0);
+            partie.AddFrame(new Frame(1));
+            partie.Frames[0].Lancer(5);
+            partie.Frames[0].Lancer(5);
+            Assert.True(partie.Frames[0].IsFinished);
+        }
     }
 }

Sources/Tests/BowlingAppUnitTest/UTestEquipe.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
-using BowlingLib.Model;
+using System.Linq;
+using BowlingLib.Model; 
 using Xunit;
 
 namespace Test.BowlingAppUnitTest
@@ -8,7 +9,7 @@ namespace Test.BowlingAppUnitTest
     public class UnitTestEquipe
     {
 
-        public static IEnumerable<object[]> Data_AddJoueurToEquipe()
+        public static IEnumerable<object[]>  Data_AddJoueurToEquipe()
         {
             yield return new object[]
             {
@@ -52,16 +53,38 @@ namespace Test.BowlingAppUnitTest
         [Theory]
         [MemberData(nameof(Data_AddJoueurToEquipe))]
         public void Test_AddJoueurToEquipe(bool expectedResult,
-                                          Joueur[] expectedJoueurs,
+                                          IEnumerable<Joueur> expectedJoueurs,
                                           Equipe equipe,
                                           Joueur joueur)
         {
              
             bool result = equipe.AjouterJoueur(joueur);
             Assert.Equal(expectedResult, result);
-            Assert.Equal(expectedJoueurs.Length, equipe.GetJoueurs().Count);
+            
+            Assert.Equal(expectedJoueurs.Count(), equipe.Joueurs.Count());
             Assert.All(expectedJoueurs, j => equipe.Joueurs.Contains(j));
+
+           
+        }
+
+
+        [Theory]
+        [MemberData(nameof(TestData.Data_AddJoueurToEquipe), MemberType=typeof(TestData))]
+        public void Test_AddJoueursToEquipe(int expectedResult,
+                                   IEnumerable<Joueur> expectedJoueurs,
+                                   IEnumerable<Joueur> expectedAddedJoueurs,
+                                   Equipe equipe,
+                                   params Joueur[] joueursToAdd)
+        {
+            var addedJoueurs = equipe.AjouterJoueurs(joueursToAdd);
+            Assert.Equal(expectedResult, addedJoueurs.Count());
+
+            Assert.All(expectedAddedJoueurs, a => addedJoueurs.Contains(a));
+
+            Assert.Equal(expectedJoueurs.Count(), equipe.Joueurs.Count());
+            Assert.All(expectedJoueurs, a => equipe.Joueurs.Contains(a));
         }
 
+
     }
 }

Sources/Tests/BowlingAppUnitTest/UnitTestJoueur.cs

@@ -1,108 +1,116 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using BowlingLib.Model;
-using Xunit;
-
-namespace Test.BowlingAppUnitTest
-{
-    public class UnitTestJoueur
-    {
-        Joueur j = new Joueur("Paul");
-        [Fact]
-        public void TestConstructeur()
-        {
-            Assert.NotNull(j);
-            Assert.Equal("Paul", j.Pseudo);
-            Assert.NotEqual("joel", j.Pseudo);
-        }
-
-        [Fact]
-        public void TestInvalidJoueur()
-        {
-            Assert.Throws<ArgumentException>(() => new Joueur(null));
-        }
-        
-        [Theory]
-        [InlineData(true, false, "Augustin", "Augustinn", false)]
-        [InlineData(true, true, "Amir", "Amir", true)]
-        [InlineData(false, false, "Amir", "", false)]
-        [InlineData(false, false, "Amir", null, false)]
-        [InlineData(false, false, null, null, true)]
-        [InlineData(false, false, null, "", false)]
-        [InlineData(false, false, "", null, false)]
-        [InlineData(false, false, "", "", true)]
-        [InlineData(false, false, "f2", "f2", true)]
-        public void TestContructeur(bool isFormated, bool isValid, string expectedPseudo, String pseudo, bool isEqual)
-        {
-            if (!isValid && !isFormated)
-            {
-                Assert.Throws<ArgumentException>(
-                    () => new Joueur(pseudo)
-                    );
-                return;
-            }
-
-            Joueur j = new Joueur(pseudo);
-
-
-            if (!isEqual)
-            {
-                Assert.NotEqual(expectedPseudo, j.Pseudo);
-
-            }
-            else
-            {
-
-
-                if (!isEqual)
-                {
-                    Assert.NotEqual(expectedPseudo, j.Pseudo);
-
-                }
-                else
-                {
-                    Assert.Equal(expectedPseudo, j.Pseudo);
-
-                }
-
-
-            }
-
-        }
-
-        //Test joueur avec stub
-        [Fact]
-        public void TestJoueurStub()
-        {
-            StubJoueur stub = new StubJoueur();
-            Assert.Equal(10, stub.GetAll(10).Count());
-        }
-
-
-        //tester la methode remove
-        [Fact]
-        public void TestRemove()
-        {
-            StubJoueur stub = new StubJoueur();
-            stub.Add(j);
-            stub.Delete(j);
-            //Compter le nombre de joueur dans un objet IEnumerable
-            Assert.Equal(0, stub.GetAll().Count());
-        }
-
-        //tester la methode update avec les members Data
-        [Fact]
-        public void TestUpdate()
-        {
-            StubJoueur stub = new StubJoueur();
-            Joueur j = new Joueur("Paul");
-            stub.Add(j);
-            j.Pseudo = "Augustin";
-            stub.Update(j);
-            Assert.Equal("Augustin", stub.GetAll().First().Pseudo);
-        }
-        
-
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using BowlingLib.Model;
+using BowlingStub;
+using Xunit;
+
+namespace Test.BowlingAppUnitTest
+{
+    public class UnitTestJoueur
+    {
+        Joueur j = new Joueur("Paul");
+        [Fact]
+        public void TestConstructeur()
+        {
+            Assert.NotNull(j);
+            Assert.Equal("Paul", j.Pseudo);
+            Assert.NotEqual("joel", j.Pseudo);
+        }
+        //si l text n est
+
+        [Fact]
+        public void TestInvalidJoueur()
+        {
+            Assert.Throws<ArgumentException>(() => new Joueur(null));
+        }
+        //
+        [Theory]
+        [InlineData(true, false, "Augustin", "Augustinn", false)]
+        [InlineData(true, true, "Amir", "Amir", true)]
+        [InlineData(false, false, "Amir", "", false)]
+        [InlineData(false, false, "Amir", null, false)]
+        [InlineData(false, false, null, null, true)]
+        [InlineData(false, false, null, "", false)]
+        [InlineData(false, false, "", null, false)]
+        [InlineData(false, false, "", "", true)]
+        [InlineData(false, false, "f2", "f2", true)]
+        public void TestContructeur(bool isFormated, bool isValid, string expectedPseudo, String pseudo, bool isEqual)
+        {// formated:
+            if (!isValid && !isFormated)
+            {
+                Assert.Throws<ArgumentException>
+                    (
+                    () => new Joueur(pseudo)
+                    );
+                return;
+            }
+
+            Joueur j = new Joueur(pseudo);
+
+
+            if (!isEqual)
+            {
+                Assert.NotEqual(expectedPseudo, j.Pseudo);
+
+            }
+            // else
+            // {
+
+
+            // if (!isEqual)
+            // {
+            //   Assert.NotEqual(expectedPseudo, j.Pseudo);
+
+            //  }
+            if (isEqual)
+            {
+                Assert.Equal(expectedPseudo, j.Pseudo);
+
+            }
+
+
+        }
+
+        //Test joueur avec stub 
+        [Fact]
+        public void TestJoueurStub()
+        {
+            StubJoueur stub = new StubJoueur();
+            Assert.Equal(10, stub.GetAllJoueur(10).Result.Count());
+        }
+
+
+        //tester la methode remove
+        [Fact]
+        public void TestRemove()
+        {
+            StubJoueur stub = new StubJoueur();
+            stub.Add(j);
+            stub.Delete(j);
+            //Compter le nombre de joueur dans un objet IEnumerable
+            Assert.Equal(0, stub.GetAll().Result.Count());
+        }
+
+
+        /*
+         * TEST AVEC LE STUB
+         */
+
+        [Fact]
+        public void TestUpdate()
+        {
+            StubJoueur stub = new StubJoueur();
+            Joueur j = new Joueur("Paul");
+            stub.Add(j);
+            j.setNom("Augustin");
+            stub.Update(j);
+            Assert.Equal("Augustin", stub.GetAll().Result.First().Pseudo);
+        }
+
+
+
+
+    }
+}
+

Sources/Tests/BowlingEFunitTest/BowlingEFunitTest.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.1.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

Sources/Tests/BowlingEFunitTest/UnitTest1.cs

@@ -0,0 +1,11 @@
+namespace BowlingEFunitTest
+{
+    public class UnitTest1
+    {
+        [Fact]
+        public void Test1()
+        {
+
+        }
+    }
+}

Sources/Tests/BowlingEFunitTest/UnittestEfjoueur.cs

@@ -4,9 +4,9 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace BowlingLib.Model
+namespace BowlingEFunitTest
 {
-    internal class FacadeManager
+    internal class unittestEfjoueur
     {
     }
 }

Sources/Tests/BowlingEFunitTest/Usings.cs

@@ -0,0 +1 @@
+global using Xunit;