feat : création des entities manager (à revoir notamment pour l'ajout d'entités)

WebApi/EntityManagers/AdministratorEntityManager.cs

@@ -0,0 +1,81 @@
+using DbConnectionLibrairie;
+using Entities;
+using ManagerInterfaces;
+using Microsoft.EntityFrameworkCore;
+using OrderCriterias;
+using ExtensionsClassLibrairie;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EntityManagers
+{
+    public class AdministratorEntityManager(MyDbContext dbContext) : IAdministratorManager<AdministratorEntity>
+    {
+        private MyDbContext dbContext = dbContext;
+
+        public Task<AdministratorEntity> addAdmin(AdministratorEntity admin)
+        {
+            dbContext.Administrators.Add(admin);
+            dbContext.SaveChangesAsync();
+            return dbContext.Administrators.Where(a => a.Equals(admin)).FirstAsync();
+        }
+
+        public Task<AdministratorEntity?> getAdministratorByUsername(string username)
+        {
+            return dbContext.Administrators.Where(a => a.Username == username).FirstOrDefaultAsync();
+        }
+
+        public Task<(int nbPages, IEnumerable<AdministratorEntity>? administrators)> getAdministrators(int nb, int count, AdministratorOrderCriteria orderCriteria = AdministratorOrderCriteria.ById)
+        {
+            int nbEl = getNbElements();
+            if(nb > nbEl/count) return Task.FromResult<(int nbPages, IEnumerable<AdministratorEntity>? administrators)>((nbEl/count, null));
+            var tmp = dbContext.Administrators;
+            switch (orderCriteria)
+            {
+                case AdministratorOrderCriteria.ById:
+                    tmp.OrderBy(a => a.Id);
+                    break;
+                case AdministratorOrderCriteria.ByUserName:
+                    tmp.OrderBy(a => a.Username);
+                    break;
+            }
+            return Task.FromResult<(int nbPages, IEnumerable<AdministratorEntity>? administrators)>((nbEl/count, tmp.Skip((nb-1)*count).Take(count)));
+        }
+
+        public int getNbElements()
+        {
+            return dbContext.Administrators.CountAsync().Result;
+        }
+
+        public Task<AdministratorEntity?> removeAdmin(AdministratorEntity admin)
+        {
+            var tmp = dbContext.Administrators.Where(a => a.Equals(admin)).FirstOrDefaultAsync().Result;
+            if(tmp == null) return Task.FromResult<AdministratorEntity?>(tmp);
+            dbContext.Administrators.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<AdministratorEntity?>(tmp);
+        }
+
+        public Task<AdministratorEntity?> removeAdmin(int id)
+        {
+            var tmp = dbContext.Administrators.Where(a => a.Id == id).FirstOrDefaultAsync().Result;
+            if (tmp == null) return Task.FromResult<AdministratorEntity?>(tmp);
+            dbContext.Administrators.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<AdministratorEntity?>(tmp);
+        }
+
+        public Task<bool> setPassword(string username, string newHashedPassword)
+        {
+            var tmp = getAdministratorByUsername(username).Result;
+            if (tmp == null) return Task.FromResult<bool>(false);
+            tmp.HashedPassword = newHashedPassword;
+            dbContext.SaveChanges();
+            return Task.FromResult<bool>(true);
+        }
+    }
+}

WebApi/EntityManagers/AnswerEntityManager.cs

