ajout des data managers et service managers

WebApi/DataManagers/AnswerDataManager.cs

@@ -0,0 +1,80 @@
+using DbConnectionLibrairie;
+using EntityManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataManagers
+{
+    public class AnswerDataManager(MyDbContext dbContext) : IAnswerManager<Answer>
+    {
+
+        private AnswerEntityManager manager = new AnswerEntityManager(dbContext);
+
+        public async Task<Answer> addAnswer(Answer answer)
+        {
+            return await Task.FromResult<Answer>((await manager.addAnswer(answer.ToEntity())).ToModel());
+        }
+
+        public async Task<Answer?> getAnswer(uint id)
+        {
+            return await Task.FromResult<Answer?>((await manager.getAnswer(id))?.ToModel());
+        }
+
+        public async Task<(int nbPages, IEnumerable<Answer>? answers)> getAnswers(int nb, int count, AnswerOrderCriteria orderCriteria = AnswerOrderCriteria.ById)
+        {
+            List<Answer>? tmp = new List<Answer>();
+            var res = await manager.getAnswers(nb, count, orderCriteria);
+            if (res.answers == null) tmp = null;
+            else
+            {
+                foreach (var item in res.answers)
+                {
+                    tmp.Add(item.ToModel());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<Answer>? answers)>((res.nbPages, tmp));
+        }
+
+        public async Task<IEnumerable<Answer>?> getAnswersByIdQuestion(uint id)
+        {
+            var tmp = await manager.getAnswersByIdQuestion(id);
+            List<Answer>? answer = new List<Answer>();
+            if (tmp == null) answer = null;
+            else
+            {
+                foreach (var item in tmp)
+                {
+                    answer.Add(item.ToModel());
+                }
+            }
+            return await Task.FromResult<List<Answer>?>(answer);
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<Answer?> removeAnswer(uint id)
+        {
+            return (await manager.removeAnswer(id))?.ToModel();
+        }
+
+        public async Task<Answer?> removeAnswer(Answer answer)
+        {
+            return (await manager.removeAnswer(answer.ToEntity()))?.ToModel();
+        }
+
+        public async Task<Answer?> updateAnswer(uint id, Answer answer)
+        {
+            return (await manager.updateAnswer(id, answer.ToEntity()))?.ToModel();
+        }
+    }
+}

WebApi/DataManagers/ChapterDataManager.cs

@@ -0,0 +1,59 @@
+using DbConnectionLibrairie;
+using EntityManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataManagers
+{
+    public class ChapterDataManager(MyDbContext dbContext) : IChapterManager<Chapter>
+    {
+        private ChapterEntityManager manager = new ChapterEntityManager(dbContext);
+        
+        public async Task<Chapter> addChapter(Chapter chapter)
+        {
+            return await Task.FromResult<Chapter>((await manager.addChapter(chapter.ToEntity())).ToModel());
+        }
+
+        public async Task<Chapter?> getChapter(uint id)
+        {
+            return await Task.FromResult<Chapter?>((await manager.getChapter(id))?.ToModel());
+        }
+
+        public async Task<(int nbPages, IEnumerable<Chapter>? chapters)> getChapters(int nb, int count, ChapterOrderCriteria orderCriteria = ChapterOrderCriteria.ById)
+        {
+            List<Chapter>? tmp = new List<Chapter>();
+            var res = await manager.getChapters(nb, count, orderCriteria);
+            if (res.chapters == null) tmp = null;
+            else
+            {
+                foreach (var item in res.chapters)
+                {
+                    tmp.Add(item.ToModel());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<Chapter>? chapters)>((res.nbPages, tmp));
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<Chapter?> removeChapter(Chapter chapter)
+        {
+            return (await manager.removeChapter(chapter.ToEntity()))?.ToModel();
+        }
+
+        public async Task<Chapter?> removeChapter(uint id)
+        {
+            return (await manager.removeChapter(id))?.ToModel();
+        }
+    }
+}

WebApi/DataManagers/DataManagers.csproj

@@ -8,7 +8,9 @@
 
   <ItemGroup>
     <ProjectReference Include="..\DbConnectionLibrairie\DbConnectionLibrairie.csproj" />
+    <ProjectReference Include="..\Entities\Entities.csproj" />
     <ProjectReference Include="..\EntityManagers\EntityManagers.csproj" />
+    <ProjectReference Include="..\ExtensionsClassLibrairie\ExtensionsClassLibrairie.csproj" />
     <ProjectReference Include="..\ManagerInterfaces\ManagerInterfaces.csproj" />
     <ProjectReference Include="..\Model\Model.csproj" />
   </ItemGroup>

WebApi/DataManagers/LobbyDataManager.cs

@@ -0,0 +1,59 @@
+using DbConnectionLibrairie;
+using EntityManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataManagers
+{
+    public class LobbyDataManager(MyDbContext dbContext) : ILobbyManager<Lobby>
+    {
+        private LobbyEntityManager manager = new LobbyEntityManager(dbContext);
+
+        public async Task<Lobby> addLobby(Lobby lobby)
+        {
+            return await Task.FromResult<Lobby>((await manager.addLobby(lobby.ToEntity())).ToModel());
+        }
+
+        public async Task<(int nbPages, IEnumerable<Lobby>? lobbies)> getLobbies(int nb, int count, LobbyOrderCriteria orderCriteria = LobbyOrderCriteria.ById)
+        {
+            List<Lobby>? tmp = new List<Lobby>();
+            var res = await manager.getLobbies(nb, count, orderCriteria);
+            if (res.lobbies == null) tmp = null;
+            else
+            {
+                foreach (var item in res.lobbies)
+                {
+                    tmp.Add(item.ToModel());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<Lobby>? lobbies)>((res.nbPages, tmp));
+        }
+
+        public async Task<Lobby?> getLobby(uint id)
+        {
+            return await Task.FromResult<Lobby?>((await manager.getLobby(id))?.ToModel());
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<Lobby?> removeLobby(Lobby lobby)
+        {
+            return (await manager.removeLobby(lobby.ToEntity()))?.ToModel();
+        }
+
+        public async Task<Lobby?> removeLobby(uint id)
+        {
+            return (await manager.removeLobby(id))?.ToModel();
+        }
+    }
+}

WebApi/DataManagers/PlayerDataManager.cs

@@ -0,0 +1,89 @@
+using DbConnectionLibrairie;
+using EntityManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataManagers
+{
+    public class PlayerDataManager(MyDbContext dbContext) : IPlayerManager<Player>
+    {
+        private PlayerEntityManager manager = new PlayerEntityManager(dbContext);
+
+        public async Task<Player> addPlayer(Player player)
+        {
+            return await Task.FromResult<Player>((await manager.addPlayer(player.ToEntity())).ToModel());
+        }
+
+        public async Task<uint?> getMaxScorePlayer(uint id, uint idChapter)
+        {
+            return await manager.getMaxScorePlayer(id, idChapter);
+        }
+
+        public async Task<uint?> getMaxScorePlayer(uint id)
+        {
+            return await manager.getMaxScorePlayer(id);
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<Player?> getPlayer(uint id)
+        {
+            return await Task.FromResult<Player?>((await manager.getPlayer(id))?.ToModel());
+        }
+
+        public async Task<Player?> getPlayer(string nickname)
+        {
+            return await Task.FromResult<Player?>((await manager.getPlayer(nickname))?.ToModel());
+        }
+
+        public async Task<(int nbPages, IEnumerable<Player>? players)> getPlayers(int nb, int count, PlayerOrderCriteria orderCriteria = PlayerOrderCriteria.ById)
+        {
+            List<Player>? tmp = new List<Player>();
+            var res = await manager.getPlayers(nb, count, orderCriteria);
+            if (res.players == null) tmp = null;
+            else
+            {
+                foreach (var item in res.players)
+                {
+                    tmp.Add(item.ToModel());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<Player>? players)>((res.nbPages, tmp));
+        }
+
+        public async Task<IEnumerable<Player>?> getPlayersInALobby(uint idLobby)
+        {
+            List<Player>? tmp = new List<Player>();
+            var res = await manager.getPlayersInALobby(idLobby);
+            if (res == null) tmp = null;
+            else
+            {
+                foreach (var item in res)
+                {
+                    tmp.Add(item.ToModel());
+                }
+            }
+            return await Task.FromResult<IEnumerable<Player>?>(tmp);
+        }
+
+        public async Task<Player?> removePlayer(Player player)
+        {
+            return (await manager.removePlayer(player.ToEntity()))?.ToModel();
+        }
+
+        public async Task<Player?> removePlayer(uint id)
+        {
+            return (await manager.removePlayer(id))?.ToModel();
+        }
+    }
+}

WebApi/DataManagers/QuestionDataManager.cs

@@ -0,0 +1,103 @@
+using DbConnectionLibrairie;
+using Entities;
+using EntityManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataManagers
+{
+    public class QuestionDataManager(MyDbContext dbContext) : IQuestionManager<Question>
+    {
+
+        private QuestionEntityManager manager = new QuestionEntityManager(dbContext);
+
+        public async Task<Question> addQuestion(Question question)
+        {
+            return await Task.FromResult<Question>((await manager.addQuestion(question.ToEntity())).ToModel());
+        }
+
+        public async Task<IEnumerable<Question>> addQuestions(IEnumerable<Question> questions)
+        {
+            var tmp = new List<QuestionEntity>();
+            foreach (var question in questions)
+            {
+                tmp.Add(question.ToEntity());
+            }
+            var res = await manager.addQuestions(tmp);
+            var tmp2 = new List<Question>();
+            foreach (var item in res)
+            {
+                tmp2.Add(item.ToModel());
+            }
+            return tmp2;
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<Question?> getQuestion(uint id)
+        {
+            return await Task.FromResult<Question?>((await manager.getQuestion(id))?.ToModel());
+        }
+
+        public async Task<(int nbPages, IEnumerable<Question>? questions)> getQuestions(int nb, int count, QuestionOrderCriteria orderCriteria = QuestionOrderCriteria.ById)
+        {
+            List<Question>? tmp = new List<Question>();
+            var res = await manager.getQuestions(nb, count, orderCriteria);
+            if (res.questions == null) tmp = null;
+            else
+            {
+                foreach (var item in res.questions)
+                {
+                    tmp.Add(item.ToModel());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<Question>? questions)>((res.nbPages, tmp));
+        }
+
+        public async Task<(int nbPages, IEnumerable<Question>? questions)?> getQuestionsByChapterAndDifficulty(int idChapter, int difficulty, int nb, int count, QuestionOrderCriteria orderCriteria = QuestionOrderCriteria.ById)
+        {
+            List<Question>? tmp = new List<Question>();
+            var res = await manager.getQuestionsByChapterAndDifficulty(idChapter, difficulty, nb, count, orderCriteria);
+            if (res == null) return await Task.FromResult<(int nbPages, IEnumerable<Question>? questions)?>(null);
+            if (res.Value.questions == null) tmp = null;
+            else
+            {
+                foreach (var item in res.Value.questions)
+                {
+                    tmp.Add(item.ToModel());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<Question>? questions)>((res.Value.nbPages, tmp));
+        }
+
+        public async Task<Question?> removeQuestion(Question question)
+        {
+            return (await manager.removeQuestion(question.ToEntity()))?.ToModel();
+        }
+
+        public async Task<Question?> removeQuestion(uint id)
+        {
+            return (await manager.removeQuestion(id))?.ToModel();
+        }
+
+        public async Task<Question?> updateQuestion(uint id, Question question)
+        {
+            return (await manager.updateQuestion(id, question.ToEntity()))?.ToModel();
+        }
+
+        public async Task<Question?> updateQuestionNbFalls(uint id)
+        {
+            return (await manager.updateQuestionNbFalls(id))?.ToModel();
+        }
+    }
+}

WebApi/EntityManagers/PlayerEntityManager.cs

@@ -56,7 +56,7 @@ namespace EntityManagers
             return await dbContext.Players.Where(p => p.Nickname == nickname).FirstOrDefaultAsync();
         }
 
-        public async Task<(int nbPage, IEnumerable<PlayerEntity>? players)> getPlayers(int nb, int count, PlayerOrderCriteria orderCriteria = PlayerOrderCriteria.ById)
+        public async Task<(int nbPages, IEnumerable<PlayerEntity>? players)> getPlayers(int nb, int count, PlayerOrderCriteria orderCriteria = PlayerOrderCriteria.ById)
         {
             int nbEl = getNbElements();
             if (nb < 0 || count < 0 || nb > nbEl / count) return await Task.FromResult<(int nbPages, IEnumerable<PlayerEntity>? players)>((nbEl / count, null));

WebApi/ManagerInterfaces/IPlayerManager.cs

@@ -62,7 +62,7 @@ namespace ManagerInterfaces
         /// does not exist (<=> (nb-1)*count outside
         /// boundaries (0, getNbElement()-1)))
         /// </returns>
-        public Task<(int nbPage, IEnumerable<T>? players)> getPlayers(int nb, int count, PlayerOrderCriteria orderCriteria = PlayerOrderCriteria.ById);
+        public Task<(int nbPages, IEnumerable<T>? players)> getPlayers(int nb, int count, PlayerOrderCriteria orderCriteria = PlayerOrderCriteria.ById);
         /// <summary>
         /// get a player
         /// </summary>

WebApi/ServiceManagers/AdministratorServiceManager.cs

@@ -0,0 +1,66 @@
+using DbConnectionLibrairie;
+using DataManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DTOs;
+
+namespace ToModel
+{
+    public class AdministratorServiceManager(MyDbContext dbContext) : IAdministratorManager<AdministratorDto>
+    {
+
+        private AdministratorDataManager manager = new AdministratorDataManager(dbContext);
+
+        public async Task<AdministratorDto> addAdmin(AdministratorDto admin)
+        {
+            return await Task.FromResult<AdministratorDto>((await manager.addAdmin(admin.ToModel())).ToDto());
+        }
+
+        public async Task<AdministratorDto?> getAdministratorByUsername(string username)
+        {
+            return await Task.FromResult<AdministratorDto?>((await manager.getAdministratorByUsername(username))?.ToDto());
+        }
+
+        public async Task<(int nbPages, IEnumerable<AdministratorDto>? administrators)> getAdministrators(int nb, int count, AdministratorOrderCriteria orderCriteria = AdministratorOrderCriteria.ById)
+        {
+            List<AdministratorDto>? tmp = new List<AdministratorDto>();
+            var res = await manager.getAdministrators(nb, count, orderCriteria);
+            if (res.administrators == null) tmp = null;
+            else
+            {
+                foreach (var item in res.administrators)
+                {
+                    tmp.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<AdministratorDto>? administrators)>((res.nbPages, tmp));
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<AdministratorDto?> removeAdmin(AdministratorDto admin)
+        {
+            return (await manager.removeAdmin(admin.ToModel()))?.ToDto();
+        }
+
+        public async Task<AdministratorDto?> removeAdmin(int id)
+        {
+            return (await manager.removeAdmin(id))?.ToDto();
+        }
+
+        public async Task<bool> setPassword(string username, string newHashedPassword)
+        {
+            return await manager.setPassword(username, newHashedPassword);
+        }
+    }
+}

WebApi/ServiceManagers/AnswerServiceManager.cs

@@ -0,0 +1,81 @@
+using DbConnectionLibrairie;
+using DataManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DTOs;
+
+namespace ServiceManagers
+{
+    public class AnswerServiceManager(MyDbContext dbContext) : IAnswerManager<AnswerDto>
+    {
+
+        private AnswerDataManager manager = new AnswerDataManager(dbContext);
+
+        public async Task<AnswerDto> addAnswer(AnswerDto answerdto)
+        {
+            return await Task.FromResult<AnswerDto>((await manager.addAnswer(answerdto.ToModel())).ToDto());
+        }
+
+        public async Task<AnswerDto?> getAnswer(uint id)
+        {
+            return await Task.FromResult<AnswerDto?>((await manager.getAnswer(id))?.ToDto());
+        }
+
+        public async Task<(int nbPages, IEnumerable<AnswerDto>? answers)> getAnswers(int nb, int count, AnswerOrderCriteria orderCriteria = AnswerOrderCriteria.ById)
+        {
+            List<AnswerDto>? tmp = new List<AnswerDto>();
+            var res = await manager.getAnswers(nb, count, orderCriteria);
+            if (res.answers == null) tmp = null;
+            else
+            {
+                foreach (var item in res.answers)
+                {
+                    tmp.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<AnswerDto>? answers)>((res.nbPages, tmp));
+        }
+
+        public async Task<IEnumerable<AnswerDto>?> getAnswersByIdQuestion(uint id)
+        {
+            var tmp = await manager.getAnswersByIdQuestion(id);
+            List<AnswerDto>? answerdto = new List<AnswerDto>();
+            if (tmp == null) answerdto = null;
+            else
+            {
+                foreach (var item in tmp)
+                {
+                    answerdto.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<List<AnswerDto>?>(answerdto);
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<AnswerDto?> removeAnswer(uint id)
+        {
+            return (await manager.removeAnswer(id))?.ToDto();
+        }
+
+        public async Task<AnswerDto?> removeAnswer(AnswerDto answerdto)
+        {
+            return (await manager.removeAnswer(answerdto.ToModel()))?.ToDto();
+        }
+
+        public async Task<AnswerDto?> updateAnswer(uint id, AnswerDto answerdto)
+        {
+            return (await manager.updateAnswer(id, answerdto.ToModel()))?.ToDto();
+        }
+    }
+}

WebApi/ServiceManagers/ChapterServiceManager.cs

@@ -0,0 +1,60 @@
+using DbConnectionLibrairie;
+using DataManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DTOs;
+
+namespace ServiceManagers
+{
+    public class ChapterServiceManager(MyDbContext dbContext) : IChapterManager<ChapterDto>
+    {
+        private ChapterDataManager manager = new ChapterDataManager(dbContext);
+        
+        public async Task<ChapterDto> addChapter(ChapterDto chapterdto)
+        {
+            return await Task.FromResult<ChapterDto>((await manager.addChapter(chapterdto.ToModel())).ToDto());
+        }
+
+        public async Task<ChapterDto?> getChapter(uint id)
+        {
+            return await Task.FromResult<ChapterDto?>((await manager.getChapter(id))?.ToDto());
+        }
+
+        public async Task<(int nbPages, IEnumerable<ChapterDto>? chapters)> getChapters(int nb, int count, ChapterOrderCriteria orderCriteria = ChapterOrderCriteria.ById)
+        {
+            List<ChapterDto>? tmp = new List<ChapterDto>();
+            var res = await manager.getChapters(nb, count, orderCriteria);
+            if (res.chapters == null) tmp = null;
+            else
+            {
+                foreach (var item in res.chapters)
+                {
+                    tmp.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<ChapterDto>? chapters)>((res.nbPages, tmp));
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<ChapterDto?> removeChapter(ChapterDto chapterdto)
+        {
+            return (await manager.removeChapter(chapterdto.ToModel()))?.ToDto();
+        }
+
+        public async Task<ChapterDto?> removeChapter(uint id)
+        {
+            return (await manager.removeChapter(id))?.ToDto();
+        }
+    }
+}

WebApi/ServiceManagers/LobbyServiceManager.cs

@@ -0,0 +1,60 @@
+using DbConnectionLibrairie;
+using DataManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DTOs;
+
+namespace ServiceManagers
+{
+    public class LobbyServiceManager(MyDbContext dbContext) : ILobbyManager<LobbyDto>
+    {
+        private LobbyDataManager manager = new LobbyDataManager(dbContext);
+
+        public async Task<LobbyDto> addLobby(LobbyDto lobbydto)
+        {
+            return await Task.FromResult<LobbyDto>((await manager.addLobby(lobbydto.ToModel())).ToDto());
+        }
+
+        public async Task<(int nbPages, IEnumerable<LobbyDto>? lobbies)> getLobbies(int nb, int count, LobbyOrderCriteria orderCriteria = LobbyOrderCriteria.ById)
+        {
+            List<LobbyDto>? tmp = new List<LobbyDto>();
+            var res = await manager.getLobbies(nb, count, orderCriteria);
+            if (res.lobbies == null) tmp = null;
+            else
+            {
+                foreach (var item in res.lobbies)
+                {
+                    tmp.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<LobbyDto>? lobbies)>((res.nbPages, tmp));
+        }
+
+        public async Task<LobbyDto?> getLobby(uint id)
+        {
+            return await Task.FromResult<LobbyDto?>((await manager.getLobby(id))?.ToDto());
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<LobbyDto?> removeLobby(LobbyDto lobbydto)
+        {
+            return (await manager.removeLobby(lobbydto.ToModel()))?.ToDto();
+        }
+
+        public async Task<LobbyDto?> removeLobby(uint id)
+        {
+            return (await manager.removeLobby(id))?.ToDto();
+        }
+    }
+}

WebApi/ServiceManagers/PlayerServiceManager.cs

@@ -0,0 +1,90 @@
+using DbConnectionLibrairie;
+using DataManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DTOs;
+
+namespace ServiceManagers
+{
+    public class PlayerServiceManager(MyDbContext dbContext) : IPlayerManager<PlayerDto>
+    {
+        private PlayerDataManager manager = new PlayerDataManager(dbContext);
+
+        public async Task<PlayerDto> addPlayer(PlayerDto playerdto)
+        {
+            return await Task.FromResult<PlayerDto>((await manager.addPlayer(playerdto.ToModel())).ToDto());
+        }
+
+        public async Task<uint?> getMaxScorePlayer(uint id, uint idChapter)
+        {
+            return await manager.getMaxScorePlayer(id, idChapter);
+        }
+
+        public async Task<uint?> getMaxScorePlayer(uint id)
+        {
+            return await manager.getMaxScorePlayer(id);
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<PlayerDto?> getPlayer(uint id)
+        {
+            return await Task.FromResult<PlayerDto?>((await manager.getPlayer(id))?.ToDto());
+        }
+
+        public async Task<PlayerDto?> getPlayer(string nickname)
+        {
+            return await Task.FromResult<PlayerDto?>((await manager.getPlayer(nickname))?.ToDto());
+        }
+
+        public async Task<(int nbPages, IEnumerable<PlayerDto>? players)> getPlayers(int nb, int count, PlayerOrderCriteria orderCriteria = PlayerOrderCriteria.ById)
+        {
+            List<PlayerDto>? tmp = new List<PlayerDto>();
+            var res = await manager.getPlayers(nb, count, orderCriteria);
+            if (res.players == null) tmp = null;
+            else
+            {
+                foreach (var item in res.players)
+                {
+                    tmp.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<PlayerDto>? players)>((res.nbPages, tmp));
+        }
+
+        public async Task<IEnumerable<PlayerDto>?> getPlayersInALobby(uint idLobby)
+        {
+            List<PlayerDto>? tmp = new List<PlayerDto>();
+            var res = await manager.getPlayersInALobby(idLobby);
+            if (res == null) tmp = null;
+            else
+            {
+                foreach (var item in res)
+                {
+                    tmp.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<IEnumerable<PlayerDto>?>(tmp);
+        }
+
+        public async Task<PlayerDto?> removePlayer(PlayerDto playerdto)
+        {
+            return (await manager.removePlayer(playerdto.ToModel()))?.ToDto();
+        }
+
+        public async Task<PlayerDto?> removePlayer(uint id)
+        {
+            return (await manager.removePlayer(id))?.ToDto();
+        }
+    }
+}

WebApi/ServiceManagers/QuestionServiceManager.cs

@@ -0,0 +1,104 @@
+using DbConnectionLibrairie;
+using DTOs;
+using Entities;
+using EntityManagers;
+using ExtensionsClassLibrairie;
+using ManagerInterfaces;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataManagers
+{
+    public class QuestionServiceManager(MyDbContext dbContext) : IQuestionManager<QuestionDto>
+    {
+
+        private QuestionDataManager manager = new QuestionDataManager(dbContext);
+
+        public async Task<QuestionDto> addQuestion(QuestionDto question)
+        {
+            return await Task.FromResult<QuestionDto>((await manager.addQuestion(question.ToModel())).ToDto());
+        }
+
+        public async Task<IEnumerable<QuestionDto>> addQuestions(IEnumerable<QuestionDto> questions)
+        {
+            var tmp = new List<Question>();
+            foreach (var question in questions)
+            {
+                tmp.Add(question.ToModel());
+            }
+            var res = await manager.addQuestions(tmp);
+            var tmp2 = new List<QuestionDto>();
+            foreach (var item in res)
+            {
+                tmp2.Add(item.ToDto());
+            }
+            return tmp2;
+        }
+
+        public int getNbElements()
+        {
+            return manager.getNbElements();
+        }
+
+        public async Task<QuestionDto?> getQuestion(uint id)
+        {
+            return await Task.FromResult<QuestionDto?>((await manager.getQuestion(id))?.ToDto());
+        }
+
+        public async Task<(int nbPages, IEnumerable<QuestionDto>? questions)> getQuestions(int nb, int count, QuestionOrderCriteria orderCriteria = QuestionOrderCriteria.ById)
+        {
+            List<QuestionDto>? tmp = new List<QuestionDto>();
+            var res = await manager.getQuestions(nb, count, orderCriteria);
+            if (res.questions == null) tmp = null;
+            else
+            {
+                foreach (var item in res.questions)
+                {
+                    tmp.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<QuestionDto>? questions)>((res.nbPages, tmp));
+        }
+
+        public async Task<(int nbPages, IEnumerable<QuestionDto>? questions)?> getQuestionsByChapterAndDifficulty(int idChapter, int difficulty, int nb, int count, QuestionOrderCriteria orderCriteria = QuestionOrderCriteria.ById)
+        {
+            List<QuestionDto>? tmp = new List<QuestionDto>();
+            var res = await manager.getQuestionsByChapterAndDifficulty(idChapter, difficulty, nb, count, orderCriteria);
+            if (res == null) return await Task.FromResult<(int nbPages, IEnumerable<QuestionDto>? questions)?>(null);
+            if (res.Value.questions == null) tmp = null;
+            else
+            {
+                foreach (var item in res.Value.questions)
+                {
+                    tmp.Add(item.ToDto());
+                }
+            }
+            return await Task.FromResult<(int nbPages, IEnumerable<QuestionDto>? questions)>((res.Value.nbPages, tmp));
+        }
+
+        public async Task<QuestionDto?> removeQuestion(QuestionDto question)
+        {
+            return (await manager.removeQuestion(question.ToModel()))?.ToDto();
+        }
+
+        public async Task<QuestionDto?> removeQuestion(uint id)
+        {
+            return (await manager.removeQuestion(id))?.ToDto();
+        }
+
+        public async Task<QuestionDto?> updateQuestion(uint id, QuestionDto question)
+        {
+            return (await manager.updateQuestion(id, question.ToModel()))?.ToDto();
+        }
+
+        public async Task<QuestionDto?> updateQuestionNbFalls(uint id)
+        {
+            return (await manager.updateQuestionNbFalls(id))?.ToDto();
+        }
+    }
+}

WebApi/ServiceManagers/ServiceManagers.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DataManagers\DataManagers.csproj" />
+    <ProjectReference Include="..\DbConnectionLibrairie\DbConnectionLibrairie.csproj" />
+    <ProjectReference Include="..\DTOs\DTOs.csproj" />
+    <ProjectReference Include="..\ExtensionsClassLibrairie\ExtensionsClassLibrairie.csproj" />
+    <ProjectReference Include="..\ManagerInterfaces\ManagerInterfaces.csproj" />
+    <ProjectReference Include="..\Model\Model.csproj" />
+  </ItemGroup>
+
+</Project>

WebApi/UnitTestsEntityManagers/AbstractUnitTestEM.cs

@@ -15,10 +15,11 @@ namespace UnitTestsEntityManagers
     public abstract class AbstractUnitTestEM
     {
         protected MyDbContext dbContext;
+        protected HttpClient httpClient;
 
         /// <summary>
         /// constructor of the class :
-        /// initialise the dbContext
+        /// initialise the database context
         /// </summary>
         public AbstractUnitTestEM()
         {
@@ -27,6 +28,8 @@ namespace UnitTestsEntityManagers
                 .Options;
 
             dbContext = new MyDbContext(opt);
+
+            httpClient = new HttpClient();
         }
 
         /// <summary>
@@ -35,7 +38,7 @@ namespace UnitTestsEntityManagers
         /// </summary>
         ~AbstractUnitTestEM()
         {
-            dbContext.DisposeAsync();
+            dbContext.Dispose();
         }
     }
 }

WebApi/UnitTestsEntityManagers/UnitTestAnswerManager.cs

@@ -22,22 +22,19 @@ namespace UnitTestsEntityManagers
         /// test of the 'ajouterAnswer' method of an AnswerManager
         /// </summary>
         [Fact]
-        public void TestAjouterAnswer()
+        public async void TestAjouterAnswer()
         {
-            var answerToAdd = new AnswerEntity { Id = -1, Content = "châteîgne" };
-            var a = mgr.ajouterAnswer(answerToAdd);
-            // 1) with an id less than 0
-            // WF : it works so 'a' is not null,
-            // his content is equal to the
-            // content of 'answerToAdd'
-            // and since it's the first answer
-            // that we add, his id equal 0
+            var answerToAdd = new AnswerEntity { Id = 0, Content = "damien" };
+            var a = await mgr.addAnswer(answerToAdd);
+            // 1) normal insertion
+            // WF : it work perfectally
+            // and a is the same as answerToAdd
             Assert.NotNull(a);
             Assert.Equal(answerToAdd.Content, a.Content);
-            Assert.NotEqual(0, a.Id);
+            Assert.Equal(answerToAdd.Id, a.Id);
 
             answerToAdd = new AnswerEntity { Id = 5, Content = "damien" };
-            a = mgr.ajouterAnswer(answerToAdd);
+            a = await mgr.addAnswer(answerToAdd);
             // 2) with a random id greater than 0
             // WF : it works so 'a' is not null,
             // his content is equal to the
@@ -46,16 +43,16 @@ namespace UnitTestsEntityManagers
             // that we add, his id equal 1
             Assert.NotNull(a);
             Assert.Equal(answerToAdd.Content, a.Content);
-            Assert.NotEqual(1, a.Id);
+            Assert.NotEqual((uint)1, a.Id);
 
             answerToAdd = new AnswerEntity { Id = 7, Content = "châteîgne" };
-            a = mgr.ajouterAnswer(answerToAdd);
+            a = await mgr.addAnswer(answerToAdd);
             // 3) with a content that we already have added
             // WF : it don't works so 'a' is null
             Assert.Null(a);
 
             answerToAdd = new AnswerEntity { Id = 7, Content = "CHÂTEÎGNE" };
-            a = mgr.ajouterAnswer(answerToAdd);
+            a = await mgr.addAnswer(answerToAdd);
             // 3) with a content that we already have added
             // but in upperCase instead of lowerCase
             // WF : it don't works so 'a' is null
@@ -66,40 +63,34 @@ namespace UnitTestsEntityManagers
         /// test of the 'supprimerAnswer' method of an AnswerManager
         /// </summary>
         [Fact]
-        public void TestSupprimerAnswer()
+        public async Task TestSupprimerAnswer()
         {
             // remember that we have only 2 answers in the database :
             // 1) (0, "châteigne")
             // 2) (1, "damien")
-            var a = mgr.supprimerAnswer(-3);
-            // 1) with an id less than 0
-            // WF : it don't work because there's no
-            // negative id so 'a' is null
-            Assert.Null(a);
-
-            a = mgr.supprimerAnswer(3);
-            // 2) with an id greater or equal
+            var a = await mgr.removeAnswer(2);
+            // 1) with an id greater or equal
             // to the number of element
             // WF : it don't works so 'a' is null,
             Assert.Null(a);
 
-            a = mgr.supprimerAnswer(0);
+            a = await mgr.removeAnswer(0);
             // 1) with an id that belongs to an answer
             // WF : it works so 'a' is not null,
             // and since we've delete the answer with
             // the id 0, the content is "châteigne"
             Assert.NotNull(a);
-            Assert.Equal(0, a.Id);
+            Assert.Equal((uint)0, a.Id);
             Assert.Equal("châteigne", a.Content);
 
-            a = mgr.supprimerAnswer(0);
+            a = await mgr.removeAnswer(1);
             // 1) same thing with the id 1 just
-            // for cleaning the database
+            // to clean the database
             // WF : it works so 'a' is not null,
             // and since we've delete the answer with
             // the id 1, the content is "damien"
             Assert.NotNull(a);
-            Assert.Equal(0, a.Id);
+            Assert.Equal((uint)0, a.Id);
             Assert.Equal("damien", a.Content);
 
             // now, the database should be clean
@@ -112,18 +103,18 @@ namespace UnitTestsEntityManagers
         /// test of the 'getNbElement' method of an AnswerManager
         /// </summary>
         [Fact]
-        public void TestGetNbElement()
+        public async Task TestGetNbElement()
         {
-            Assert.Equal(0, mgr.getNbElement()); // just to be sure
+            Assert.Equal(0, mgr.getNbElements()); // just to be sure
 
             Assert.NotNull(answers); // just to be sure
 
             int count = 0;
             foreach (var answer in answers)
             {
-                mgr.ajouterAnswer(answer);
+                await mgr.addAnswer(answer);
                 count++;
-                Assert.Equal(count, mgr.getNbElement());
+                Assert.Equal(count, mgr.getNbElements());
             }
         }
 

WebApi/UnitTestsEntityManagers/UnitTestsEntityManagers.csproj

@@ -12,7 +12,7 @@
 
   <ItemGroup>
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="xunit" Version="2.5.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
   </ItemGroup>

WebApi/WebApi.sln

@@ -17,16 +17,15 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OrderCriterias", "OrderCrit
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitTestsEntityManagers", "UnitTestsEntityManagers\UnitTestsEntityManagers.csproj", "{6E2E46BB-91F0-4F5C-B378-A54E4F80ED0C}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "FakeDatas", "FakeDatas", "{295BDC09-893D-4862-8F6C-6B65FACCB802}"
-	ProjectSection(SolutionItems) = preProject
-		fake-Answers.json = fake-Answers.json
-	EndProjectSection
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Model", "Model\Model.csproj", "{95E60A3C-AB3C-4B8F-BAA2-EEB899E12CE7}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ExtensionsClassLibrairie", "ExtensionsClassLibrairie\ExtensionsClassLibrairie.csproj", "{66AAAC2F-10B0-4F29-971C-3548EB34B621}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DataManagers", "DataManagers\DataManagers.csproj", "{C609569C-353E-4F1A-BDEE-7C686FBDA084}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DataManagers", "DataManagers\DataManagers.csproj", "{C609569C-353E-4F1A-BDEE-7C686FBDA084}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ServiceManagers", "ServiceManagers\ServiceManagers.csproj", "{5E2AC4B3-3DC6-48CF-9F90-5EDFFCF0A385}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WebApi", "WebApi\WebApi.csproj", "{7A65FECF-F4F5-4D88-853D-F21A3BAA5E39}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -74,6 +73,14 @@ Global
 		{C609569C-353E-4F1A-BDEE-7C686FBDA084}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C609569C-353E-4F1A-BDEE-7C686FBDA084}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C609569C-353E-4F1A-BDEE-7C686FBDA084}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5E2AC4B3-3DC6-48CF-9F90-5EDFFCF0A385}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5E2AC4B3-3DC6-48CF-9F90-5EDFFCF0A385}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5E2AC4B3-3DC6-48CF-9F90-5EDFFCF0A385}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5E2AC4B3-3DC6-48CF-9F90-5EDFFCF0A385}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7A65FECF-F4F5-4D88-853D-F21A3BAA5E39}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7A65FECF-F4F5-4D88-853D-F21A3BAA5E39}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7A65FECF-F4F5-4D88-853D-F21A3BAA5E39}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7A65FECF-F4F5-4D88-853D-F21A3BAA5E39}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

WebApi/WebApi/Controllers/WeatherForecastController.cs

@@ -0,0 +1,33 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace WebApi.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class WeatherForecastController : ControllerBase
+    {
+        private static readonly string[] Summaries = new[]
+        {
+            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
+        };
+
+        private readonly ILogger<WeatherForecastController> _logger;
+
+        public WeatherForecastController(ILogger<WeatherForecastController> logger)
+        {
+            _logger = logger;
+        }
+
+        [HttpGet(Name = "GetWeatherForecast")]
+        public IEnumerable<WeatherForecast> Get()
+        {
+            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
+            {
+                Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
+                TemperatureC = Random.Shared.Next(-20, 55),
+                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
+            })
+            .ToArray();
+        }
+    }
+}

WebApi/WebApi/Program.cs

@@ -0,0 +1,25 @@
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to the container.
+
+builder.Services.AddControllers();
+// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+var app = builder.Build();
+
+// Configure the HTTP request pipeline.
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+
+app.UseAuthorization();
+
+app.MapControllers();
+
+app.Run();

WebApi/WebApi/Properties/launchSettings.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:6506",
+      "sslPort": 44397
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "http://localhost:5293",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7194;http://localhost:5293",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

WebApi/WebApi/WeatherForecast.cs

@@ -0,0 +1,13 @@
+namespace WebApi
+{
+    public class WeatherForecast
+    {
+        public DateOnly Date { get; set; }
+
+        public int TemperatureC { get; set; }
+
+        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
+
+        public string? Summary { get; set; }
+    }
+}

WebApi/WebApi/WebApi.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
+  </ItemGroup>
+
+</Project>

WebApi/WebApi/WebApi.http

@@ -0,0 +1,6 @@
+@WebApi_HostAddress = http://localhost:5293
+
+GET {{WebApi_HostAddress}}/weatherforecast/
+Accept: application/json
+
+###

WebApi/WebApi/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

WebApi/WebApi/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}