@@ -0,0 +1,88 @@
+using DbConnectionLibrairie;
+using Entities;
+using ManagerInterfaces;
+using Microsoft.EntityFrameworkCore;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EntityManagers
+{
+    public class AnswerEntityManager(MyDbContext dbContext) : IAnswerManager<AnswerEntity>
+    {
+        private MyDbContext dbContext = dbContext;
+
+        public Task<AnswerEntity> addAnswer(AnswerEntity answer)
+        {
+            dbContext.Answers.Add(answer);
+            dbContext.SaveChangesAsync();
+            return dbContext.Answers.Where(a => a.Equals(answer)).FirstAsync();
+        }
+
+        public Task<AnswerEntity?> getAnswer(uint id)
+        {
+            return dbContext.Answers.Where(a => a.Id == id).FirstOrDefaultAsync();
+        }
+
+        public Task<(int nbPages, IEnumerable<AnswerEntity>? answers)> getAnswers(int nb, int count, AnswerOrderCriteria orderCriteria = AnswerOrderCriteria.ById)
+        {
+            int nbEl = getNbElements();
+            if (nb > nbEl / count) return Task.FromResult<(int nbPages, IEnumerable<AnswerEntity>? answers)>((nbEl / count, null));
+            var tmp = dbContext.Answers;
+            switch (orderCriteria)
+            {
+                case AnswerOrderCriteria.ById:
+                    tmp.OrderBy(a => a.Id);
+                    break;
+                case AnswerOrderCriteria.ByContent:
+                    tmp.OrderBy(a => a.Content);
+                    break;
+                case AnswerOrderCriteria.ByIdQuestion:
+                    tmp.OrderBy(a => a.IdQuestion);
+                    break;
+            }
+            return Task.FromResult<(int nbPages, IEnumerable<AnswerEntity>? answers)>((nbEl / count, tmp.Skip((nb - 1) * count).Take(count)));
+        }
+
+        public Task<IEnumerable<AnswerEntity>?> getAnswersByIdQuestion(uint id)
+        {
+            if(dbContext.Questions.Where(q => q.Id == id).Any())
+            {
+                return Task.FromResult<IEnumerable<AnswerEntity>?>(dbContext.Answers.Where(a => a.IdQuestion == id));
+            }
+            return Task.FromResult<IEnumerable<AnswerEntity>?>(null);
+        }
+
+        public int getNbElements()
+        {
+            return dbContext.Answers.CountAsync().Result;
+        }
+
+        public Task<AnswerEntity?> removeAnswer(uint id)
+        {
+            var tmp = getAnswer(id).Result;
+            if (tmp == null) return Task.FromResult<AnswerEntity?>(tmp);
+            dbContext.Answers.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<AnswerEntity?>(tmp);
+        }
+
+        public Task<AnswerEntity?> removeAnswer(AnswerEntity answer)
+        {
+            var tmp = dbContext.Answers.Where(a => a.Equals(answer)).FirstOrDefaultAsync().Result;
+            if (tmp == null) return Task.FromResult<AnswerEntity?>(tmp);
+            dbContext.Answers.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<AnswerEntity?>(tmp);
+        }
+
+        public Task<AnswerEntity?> updateAnswer(uint id, AnswerEntity answer)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

WebApi/EntityManagers/ChapterEntityManager.cs

@@ -0,0 +1,71 @@
+using DbConnectionLibrairie;
+using Entities;
+using ManagerInterfaces;
+using Microsoft.EntityFrameworkCore;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EntityManagers
+{
+    public class ChapterEntityManager(MyDbContext dbContext) : IChapterManager<ChapterEntity>
+    {
+        MyDbContext dbContext = dbContext;
+
+        public Task<ChapterEntity> addChapter(ChapterEntity chapter)
+        {
+            dbContext.Chapters.Add(chapter);
+            dbContext.SaveChangesAsync();
+            return dbContext.Chapters.Where(a => a.Equals(chapter)).FirstAsync();
+        }
+
+        public Task<ChapterEntity?> getChapter(uint id)
+        {
+            return Task.FromResult<ChapterEntity?>(dbContext.Chapters.Where(c => c.Id == id).FirstOrDefault());
+        }
+
+        public Task<(int nbPages, IEnumerable<ChapterEntity>? chapters)> getChapters(int nb, int count, ChapterOrderCriteria orderCriteria = ChapterOrderCriteria.ById)
+        {
+            int nbEl = getNbElements();
+            if (nb > nbEl / count) return Task.FromResult<(int nbPages, IEnumerable<ChapterEntity>? chapters)>((nbEl / count, null));
+            var tmp = dbContext.Chapters;
+            switch (orderCriteria)
+            {
+                case ChapterOrderCriteria.ById:
+                    tmp.OrderBy(a => a.Id);
+                    break;
+                case ChapterOrderCriteria.ByName:
+                    tmp.OrderBy(a => a.Name);
+                    break;
+            }
+            return Task.FromResult<(int nbPages, IEnumerable<ChapterEntity>? chapters)>((nbEl / count, tmp.Skip((nb - 1) * count).Take(count)));
+        }
+
+        public int getNbElements()
+        {
+            return dbContext.Chapters.CountAsync().Result;
+        }
+
+        public Task<ChapterEntity?> removeChapter(ChapterEntity chapter)
+        {
+            var tmp = dbContext.Chapters.Where(a => a.Equals(chapter)).FirstOrDefaultAsync().Result;
+            if (tmp == null) return Task.FromResult<ChapterEntity?>(tmp);
+            dbContext.Chapters.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<ChapterEntity?>(tmp);
+        }
+
+        public Task<ChapterEntity?> removeChapter(uint id)
+        {
+            var tmp = getChapter(id).Result;
+            if (tmp == null) return Task.FromResult<ChapterEntity?>(tmp);
+            dbContext.Chapters.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<ChapterEntity?>(tmp);
+        }
+    }
+}

WebApi/EntityManagers/EntityManagers.csproj

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

WebApi/EntityManagers/LobbyEntityManager.cs

@@ -0,0 +1,74 @@
+using DbConnectionLibrairie;
+using Entities;
+using ManagerInterfaces;
+using Microsoft.EntityFrameworkCore;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EntityManagers
+{
+    public class LobbyEntityManager(MyDbContext dbContext) : ILobbyManager<LobbyEntity>
+    {
+        MyDbContext dbContext = dbContext;
+
+        public Task<LobbyEntity> addLobby(LobbyEntity lobby)
+        {
+            dbContext.Lobbies.Add(lobby);
+            dbContext.SaveChangesAsync();
+            return dbContext.Lobbies.Where(a => a.Equals(lobby)).FirstAsync();
+        }
+
+        public Task<(int nbPages, IEnumerable<LobbyEntity>? lobbies)> getLobbies(int nb, int count, LobbyOrderCriteria orderCriteria = LobbyOrderCriteria.ById)
+        {
+            int nbEl = getNbElements();
+            if (nb > nbEl / count) return Task.FromResult<(int nbPages, IEnumerable<LobbyEntity>? lobbies)>((nbEl / count, null));
+            var tmp = dbContext.Lobbies;
+            switch (orderCriteria)
+            {
+                case LobbyOrderCriteria.ById:
+                    tmp.OrderBy(l => l.Id);
+                    break;
+                case LobbyOrderCriteria.ByName:
+                    tmp.OrderBy(l => l.Name);
+                    break;
+                case LobbyOrderCriteria.ByNbJoueur:
+                    tmp.OrderBy(l => l.NbPlayers);
+                    break;
+            }
+            return Task.FromResult<(int nbPages, IEnumerable<LobbyEntity>? lobbies)>((nbEl / count, tmp.Skip((nb - 1) * count).Take(count)));
+        }
+
+        public Task<LobbyEntity?> getLobby(uint id)
+        {
+            return Task.FromResult<LobbyEntity?>(dbContext.Lobbies.Where(l => l.Id == id).FirstOrDefault());
+        }
+
+        public int getNbElements()
+        {
+            return dbContext.Lobbies.CountAsync().Result;
+        }
+
+        public Task<LobbyEntity?> removeLobby(LobbyEntity lobby)
+        {
+            var tmp = dbContext.Lobbies.Where(a => a.Equals(lobby)).FirstOrDefaultAsync().Result;
+            if (tmp == null) return Task.FromResult<LobbyEntity?>(tmp);
+            dbContext.Lobbies.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<LobbyEntity?>(tmp);
+        }
+
+        public Task<LobbyEntity?> removeLobby(uint id)
+        {
+            var tmp = dbContext.Lobbies.Where(a => a.Id == id).FirstOrDefaultAsync().Result;
+            if (tmp == null) return Task.FromResult<LobbyEntity?>(tmp);
+            dbContext.Lobbies.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<LobbyEntity?>(tmp);
+        }
+    }
+}

WebApi/EntityManagers/PlayerEntityManager.cs

@@ -0,0 +1,96 @@
+using DbConnectionLibrairie;
+using Entities;
+using ManagerInterfaces;
+using Microsoft.EntityFrameworkCore;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EntityManagers
+{
+    public class PlayerEntityManager(MyDbContext dbContext) : IPlayerManager<PlayerEntity>
+    {
+        MyDbContext dbContext = dbContext;
+
+        public Task<PlayerEntity> addPlayer(PlayerEntity player)
+        {
+            dbContext.Players.Add(player);
+            dbContext.SaveChangesAsync();
+            return dbContext.Players.Where(a => a.Equals(player)).FirstAsync();
+        }
+
+        public Task<uint?> getMaxScorePlayer(uint id, uint idChapter)
+        {
+            var tmp = dbContext.Play.Where(p => p.IdPlayer == id && p.IdChapter == idChapter).FirstOrDefault();
+            return Task.FromResult(tmp?.MaxScore);
+        }
+
+        public Task<uint?> getMaxScorePlayer(uint id)
+        {
+            var tmp = dbContext.Play.Where(p => p.IdPlayer == id).Select(p => p.MaxScore);
+            if (!tmp.AnyAsync().Result) return Task.FromResult<uint?>(null);
+            return Task.FromResult<uint?>(tmp?.MaxAsync().Result);
+        }
+
+        public int getNbElements()
+        {
+            return dbContext.Players.CountAsync().Result;
+        }
+
+        public Task<PlayerEntity?> getPlayer(uint id)
+        {
+            return dbContext.Players.Where(p => p.Id == id).FirstOrDefaultAsync();
+        }
+
+        public Task<PlayerEntity?> getPlayer(string nickname)
+        {
+            return dbContext.Players.Where(p => p.Nickname == nickname).FirstOrDefaultAsync();
+        }
+
+        public Task<(int nbPage, IEnumerable<PlayerEntity>? players)> getPlayers(int nb, int count, PlayerOrderCriteria orderCriteria = PlayerOrderCriteria.ById)
+        {
+            int nbEl = getNbElements();
+            if (nb > nbEl / count) return Task.FromResult<(int nbPages, IEnumerable<PlayerEntity>? players)>((nbEl / count, null));
+            var tmp = dbContext.Players;
+            switch (orderCriteria)
+            {
+                case PlayerOrderCriteria.ById:
+                    tmp.OrderBy(p => p.Id);
+                    break;
+                case PlayerOrderCriteria.ByNickname:
+                    tmp.OrderBy(p => p.Nickname);
+                    break;
+            }
+            return Task.FromResult<(int nbPages, IEnumerable<PlayerEntity>? players)>((nbEl / count, tmp.Skip((nb - 1) * count).Take(count)));
+        }
+
+        public Task<IEnumerable<PlayerEntity>?> getPlayersInALobby(uint idLobby)
+        {
+            return Task.FromResult<IEnumerable<PlayerEntity>?>(dbContext.Use
+                .Where(u => u.IdLobby == idLobby)
+                .Select(u => u.Player));
+        }
+
+        public Task<PlayerEntity?> removePlayer(PlayerEntity player)
+        {
+            var tmp = dbContext.Players.Where(p => p.Equals(player)).FirstOrDefaultAsync().Result;
+            if (tmp == null) return Task.FromResult<PlayerEntity?>(tmp);
+            dbContext.Players.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<PlayerEntity?>(tmp);
+        }
+
+        public Task<PlayerEntity?> removePlayer(uint id)
+        {
+            var tmp = getPlayer(id).Result;
+            if (tmp == null) return Task.FromResult<PlayerEntity?>(tmp);
+            dbContext.Players.Remove(tmp);
+            dbContext.SaveChanges();
+            return Task.FromResult<PlayerEntity?>(tmp);
+        }
+    }
+}

WebApi/EntityManagers/QuestionEntityManager.cs

@@ -0,0 +1,125 @@
+using DbConnectionLibrairie;
+using Entities;
+using ManagerInterfaces;
+using Microsoft.EntityFrameworkCore;
+using Model;
+using OrderCriterias;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EntityManagers
+{
+    public class QuestionEntityManager(MyDbContext dbContext) : IQuestionManager<QuestionEntity>
+    {
+        private MyDbContext dbContext = dbContext;
+
+        private IQueryable<QuestionEntity> trier(IQueryable<QuestionEntity> query, QuestionOrderCriteria orderCriteria)
+        {
+            switch(orderCriteria)
+            {
+                case QuestionOrderCriteria.ById:
+                    return query.OrderBy(q => q.Id);
+                case QuestionOrderCriteria.ByContent:
+                    return query.OrderBy(q => q.Content);
+                case QuestionOrderCriteria.ByDifficulty:
+                    return query.OrderBy(q => q.Difficulty);
+                case QuestionOrderCriteria.ByNbFalls:
+                    return query.OrderBy(q => q.NbFalls);
+                case QuestionOrderCriteria.ByIdChapter:
+                    return query.OrderBy(q => q.Chapter);
+            }
+            return query;
+        }
+
+        public Task<QuestionEntity> addQuestion(QuestionEntity question)
+        {
+            dbContext.Questions.Add(question);
+            dbContext.SaveChangesAsync();
+            return dbContext.Questions.Where(q => q.Equals(question)).FirstAsync();
+        }
+
+        public Task<IEnumerable<QuestionEntity>> addQuestions(IEnumerable<QuestionEntity> questions)
+        {
+            var tmp = new List<QuestionEntity>();
+            foreach (var q in questions)
+            {
+                tmp.Add(addQuestion(q).Result);
+            }
+            return Task.FromResult<IEnumerable<QuestionEntity>>(tmp);
+        }
+
+        public int getNbElements()
+        {
+            return dbContext.Questions.CountAsync().Result;
+        }
+
+        public Task<QuestionEntity?> getQuestion(uint id)
+        {
+            return Task.FromResult<QuestionEntity?>(dbContext.Questions.Where(q => q.Id == id).FirstOrDefault());
+        }
+
+        public Task<(int nbPages, IEnumerable<QuestionEntity>? questions)> getQuestions(int nb, int count, QuestionOrderCriteria orderCriteria = QuestionOrderCriteria.ById)
+        {
+            int nbEl = getNbElements();
+            if (nb > nbEl / count) return Task.FromResult<(int nbPages, IEnumerable<QuestionEntity>? questions)>((nbEl / count, null));
+            var tmp = trier(dbContext.Questions, orderCriteria);
+            return Task.FromResult<(int nbPages, IEnumerable<QuestionEntity>? questions)>((nbEl / count, tmp.Skip((nb - 1) * count).Take(count)));
+        }
+
+        public Task<(int nbPages, IEnumerable<QuestionEntity>? questions)?> getQuestionsByChapterAndDifficulty(int idChapter, int difficulty, int nb, int count, QuestionOrderCriteria orderCriteria = QuestionOrderCriteria.ById)
+        {
+            if (!dbContext.Chapters.Where(c => c.Id == idChapter).AnyAsync().Result || difficulty < 1 || difficulty > 3)
+                return Task.FromResult<(int nbPages, IEnumerable<QuestionEntity>? questions)?>(null);
+            int nbEl = getNbElements();
+            if (nb > nbEl / count) return Task.FromResult<(int nbPages, IEnumerable<QuestionEntity>? questions)?>((nbEl / count, null));
+            var tmp = trier(dbContext.Questions, orderCriteria);
+            return Task.FromResult<(int nbPages, IEnumerable<QuestionEntity>? questions)?>((nbEl / count, tmp.Skip((nb - 1) * count).Take(count)));
+        }
+
+        public Task<QuestionEntity?> removeQuestion(QuestionEntity question)
+        {
+            var tmp = dbContext.Questions.Where(q => q.Equals(question)).FirstOrDefaultAsync();
+            if (tmp.Result == null) return tmp;
+            dbContext.Questions.Remove(tmp.Result);
+            dbContext.SaveChangesAsync();
+            return tmp;
+        }
+
+        public Task<QuestionEntity?> removeQuestion(uint id)
+        {
+            var tmp = getQuestion(id);
+            if (tmp.Result == null) return tmp;
+            dbContext.Questions.Remove(tmp.Result);
+            dbContext.SaveChangesAsync();
+            return tmp;
+        }
+
+        public Task<QuestionEntity?> updateQuestion(uint id, QuestionEntity question)
+        {
+            var tmp = getQuestion(id);
+            if (tmp.Result == null) return tmp;
+            tmp.Result.Chapter = question.Chapter;
+            tmp.Result.Content = question.Content;
+            tmp.Result.IdChapter = question.IdChapter;
+            tmp.Result.AnswerGood = question.AnswerGood;
+            tmp.Result.Difficulty = question.Difficulty;
+            dbContext.SaveChangesAsync();
+            return tmp;
+        }
+
+        public Task<QuestionEntity?> updateQuestionNbFalls(uint id)
+        {
+            var tmp = getQuestion(id);
+            if (tmp.Result == null) return tmp;
+            tmp.Result.NbFalls++;
+            uint nbFalls = tmp.Result.NbFalls;
+            if (nbFalls == 50) tmp.Result.Difficulty = 2;
+            if (nbFalls == 150) tmp.Result.Difficulty = 3;
+            dbContext.SaveChangesAsync();
+            return tmp;
+        }
+    }
+}

WebApi/ManagerInterfaces/IAnswerManager.cs

@@ -36,7 +36,7 @@ namespace ManagerInterfaces
         /// <returns>
         /// a set of all T answers that answer to this question
         /// </returns>
-        public Task<ReadOnlyCollection<T>?> getAnswersByIdQuestion(uint id);
+        public Task<IEnumerable<T>?> getAnswersByIdQuestion(uint id);
         /// <summary>
         /// modified a T element with an id
         /// </summary>

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, LobbyOrderCriteria orderCriteria = LobbyOrderCriteria.ById);
+        public Task<(int nbPage, IEnumerable<T>? players)> getPlayers(int nb, int count, PlayerOrderCriteria orderCriteria = PlayerOrderCriteria.ById);
         /// <summary>
         /// get a player
         /// </summary>
@@ -72,7 +72,7 @@ namespace ManagerInterfaces
         /// or null if no player match
         /// with this id
         /// </returns>
-        public Task<T?> getPlayer(int id);
+        public Task<T?> getPlayer(uint id);
         /// <summary>
         /// get a player
         /// </summary>
@@ -94,7 +94,7 @@ namespace ManagerInterfaces
         /// delete the lobby) if it is used by
         /// no player
         /// </returns>
-        public Task<IEnumerable<T>?> getPlayersInALobby(int idLobby);
+        public Task<IEnumerable<T>?> getPlayersInALobby(uint idLobby);
         /// <summary>
         /// get the max score of a player in a chapter
         /// </summary>
@@ -105,7 +105,7 @@ namespace ManagerInterfaces
         /// or null if the player or
         /// the chapter does not exist
         /// </returns>
-        public Task<int?> getMaxScorePlayer(int id, int idChapter);
+        public Task<uint?> getMaxScorePlayer(uint id, uint idChapter);
         /// <summary>
         /// get the global max score of a player
         /// </summary>
@@ -114,6 +114,6 @@ namespace ManagerInterfaces
         /// the max score of the player
         /// or null if the player does not exist
         /// </returns>
-        public Task<int?> getMaxScorePlayer(int id);
+        public Task<uint?> getMaxScorePlayer(uint id);
     }
 }

WebApi/ManagerInterfaces/IQuestionManager.cs

@@ -1,5 +1,6 @@
 using OrderCriterias;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
@@ -92,7 +93,7 @@ namespace ManagerInterfaces
         /// </summary>
         /// <param name="questions">a set of questions to add</param>
         /// <returns>questions added</returns>
-        public Task<T> addQuestions(IEnumerable<T> questions);
+        public Task<IEnumerable<T>> addQuestions(IEnumerable<T> questions);
         /// <summary>
         /// get a part of all questions for a given chapter and a given difficulty
         /// </summary>