Merge resolved

API_SQLuedo/API/API.csproj

@@ -21,6 +21,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.0" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
   </ItemGroup>

API_SQLuedo/API/Controllers/BlackListController.cs

@@ -17,7 +17,7 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
     [HttpGet("user/ban/{page:int}/{number:int}")]
     [ProducesResponseType(typeof(IEnumerable<BlackListDto>), 200)]
     [ProducesResponseType(typeof(string), 204)]
-    public IActionResult GetUsers(int page, int number, BlackListOdrerCriteria orderCriteria)
+    public IActionResult GetBannedUsers(int page, int number, BlackListOdrerCriteria orderCriteria)
     {
         var users = blackListService.GetBannedUsers(page, number, orderCriteria).ToList();
         if (users.Count == 0)
@@ -37,7 +37,7 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
     {
         var nb = blackListService.GetNumberOfBannedUsers();
         logger.LogInformation("[INFORMATION] {nb} Email(s) banni(s) trouvé(s)", nb);
-        return Ok(nb);
+        return Ok(new KeyValuePair<string,int>("number",nb));
     }
 
     [HttpPost("user/ban")]
@@ -64,9 +64,8 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
         var success = blackListService.BanUser(username);
         if (success)
         {
-            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été banni pour 2 ans.",
+            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été banni pour 2 ans.", username);
-                username);
+            return Ok(new KeyValuePair<string,bool>("success", true));
-            return Ok();
         }
         else
         {
@@ -84,7 +83,7 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
         if (success)
         {
             logger.LogInformation("[INFORMATION] L'utilisateur avec l'email {email} a été débanni.", email);
-            return Ok();
+            return Ok(new KeyValuePair<string,bool>("success", true));
         }
         else
         {

API_SQLuedo/API/Controllers/InquiriesController.cs

@@ -136,4 +136,14 @@ public class InquiriesController : Controller
         _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
         return NotFound();
     }
+
+    [HttpGet("inquiries/number")]
+    [ProducesResponseType(typeof(InquiryDto), 200)]
+    [ProducesResponseType(typeof(string), 204)]
+    public IActionResult GetNumberOfInquiries()
+    {
+        var nbInquiry = _inquiryDataService.GetNumberOfInquiries();
+        _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
+        return Ok(new KeyValuePair<string, int>("nbInquiries", nbInquiry));
+    }
 }

API_SQLuedo/API/Controllers/InquiryTableController.cs

@@ -0,0 +1,42 @@
+using Asp.Versioning;
+using Dto;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.AspNetCore.Mvc;
+using Shared;
+
+namespace API.Controllers;
+
+[Route("api/v{version:apiVersion}/[controller]")]
+[Authorize]
+[ApiVersion("1.0")]
+[ApiController]
+public class InquiryTableController : Controller
+{
+    private readonly IInquiryTableService<InquiryTableDto> _inquiryTableService;
+
+    private readonly ILogger<InquiryTableController> _logger;
+
+    public InquiryTableController(IInquiryTableService<InquiryTableDto> inquiryTableService, ILogger<InquiryTableController> logger)
+    {
+        _inquiryTableService = inquiryTableService;
+        _logger = logger;
+    }
+
+    [HttpGet("database/{id:int}")]
+    [ProducesResponseType(typeof(string), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult GetDatabaseNameByInquiryById(int id)
+    {
+        try
+        {
+            _logger.LogInformation("[INFORMATION] La base de données pour l'enquête avec l'id {id} a été trouvé.", id);
+            return Ok(new KeyValuePair<string,string>("database", _inquiryTableService.GetDatabaseNameByInquiryId(id)));
+        }
+        catch (ArgumentException)
+        {
+            _logger.LogError("[ERREUR] Aucune base de données trouvée pour l'enquête avec l'id {id}.", id);
+            return NotFound();
+        }
+    }
+}

API_SQLuedo/API/Controllers/LessonsController.cs

@@ -101,9 +101,11 @@ public class LessonsController : Controller
         {
             return BadRequest();
         }
+
         try
         {
-            var createdLesson = _lessonDataService.CreateLesson(dto.Id, dto.Title, dto.LastPublisher, dto.LastEdit ?? DateOnly.FromDateTime(DateTime.Now));
+            var createdLesson = _lessonDataService.CreateLesson(dto.Id, dto.Title, dto.LastPublisher,
+                dto.LastEdit ?? DateOnly.FromDateTime(DateTime.Now));
             if (createdLesson != null)
             {
                 _logger.LogInformation(
@@ -141,6 +143,7 @@ public class LessonsController : Controller
                 id);
             return BadRequest();
         }
+
         if (LessonDto != null)
         {
             _logger.LogInformation("[INFORMATION] La mise à jour de la leçon avec l'id {id} a été effectuée", id);

API_SQLuedo/API/Controllers/NotepadController.cs

@@ -0,0 +1,97 @@
+using Asp.Versioning;
+using Dto;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Shared;
+
+namespace API.Controllers;
+
+[Route("api/v{version:apiVersion}/[controller]")]
+[Authorize]
+[ApiVersion("1.0")]
+[ApiController]
+public class NotepadController : Controller
+{
+    private readonly INotepadService<NotepadDto> _notepadDataService;
+
+    private readonly ILogger<NotepadController> _logger;
+
+    public NotepadController(INotepadService<NotepadDto> notepadService, ILogger<NotepadController> logger)
+    {
+        _notepadDataService = notepadService;
+        _logger = logger;
+    }
+
+    [HttpGet("notepad/{userId:int}/{inquiryId:int}")]
+    [ProducesResponseType(typeof(NotepadDto), 200)]
+    [ProducesResponseType(typeof(void), 404)]
+    public IActionResult GetNotepadByUserAndInquiryById(int userId, int inquiryId)
+    {
+        try
+        {
+            _logger.LogInformation(
+                "[INFORMATION] Le bloc-notes de l'utilisateur avec l'id {id} et l'enquête avec l'id {idInquiry} a été trouvé.",
+                userId, inquiryId);
+            return Ok(_notepadDataService.GetNotepadFromUserAndInquiryId(userId,inquiryId));
+        }
+        catch (ArgumentException)
+        {
+            _logger.LogError(
+                "[ERREUR] Aucun bloc-notes trouvé pour l'utilisateur avec l'id {id} et l'enquête avec l'id {inquiryId}.",
+                userId, inquiryId);
+            return NotFound();
+        }
+    }
+    
+    [HttpPost("notepad")]
+    [ProducesResponseType(typeof(void), 200)]
+    [ProducesResponseType(typeof(void), 404)]
+    public IActionResult SetNotepadByUserAndInquiryById([FromBody] NotepadDto notepad)
+    {
+        try
+        {
+            if (notepad.InquiryId < 0 || notepad.UserId < 0 || notepad.Notes == null)
+            {
+                return BadRequest();
+            }
+            _notepadDataService.SetNotepadFromUserAndInquiryId(notepad.UserId, notepad.InquiryId, notepad.Notes);
+            _logger.LogInformation(
+                "[INFORMATION] Le bloc-notes de l'utilisateur avec l'id {id} et l'enquête avec l'id {idInquiry} a été créé.",
+                notepad.UserId, notepad.InquiryId);
+            return Ok();
+        }
+        catch (ArgumentException)
+        {
+            _logger.LogError(
+                "[ERREUR] Aucun bloc-notes n'a pu être créé pour l'utilisateur avec l'id {id} et l'enquête avec l'id {inquiryId}.",
+                notepad.UserId, notepad.InquiryId);
+            return NotFound();
+        }
+    }
+    
+    [HttpPut("notepad")]
+    [ProducesResponseType(typeof(void), 203)]
+    [ProducesResponseType(typeof(void), 404)]
+    public IActionResult UpdateNotepadByUserAndInquiryById([FromBody] NotepadDto notepad)
+    {
+        try
+        {
+            if (notepad.InquiryId < 0 || notepad.UserId < 0 || notepad.Notes == null)
+            {
+                return BadRequest();
+            }
+            _notepadDataService.UpdateNotepadFromUserAndInquiryId(notepad.UserId, notepad.InquiryId, notepad.Notes);
+            _logger.LogInformation(
+                "[INFORMATION] Le bloc-notes de l'utilisateur avec l'id {id} et l'enquête avec l'id {idInquiry} a été mis à jour.",
+                notepad.UserId, notepad.InquiryId);
+            return Ok();
+        }
+        catch (ArgumentException)
+        {
+            _logger.LogError(
+                "[ERREUR] Aucun bloc-notes n'a pu être mis à jour pour l'utilisateur avec l'id {id} et l'enquête avec l'id {inquiryId}.",
+                notepad.UserId, notepad.InquiryId);
+            return NotFound();
+        }
+    }
+}

API_SQLuedo/API/Controllers/ParagraphsController.cs

@@ -97,7 +97,8 @@ public class ParagraphsController : Controller
     [ProducesResponseType(typeof(string), 400)]
     public IActionResult CreateParagraph([FromBody] ParagraphDto dto)
     {
-        if (dto.ContentTitle == null || dto.ContentContent == null || dto.Title == null || dto.Content == null || dto.Info == null || dto.Query == null ||
+        if (dto.ContentTitle == null || dto.ContentContent == null || dto.Title == null || dto.Content == null ||
+            dto.Info == null || dto.Query == null ||
             dto.Comment == null)
         {
             return BadRequest();
@@ -107,7 +108,8 @@ public class ParagraphsController : Controller
             "[INFORMATION] Un paragraphe a été créé : title - {title}, content - {content}, info - {info}, query - {query}, comment - {comment}",
             dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
         return Created(nameof(GetParagraphs),
-            _paragraphDataService.CreateParagraph(dto.ContentTitle, dto.ContentContent,dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment,
+            _paragraphDataService.CreateParagraph(dto.ContentTitle, dto.ContentContent, dto.Title, dto.Content,
+                dto.Info, dto.Query, dto.Comment,
                 dto.LessonId));
     }
 

API_SQLuedo/API/Controllers/QueryController.cs

@@ -0,0 +1,65 @@
+using Dto;
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Shared;
+using Model.OrderCriteria;
+
+namespace API.Controllers
+{
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Authorize]
+    [ApiVersion("1.0")]
+    [ApiController]
+    public class QueryController(ILogger<QueryController> logger, IQueryService<QueryDto> queryService) : ControllerBase
+    {
+        [HttpPost("{database}/execute")]
+        [ProducesResponseType(typeof(QueryDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult ExecuteQuery([FromBody]string query, string database)
+        {
+            var queryResult = queryService.ExecuteQuery(query, database);
+            if (queryResult == null)
+            {
+                logger.LogError("[ERREUR] La requête n'a rien renvoyé.");
+                return StatusCode(204);
+            }
+
+            logger.LogInformation("[INFORMATION] La requête a renvoyé : {result} ", queryResult);
+            return Ok(queryResult);
+        }
+
+        [HttpGet("{database}/Tables")]
+        [ProducesResponseType(typeof(QueryDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetTables(string database)
+        {
+            var queryResult = queryService.GetTables(database);
+            if (queryResult == null)
+            {
+                logger.LogError("[ERREUR] La requête n'a rien renvoyé.");
+                return StatusCode(204);
+            }
+
+            logger.LogInformation("[INFORMATION] La requête a renvoyé : {result} ", queryResult);
+            return Ok(queryResult);
+        }
+
+
+        [HttpGet("{database}/{table}/Columns")]
+        [ProducesResponseType(typeof(QueryDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetColumns(string database,string table)
+        {
+            var queryResult = queryService.GetColumns(database,table);
+            if (queryResult == null)
+            {
+                logger.LogError("[ERREUR] La requête n'a rien renvoyé.");
+                return StatusCode(204);
+            }
+
+            logger.LogInformation("[INFORMATION] La requête a renvoyé : {result} ", queryResult);
+            return Ok(queryResult);
+        }
+    }
+}

API_SQLuedo/API/Controllers/SolutionController.cs

@@ -0,0 +1,43 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Dto;
+using Model.OrderCriteria;
+using Shared;
+using Asp.Versioning;
+
+namespace API.Controllers
+{
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Authorize]
+    [ApiVersion("1.0")]
+    [ApiController]
+    public class SolutionController : Controller
+    {
+        private readonly ISolutionService<SolutionDto> _solutionDataService;
+
+        private readonly ILogger<SolutionController> _logger;
+
+        public SolutionController(ISolutionService<SolutionDto> solutionDataService, ILogger<SolutionController> logger)
+        {
+            _solutionDataService = solutionDataService;
+            _logger = logger;
+        }
+
+        [HttpGet("solution/{id:int}")]
+        [ProducesResponseType(typeof(SolutionDto), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetSolutionByInquiryById(int id)
+        {
+            try
+            {
+                _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été trouvé.", id);
+                return Ok(_solutionDataService.GetSolutionByInquiryId(id));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+                return NotFound();
+            }
+        }
+    }
+}

API_SQLuedo/API/Controllers/UserController.cs

@@ -8,6 +8,7 @@ using Model.OrderCriteria;
 namespace API.Controllers;
 
 [Route("api/v{version:apiVersion}/[controller]")]
+[Authorize]
 [ApiVersion("1.0")]
 [ApiController]
 public class UsersController(ILogger<UsersController> logger, IUserService<UserDto> userService) : ControllerBase
@@ -93,6 +94,7 @@ public class UsersController(ILogger<UsersController> logger, IUserService<UserD
             return NotFound("Utilisateur non trouvé !");
         }
     }
+
     [HttpGet("user/email/{email}")]
     [ProducesResponseType(typeof(UserDto), 200)]
     [ProducesResponseType(typeof(string), 404)]
@@ -136,7 +138,8 @@ public class UsersController(ILogger<UsersController> logger, IUserService<UserD
         var success = userService.DeleteUserByUsername(username);
         if (success)
         {
-            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.", username);
+            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.",
+                username);
             return Ok();
         }
         else
@@ -149,6 +152,8 @@ public class UsersController(ILogger<UsersController> logger, IUserService<UserD
     [HttpPost]
     [ProducesResponseType(typeof(UserDto), 201)]
     [ProducesResponseType(typeof(string), 400)]
+    [ProducesResponseType(typeof(string), 409)]
+    [ProducesResponseType(typeof(string), 410)]
     public IActionResult CreateUser([FromBody] UserDto dto)
     {
         if (dto.Username == null || dto.Password == null || dto.Email == null)
@@ -156,6 +161,16 @@ public class UsersController(ILogger<UsersController> logger, IUserService<UserD
             return BadRequest();
         }
 
+        if (userService.IsEmailTaken(dto.Email))
+        {
+            return StatusCode(409, "Email déjà utilisé");
+        }
+
+        if (userService.IsUsernameTaken(dto.Username))
+        {
+            return StatusCode(410, "Username déjà utilisé");
+        }
+
         // return Ok(userService.CreateUser(username, password, email, isAdmin));
         logger.LogInformation(
             "[INFORMATION] Un utilisateur a été créé : username - {username}, password - {password}, email - {email}, isAdmin - {isAdmin}",
@@ -168,9 +183,10 @@ public class UsersController(ILogger<UsersController> logger, IUserService<UserD
     [ProducesResponseType(typeof(UserDto), 200)]
     [ProducesResponseType(typeof(string), 400)]
     [ProducesResponseType(typeof(string), 404)]
-    public IActionResult UpdateUser(int id, [FromBody] UserDto UserDto)
+    [ProducesResponseType(typeof(string), 409)]
+    public IActionResult UpdateUser(int id, [FromBody] UserDto userDto)
     {
-        if (id != UserDto.Id)
+        if (id != userDto.Id)
         {
             logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
             return BadRequest();
@@ -183,14 +199,37 @@ public class UsersController(ILogger<UsersController> logger, IUserService<UserD
             return BadRequest();
         }
 
-        if (UserDto != null)
+        if (userDto.Username == userService.GetUserById(id).Username && !userService.IsEmailTaken(userDto.Email)
+            || (userDto.Email == userService.GetUserById(id).Email &&
+                !userService.IsUsernameTaken(userDto.Username))
+            || (!userService.IsEmailTaken(userDto.Email) && !userService.IsUsernameTaken(userDto.Username)))
         {
             logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
                 id);
-            return Ok(userService.UpdateUser(id, UserDto));
+            return Ok(userService.UpdateUser(id, userDto));
         }
 
-        logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
+        logger.LogError("[ERREUR] Email ou nom d'utilisateur déjà utilisé");
+        return StatusCode(409, "Email ou nom d'utilisateur déjà utilisé");
+    }
+
+    [HttpPut("user/promote/{id:int}")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult PromoteUser(int id)
+    {
+        var userPromoted = userService.GetUserById(id);
+        if (userPromoted != null)
+        {
+            userPromoted = userService.PromoteUser(id);
+            logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} a été effectuée");
+            return Ok(userPromoted);
+        }
+        else
+        {
+            logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} à échouée",
+                id);
             return NotFound();
         }
     }
+}

API_SQLuedo/API/Program.cs

@@ -13,12 +13,14 @@ using Shared;
 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();
 
+builder.Services.AddScoped<IQueryService<QueryDto>, QueryDataServiceApi>();
+
 builder.Services.AddScoped<IUserService<UserEntity>, UserDataService>();
 builder.Services.AddScoped<IUserService<UserDto>, UserDataServiceApi>();
 
@@ -28,6 +30,12 @@ builder.Services.AddScoped<IBlackListService<BlackListDto>, BlackListDataService
 builder.Services.AddScoped<IInquiryService<InquiryEntity>, InquiryDataService>();
 builder.Services.AddScoped<IInquiryService<InquiryDto>, InquiryDataServiceApi>();
 
+builder.Services.AddScoped<ISolutionService<SolutionEntity>, SolutionDataService>();
+builder.Services.AddScoped<ISolutionService<SolutionDto>, SolutionDataServiceAPI>();
+
+builder.Services.AddScoped<IInquiryTableService<InquiryTableEntity>, InquiryTableDataService>();
+builder.Services.AddScoped<IInquiryTableService<InquiryTableDto>, InquiryTableDataServiceAPI>();
+
 builder.Services.AddScoped<IParagraphService<ParagraphEntity>, ParagraphDataService>();
 builder.Services.AddScoped<IParagraphService<ParagraphDto>, ParagraphDataServiceApi>();
 
@@ -37,7 +45,10 @@ builder.Services.AddScoped<ISuccessService<SuccessDto>, SuccessDataServiceApi>()
 builder.Services.AddScoped<ILessonService<LessonEntity>, LessonDataService>();
 builder.Services.AddScoped<ILessonService<LessonDto>, LessonDataServiceApi>();
 
-builder.Services.AddDbContext<UserDbContext>(options =>
+builder.Services.AddScoped<INotepadService<NotepadEntity>, NotepadDataService>();
+builder.Services.AddScoped<INotepadService<NotepadDto>, NotepadDataServiceAPI>();
+
+builder.Services.AddDbContext<DbContext, UserDbContext>(options =>
 {
     if (builder.Environment.IsProduction())
     {
@@ -103,9 +114,29 @@ builder.Services.AddSwaggerGen(option =>
         }
     });
 });
+builder.Services.AddCors(options =>
+{
+    options.AddPolicy("AllowSpecificOrigin",
+        builder =>
+        {
+            builder.WithOrigins("https://localhost:7171")
+                .AllowAnyMethod()
+                .AllowAnyHeader();
+        });
+});
+
+var configuration = new ConfigurationBuilder()
+    .SetBasePath(Directory.GetCurrentDirectory())
+    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
+    .Build();
+
+builder.Services.AddSingleton(configuration);
+
 
 var app = builder.Build();
 
+app.UseCors("AllowSpecificOrigin");
+
 // Création de l'utilisateur admin pour la base de données Identity
 
 using (var scope = app.Services.CreateScope())

API_SQLuedo/API/Service/InquiryDataServiceAPI.cs

@@ -29,6 +29,11 @@ public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService
         return inquiries.Select(i => i.FromEntityToDto()).ToList();
     }
 
+    public int GetNumberOfInquiries()
+    {
+        return inquiryService.GetNumberOfInquiries();
+    }
+
     public InquiryDto GetInquiryById(int id) => inquiryService.GetInquiryById(id).FromEntityToDto();
 
     public InquiryDto GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title).FromEntityToDto();

API_SQLuedo/API/Service/InquiryTableDataServiceAPI.cs

@@ -0,0 +1,13 @@
+using Dto;
+using Entities;
+using Shared;
+
+namespace API.Service;
+
+public class InquiryTableDataServiceAPI(IInquiryTableService<InquiryTableEntity> inquiryTableService) : IInquiryTableService<InquiryTableDto>
+{
+    public string GetDatabaseNameByInquiryId(int id)
+    {
+        return inquiryTableService.GetDatabaseNameByInquiryId(id);
+    }
+}

API_SQLuedo/API/Service/LessonDataServiceAPI.cs

@@ -14,6 +14,11 @@ public class LessonDataServiceApi(ILessonService<LessonEntity> lessonService) :
         return lessonsEntities.Select(e => e.FromEntityToDto()).ToList();
     }
 
+    public int GetNumberOfLessons()
+    {
+        return lessonService.GetNumberOfLessons();
+    }
+
     public LessonDto GetLessonById(int id) => lessonService.GetLessonById(id).FromEntityToDto();
 
     public LessonDto GetLessonByTitle(string title) => lessonService.GetLessonByTitle(title).FromEntityToDto();

API_SQLuedo/API/Service/NotepadDataServiceAPI.cs

@@ -0,0 +1,24 @@
+using Dto;
+using Entities;
+using Shared;
+using Shared.Mapper;
+
+namespace API.Service;
+
+public class NotepadDataServiceAPI(INotepadService<NotepadEntity> notepadService) : INotepadService<NotepadDto>
+{
+    public NotepadDto GetNotepadFromUserAndInquiryId(int userId, int inquiryId)
+    {
+        return notepadService.GetNotepadFromUserAndInquiryId(userId, inquiryId).FromEntityToDto();
+    }
+
+    public void SetNotepadFromUserAndInquiryId(int userId, int inquiryId, string notes)
+    {
+        notepadService.SetNotepadFromUserAndInquiryId(userId,inquiryId,notes);
+    }
+
+    public void UpdateNotepadFromUserAndInquiryId(int userId, int inquiryId, string notes)
+    {
+        notepadService.UpdateNotepadFromUserAndInquiryId(userId,inquiryId,notes);
+    }
+}

API_SQLuedo/API/Service/ParagraphDataServiceAPI.cs

@@ -15,6 +15,11 @@ public class ParagraphDataServiceApi(IParagraphService<ParagraphEntity> paragrap
         return paragraphsEntities.Select(e => e.FromEntityToDto()).ToList();
     }
 
+    public IEnumerable<ParagraphDto> GetParagraphsByLessonId(int lessonId)
+    {
+        return paragraphService.GetParagraphsByLessonId(lessonId).Select(p => p.FromEntityToDto());
+    }
+
     public ParagraphDto GetParagraphById(int id) => paragraphService.GetParagraphById(id).FromEntityToDto();
 
     public ParagraphDto GetParagraphByTitle(string title) =>

API_SQLuedo/API/Service/QueryDataServiceApi.cs

@@ -0,0 +1,177 @@
+using Dto;
+using Entities;
+using Model.OrderCriteria;
+using Npgsql;
+using Shared;
+using Shared.Mapper;
+using Microsoft.Extensions.Configuration;
+using System.Text;
+using Newtonsoft.Json;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+
+namespace API.Service;
+
+public class QueryDataServiceApi : IQueryService<QueryDto>{
+    private readonly IConfiguration _configuration;
+
+    public QueryDataServiceApi(IConfiguration configuration)
+    {
+        _configuration = configuration;
+    }
+    public QueryDto ExecuteQuery(string query, string database)
+    {
+        string connectionString = _configuration.GetConnectionString("DefaultConnection");
+        connectionString = connectionString.Replace("{database}", database);
+
+        if (string.IsNullOrEmpty(database))
+        {
+            return new QueryDto { Result = "Le nom de la base de données est requis." };
+        }
+
+        try
+        {
+            using (NpgsqlConnection connection = new NpgsqlConnection(connectionString))
+            {
+                connection.Open();
+                using (NpgsqlCommand command = new NpgsqlCommand(query, connection))
+                {
+                    using (NpgsqlDataReader reader = command.ExecuteReader())
+                    {
+                        List<Dictionary<string, object>> resultList = new List<Dictionary<string, object>>();
+
+
+                        List<string> columnNames = new List<string>();
+                        for (int i = 0; i < reader.FieldCount; i++)
+                        {
+                            columnNames.Add(reader.GetName(i));
+                        }
+
+                        while (reader.Read())
+                        {
+                            Dictionary<string, object> row = new Dictionary<string, object>();
+                            for (int i = 0; i < reader.FieldCount; i++)
+                            {
+                                row[columnNames[i]] = reader[i].ToString();
+                            }
+
+                            resultList.Add(row);
+                        }
+
+                        string resultJson = JsonConvert.SerializeObject(resultList);
+
+                        QueryDto queryDto = new QueryDto { Result = resultJson };
+                        return queryDto;
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            return new QueryDto { Result = ex.Message };
+        }
+    }
+
+    public QueryDto GetTables(string database)
+    {
+        string connectionString = _configuration.GetConnectionString("DefaultConnection");
+        connectionString = connectionString.Replace("{database}", database);
+
+        try
+        {
+            using (NpgsqlConnection connection = new NpgsqlConnection(connectionString))
+            {
+                connection.Open();
+                using (NpgsqlCommand command = new NpgsqlCommand())
+                {
+                    command.Connection = connection;
+                    // Donner et exclure les bonnes permissions au rôle en question
+
+                    // GRANT SELECT ON TABLE information_schema.tables TO votre_utilisateur;
+
+                    // GRANT SELECT ON TABLE information_schema.columns TO votre_utilisateur;
+
+                    // REVOKE ALL ON SCHEMA information_schema FROM PUBLIC;
+
+                    command.CommandText =
+                        "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';";
+
+                    using (NpgsqlDataReader reader = command.ExecuteReader())
+                    {
+                        List<string> tableNames = new List<string>();
+
+                        while (reader.Read())
+                        {
+                            tableNames.Add(reader["table_name"].ToString());
+                        }
+
+                        Dictionary<string, string> tablesDict = new Dictionary<string, string>();
+                        foreach (string tableName in tableNames)
+                        {
+                            tablesDict[tableName] = tableName;
+                        }
+
+                        string tablesJson = JsonConvert.SerializeObject(tablesDict);
+
+                        QueryDto queryDto = new QueryDto { Result = tablesJson };
+                        return queryDto;
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            return new QueryDto { Result = ex.Message };
+        }
+    }
+
+    public QueryDto GetColumns(string database, string table)
+    {
+        string connectionString = _configuration.GetConnectionString("DefaultConnection");
+        connectionString = connectionString.Replace("{database}", database);
+
+        using (NpgsqlConnection connection = new NpgsqlConnection(connectionString))
+            {
+                connection.Open();
+                using (NpgsqlCommand command = new NpgsqlCommand())
+                {
+                    command.Connection = connection;
+                    // Donner et exclure les bonnes permissions au rôle en question
+
+                    //GRANT SELECT ON TABLE information_schema.tables TO votre_utilisateur;
+
+                    //GRANT SELECT ON TABLE information_schema.columns TO votre_utilisateur;
+
+                    //REVOKE ALL ON SCHEMA information_schema FROM PUBLIC;
+
+                    command.CommandText =
+                        $"SELECT column_name FROM information_schema.columns WHERE table_name = '{table}';";
+
+                    Console.WriteLine(command.CommandText);
+
+                    using (NpgsqlDataReader reader = command.ExecuteReader())
+                    {
+                        List<string> columnsNames = new List<string>();
+
+                        while (reader.Read())
+                        {
+                            columnsNames.Add(reader["column_name"].ToString());
+                        }
+
+                        Dictionary<string, string> columnsDict = new Dictionary<string, string>();
+                        foreach (string colName in columnsNames)
+                        {
+                            columnsDict[colName] = colName;
+                        }
+
+                        string tablesJson = JsonConvert.SerializeObject(columnsDict);
+
+                        Console.WriteLine(tablesJson);
+
+                        QueryDto queryDto = new QueryDto { Result = tablesJson };
+                        return queryDto;
+                    }
+                }
+            }
+        
+    }
+}

API_SQLuedo/API/Service/SolutionDataServiceAPI.cs

@@ -0,0 +1,14 @@
+using Dto;
+using Entities;
+using Shared;
+using Shared.Mapper;
+
+namespace API.Service;
+
+public class SolutionDataServiceAPI(ISolutionService<SolutionEntity> solutionService) : ISolutionService<SolutionDto>
+{
+    public SolutionDto GetSolutionByInquiryId(int id)
+    {
+        return solutionService.GetSolutionByInquiryId(id).FromEntityToDto();
+    }
+}

API_SQLuedo/API/Service/UserDataServiceAPI.cs

@@ -38,4 +38,11 @@ public class UserDataServiceApi(IUserService<UserEntity> userService) : IUserSer
 
     public UserDto CreateUser(string username, string password, string email, bool isAdmin) =>
         userService.CreateUser(username, password, email, isAdmin).FromEntityToDto();
+
+    public bool IsEmailTaken(string email) => userService.IsEmailTaken(email);
+
+    public bool IsUsernameTaken(string username) => userService.IsUsernameTaken(username);
+
+    public UserDto PromoteUser(int id) =>
+        userService.PromoteUser(id).FromEntityToDto();
 }

API_SQLuedo/API/appsettings.json

@@ -5,5 +5,8 @@
       "Microsoft.AspNetCore": "Warning"
     }
   },
-  "AllowedHosts": "*"
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "DefaultConnection": "Host=localhost;Username=admin;Password=motdepasse;Database={database}"
+  }
 }

API_SQLuedo/DbDataManager/Service/InquiryDataService.cs

@@ -26,7 +26,7 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
         {
             number = 10;
         }
-        IQueryable<InquiryEntity> query = DbContext.Inquiries.Skip((page - 1) * number).Take(number);
+        IQueryable<InquiryEntity> query = DbContext.Inquiries;
         switch (orderCriteria)
         {
             case InquiryOrderCriteria.None:
@@ -40,14 +40,23 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
             case InquiryOrderCriteria.ByIsUser:
                 query = query.OrderBy(s => s.IsUser);
                 break;
+            case InquiryOrderCriteria.ById:
+                query = query.OrderBy(s => s.Id);
+                break;
             default:
                 break;
         }
 
+        query = query.Skip((page - 1) * number).Take(number);
         var inquiries = query.ToList();
         return inquiries;
     }
 
+    public int GetNumberOfInquiries()
+    {
+        return DbContext.Inquiries.Count();
+    }
+
     public InquiryEntity GetInquiryById(int id)
     {
         var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Id == id);
@@ -92,7 +101,7 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
         }
 
         DbContext.Inquiries.Remove(inquiryEntity);
-        DbContext.SaveChangesAsync();
+        DbContext.SaveChanges();
         return true;
     }
 

API_SQLuedo/DbDataManager/Service/InquiryTableDataService.cs

@@ -0,0 +1,27 @@
+using DbContextLib;
+using Entities;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class InquiryTableDataService : IInquiryTableService<InquiryTableEntity>
+{
+    private UserDbContext DbContext { get; set; }
+
+    public InquiryTableDataService(UserDbContext context)
+    {
+        DbContext = context;
+        context.Database.EnsureCreated();
+    }
+    
+    public string GetDatabaseNameByInquiryId(int id)
+    {
+        var inquiryTable = DbContext.InquiryTables.FirstOrDefault(i => i.OwnerId == id);
+        if (inquiryTable == null)
+        {
+            throw new ArgumentException($"Erreur, impossible de trouver l'objet InquiryTable pour l'enquête d'id {id}",
+                nameof(id));
+        }
+        return inquiryTable.DatabaseName;
+    }
+}

API_SQLuedo/DbDataManager/Service/LessonDataService.cs

@@ -29,7 +29,7 @@ public class LessonDataService : ILessonService<LessonEntity>
             number = 10;
         }
 
-        IQueryable<LessonEntity> query = DbContext.Lessons.Skip((page - 1) * number).Take(number);
+        IQueryable<LessonEntity> query = DbContext.Lessons;
         switch (orderCriteria)
         {
             case LessonOrderCriteria.None:
@@ -43,14 +43,25 @@ public class LessonDataService : ILessonService<LessonEntity>
             case LessonOrderCriteria.ByLastEdit:
                 query = query.OrderBy(s => s.LastEdit);
                 break;
+            case LessonOrderCriteria.ById:
+                query = query.OrderBy(s => (int) s.Id);
+                break;
             default:
                 break;
         }
 
+        query = query.Skip((page - 1) * number).Take(number);
+        
+
         var lessons = query.ToList();
         return lessons;
     }
 
+    public int GetNumberOfLessons()
+    {
+        return DbContext.Lessons.Count();
+    }
+
     public LessonEntity GetLessonById(int id)
     {
         var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);

API_SQLuedo/DbDataManager/Service/NotepadDataService.cs

@@ -0,0 +1,63 @@
+using DbContextLib;
+using Entities;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class NotepadDataService : INotepadService<NotepadEntity>
+{
+    private UserDbContext DbContext { get; set; }
+
+    public NotepadDataService(UserDbContext context)
+    {
+        DbContext = context;
+        context.Database.EnsureCreated();
+    }
+    public NotepadEntity GetNotepadFromUserAndInquiryId(int userId, int inquiryId)
+    {
+        var user = DbContext.Users.FirstOrDefault(u => u.Id == userId);
+        if (user == null)
+        {
+            throw new ArgumentException("Erreur, aucun utilisateur ne possède l'ID fourni");
+        }
+        var inquiry = DbContext.Inquiries.FirstOrDefault(i => i.Id == inquiryId);
+        if (inquiry == null)
+        {
+            throw new ArgumentException("Erreur, aucune enquête ne possède l'ID fourni");
+        }
+        var notepad = DbContext.Notepads.FirstOrDefault(n => n.UserId == userId && n.InquiryId == inquiryId);
+        if (notepad == null)
+        {
+            throw new ArgumentException("Erreur, aucun bloc-notes n'existe pour l'utilisateur et l'enquête donnés");
+        }
+        return notepad;
+    }
+
+    public void SetNotepadFromUserAndInquiryId(int userId, int inquiryId, string notes)
+    {
+        var user = DbContext.Users.FirstOrDefault(u => u.Id == userId);
+        if (user == null)
+        {
+            throw new ArgumentException("Erreur, aucun utilisateur ne possède l'ID fourni");
+        }
+        var inquiry = DbContext.Inquiries.FirstOrDefault(i => i.Id == inquiryId);
+        if (inquiry == null)
+        {
+            throw new ArgumentException("Erreur, aucune enquête ne possède l'ID fourni");
+        }
+        var notepad = DbContext.Notepads.FirstOrDefault(n => n.UserId == userId && n.InquiryId == inquiryId);
+        if (notepad != null)
+        {
+            throw new ArgumentException("Erreur, un bloc-notes existe déjà pour l'utilisateur et l'enquête donnés");
+        }
+        DbContext.Notepads.Add(new NotepadEntity { UserId = userId, InquiryId = inquiryId, Notes = notes });
+        DbContext.SaveChangesAsync();
+    }
+
+    public void UpdateNotepadFromUserAndInquiryId(int userId, int inquiryId, string notes)
+    {
+        var notepad = GetNotepadFromUserAndInquiryId(userId, inquiryId);
+        notepad.Notes = notes;
+        DbContext.SaveChangesAsync();
+    }
+}

API_SQLuedo/DbDataManager/Service/ParagraphDataService.cs

@@ -54,6 +54,17 @@ public class ParagraphDataService : IParagraphService<ParagraphEntity>
         return paragraphs;
     }
 
+    public IEnumerable<ParagraphEntity> GetParagraphsByLessonId(int lessonId)
+    {
+        var lesson = DbContext.Lessons.FirstOrDefault(l => l.Id == lessonId);
+        if (lesson == null)
+        {
+            throw new ArgumentException($"Erreur, la leçon ayant pour id {lessonId} est introuvable.");
+        }
+        var list = DbContext.Paragraphs.Where(p => p.LessonId == lessonId);
+        return list;
+    }
+
     public ParagraphEntity GetParagraphById(int id)
     {
         var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);

API_SQLuedo/DbDataManager/Service/SolutionDataService.cs

@@ -0,0 +1,26 @@
+using DbContextLib;
+using Entities;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class SolutionDataService : ISolutionService<SolutionEntity>
+{
+    private UserDbContext DbContext { get; set; }
+
+    public SolutionDataService(UserDbContext context)
+    {
+        DbContext = context;
+        context.Database.EnsureCreated();
+    }
+
+    public SolutionEntity GetSolutionByInquiryId(int id)
+    {
+        var solution = DbContext.Solutions.FirstOrDefault(s => s.OwnerId == id);
+        if (solution == null)
+        {
+            throw new ArgumentException($"Impossible de trouver la solution pour l'enquête d'id {id}", nameof(id));
+        }
+        return solution;
+    }
+}

API_SQLuedo/DbDataManager/Service/UserDataService.cs

@@ -58,7 +58,8 @@ public class UserDataService : IUserService<UserEntity>
         {
             number = 10;
         }
-        IQueryable<UserEntity> query = DbContext.Users.Skip((page - 1) * number).Take(number);
+
+        IQueryable<UserEntity> query = DbContext.Users;
         switch (orderCriteria)
         {
             case UserOrderCriteria.None:
@@ -78,6 +79,7 @@ public class UserDataService : IUserService<UserEntity>
             default:
                 break;
         }
+        query = query.Skip((page - 1) * number).Take(number);
 
         var users = query.ToList();
         return users;
@@ -142,7 +144,6 @@ public class UserDataService : IUserService<UserEntity>
         {
             return false;
         }
-
         DbContext.Users.Remove(userEntity);
         DbContext.SaveChangesAsync();
         return true;
@@ -179,4 +180,24 @@ public class UserDataService : IUserService<UserEntity>
         DbContext.SaveChangesAsync();
         return newUserEntity;
     }
+
+    public bool IsEmailTaken(string email)
+    {
+        var isEmail = DbContext.Users.Any(u => u.Email == email);
+        return isEmail;
+    }
+
+    public bool IsUsernameTaken(string username)
+    {
+        var isUsername = DbContext.Users.Any(u => u.Username == username);
+        return isUsername;
+    }
+
+    public UserEntity PromoteUser(int id)
+    {
+        var userEdit = GetUserById(id);
+        var newUserEntity = UpdateUser(id,new UserEntity{Id = id,Username = userEdit.Username,Password = userEdit.Password,Email = userEdit.Email,IsAdmin = true});
+        DbContext.SaveChangesAsync();
+        return newUserEntity;
+    }
 }

API_SQLuedo/Dto/QueryDTO.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Dto
+{
+    public class QueryDto
+    {
+        public string Result { get; set; }
+    }
+}

API_SQLuedo/EntityFramework/UserEntity.cs

@@ -1,8 +1,11 @@
 using System.ComponentModel.DataAnnotations.Schema;
+using Microsoft.EntityFrameworkCore;
 
 namespace Entities;
 
 [Table("User")]
+[Index(nameof(Username), IsUnique = true)]
+[Index(nameof(Email), IsUnique = true)]
 public class UserEntity
 {
     public int Id { get; set; }

API_SQLuedo/Model/OrderCriteria/InquiryOrderCriteria.cs

@@ -5,5 +5,6 @@ public enum InquiryOrderCriteria
     None,
     ByTitle,
     ByDescription,
-    ByIsUser
+    ByIsUser,
+    ById
 }

API_SQLuedo/Model/OrderCriteria/LessonOrderCriteria.cs

@@ -5,5 +5,6 @@ public enum LessonOrderCriteria
     None,
     ByTitle,
     ByLastPublisher,
-    ByLastEdit
+    ByLastEdit,
+    ById
 }

API_SQLuedo/Shared/IInquiryService.cs

@@ -5,6 +5,7 @@ namespace Shared;
 public interface IInquiryService<TInquiry>
 {
     public IEnumerable<TInquiry> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria);
+    public int GetNumberOfInquiries();
     public TInquiry GetInquiryById(int id);
     public TInquiry GetInquiryByTitle(string title);
     public bool DeleteInquiry(int id);

API_SQLuedo/Shared/IInquiryTableService.cs

@@ -0,0 +1,6 @@
+namespace Shared;
+
+public interface IInquiryTableService<TInquiryTable>
+{
+    public string GetDatabaseNameByInquiryId(int id);
+}

API_SQLuedo/Shared/ILessonService.cs

@@ -5,6 +5,7 @@ namespace Shared;
 public interface ILessonService<TLesson>
 {
     public IEnumerable<TLesson> GetLessons(int page, int number, LessonOrderCriteria orderCriteria);
+    public int GetNumberOfLessons();
     public TLesson GetLessonById(int id);
     public TLesson GetLessonByTitle(string title);
     public bool DeleteLesson(int id);

API_SQLuedo/Shared/INotepadService.cs

@@ -0,0 +1,10 @@
+namespace Shared;
+
+public interface INotepadService<TNotepad>
+{
+    public TNotepad GetNotepadFromUserAndInquiryId(int userId, int inquiryId);
+
+    public void SetNotepadFromUserAndInquiryId(int userId, int inquiryId, string notes);
+
+    public void UpdateNotepadFromUserAndInquiryId(int userId, int inquiryId, string notes);
+}

API_SQLuedo/Shared/IParagraphService.cs

@@ -5,6 +5,7 @@ namespace Shared
     public interface IParagraphService<TParagraph>
     {
         public IEnumerable<TParagraph> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria);
+        public IEnumerable<TParagraph> GetParagraphsByLessonId(int lessonId);
         public TParagraph GetParagraphById(int id);
         public TParagraph GetParagraphByTitle(string title);
         public bool DeleteParagraph(int id);

API_SQLuedo/Shared/IQueryService.cs

@@ -0,0 +1,18 @@
+using Microsoft.AspNetCore.Mvc;
+using Model.OrderCriteria;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Dto;
+
+namespace Shared
+{
+    public interface IQueryService<TQuery>
+    {
+        public TQuery ExecuteQuery(string query, string database);
+        public QueryDto GetTables(string database);
+        public QueryDto GetColumns(string database,string table);
+    }
+}

API_SQLuedo/Shared/ISolutionService.cs

@@ -0,0 +1,6 @@
+namespace Shared;
+
+public interface ISolutionService<TSolution>
+{
+    public TSolution GetSolutionByInquiryId(int id);
+}

API_SQLuedo/Shared/IUserService.cs

@@ -14,5 +14,8 @@ namespace Shared
         public bool DeleteUserByUsername(string username);
         public TUser UpdateUser(int id, TUser user);
         public TUser CreateUser(string username, string password, string email, bool isAdmin);
+        public bool IsEmailTaken(string email);
+        public bool IsUsernameTaken(string username);
+        public TUser PromoteUser(int id);
     }
 }

API_SQLuedo/Shared/Mapper/LessonMapper.cs

@@ -16,10 +16,6 @@ public static class LessonMapper
         return new LessonDto(model.Id, model.Title, model.LastPublisher, model.LastEdit, model.Content.Select(c => c.FromEntityToDto()).ToList());
     }
     
-    public static LessonDto FromEntityToDtoPost(this LessonEntity model)
-    {
-        return new LessonDto(model.Id, model.Title, model.LastPublisher, model.LastEdit);
-    }
 
     public static LessonEntity FromModelToEntity(this Lesson model)
     {

API_SQLuedo/StubbedContextLib/StubbedContext.cs

@@ -184,5 +184,29 @@ public class StubbedContext : UserDbContext
                 IsFinished = true
             }
         );
+        builder.Entity<LessonEntity>().HasData(
+            new LessonEntity
+            {
+                Id = 1, Title = "Lesson N°1", LastEdit = DateOnly.FromDateTime(DateTime.Now), LastPublisher = "Clément"
+            },
+            new LessonEntity
+            {
+                Id = 2, Title = "Lesson N°2", LastEdit = DateOnly.FromDateTime(DateTime.Now), LastPublisher = "Clément"
+            },
+            new LessonEntity
+            {
+                Id = 3, Title = "Lesson N°3", LastEdit = DateOnly.FromDateTime(DateTime.Now), LastPublisher = "Clément"
+            },
+            new LessonEntity
+            {
+                Id = 4, Title = "Lesson N°4", LastEdit = DateOnly.FromDateTime(DateTime.Now), LastPublisher = "Clément"
+            }
+        );
+        builder.Entity<ParagraphEntity>().HasData(
+            new ParagraphEntity { Id = 1, LessonId = 1, ContentTitle = "Paragraph N°1", ContentContent = "Content of paragraph N°1", Title = "Title Paragraph N°1", Content = "Content of paragraph N°1", Info = "Infos", Query = "SELECT * FROM Table", Comment = "Comment of paragraph N°1"},
+            new ParagraphEntity { Id = 2, LessonId = 1, ContentTitle = "Paragraph N°2", ContentContent = "Content of paragraph N°2", Title = "Title Paragraph N°2", Content = "Content of paragraph N°2", Info = "Infos", Query = "SELECT * FROM Table", Comment = "Comment of paragraph N°2"},
+            new ParagraphEntity { Id = 3, LessonId = 1, ContentTitle = "Paragraph N°3", ContentContent = "Content of paragraph N°3", Title = "Title Paragraph N°3", Content = "Content of paragraph N°3", Info = "Infos", Query = "SELECT * FROM Table", Comment = "Comment of paragraph N°3"},
+            new ParagraphEntity { Id = 4, LessonId = 2, ContentTitle = "Paragraph N°1", ContentContent = "Content of paragraph N°1", Title = "Title Paragraph N°1", Content = "Content of paragraph N°1", Info = "Infos", Query = "SELECT * FROM Table", Comment = "Comment of paragraph N°1"}
+            );
     }
 }

API_SQLuedo/TestAPI/BlackListUnitTest.cs

@@ -46,7 +46,7 @@ public class BlackListUnitTest
         var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
 
         var userResult = usersController.BanUser("Test1");
-        Assert.Equal(typeof(OkResult), userResult.GetType());
+        Assert.Equal(typeof(OkObjectResult), userResult.GetType());
     }
     
     [Fact]
@@ -68,7 +68,7 @@ public class BlackListUnitTest
         var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
 
         var userResult = usersController.UnbanUser("example@email.com");
-        Assert.Equal(typeof(OkResult), userResult.GetType());
+        Assert.Equal(typeof(OkObjectResult), userResult.GetType());
     }
     
     [Fact]
@@ -94,7 +94,7 @@ public class BlackListUnitTest
             });
         var blackListController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
 
-        var result = blackListController.GetUsers(1,10,BlackListOdrerCriteria.None);
+        var result = blackListController.GetBannedUsers(1,10,BlackListOdrerCriteria.None);
         Assert.Equal(typeof(OkObjectResult), result.GetType());
         if (result is OkObjectResult okObjectResult)
         {
@@ -118,7 +118,7 @@ public class BlackListUnitTest
             });
         var blackListController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
 
-        var result = blackListController.GetUsers(1,10,BlackListOdrerCriteria.ByEmail);
+        var result = blackListController.GetBannedUsers(1,10,BlackListOdrerCriteria.ByEmail);
         Assert.Equal(typeof(OkObjectResult), result.GetType());
         if (result is OkObjectResult okObjectResult)
         {
@@ -142,7 +142,7 @@ public class BlackListUnitTest
             });
         var blackListController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
 
-        var result = blackListController.GetUsers(1,10,BlackListOdrerCriteria.ByExpirationDate);
+        var result = blackListController.GetBannedUsers(1,10,BlackListOdrerCriteria.ByExpirationDate);
         Assert.Equal(typeof(OkObjectResult), result.GetType());
         if (result is OkObjectResult okObjectResult)
         {
@@ -154,6 +154,23 @@ public class BlackListUnitTest
         }
     }
 
+    [Fact]
+    public void Get_0_BannedUsers_OrderedByNone()
+    {
+        _blackListService.Setup(x => x.GetBannedUsers(1, 10, BlackListOdrerCriteria.None))
+            .Returns(new List<BlackListDto>());
+        var blackListController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var result = blackListController.GetBannedUsers(1, 10, BlackListOdrerCriteria.None);
+        Assert.Equal(typeof(StatusCodeResult), result.GetType());
+        if (result is NotFoundObjectResult notFoundObjectResult)
+        {
+            var valeur = notFoundObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void GetNbBannedUsers()
     {
@@ -163,7 +180,7 @@ public class BlackListUnitTest
 
         var userResult = usersController.GetNumberOfBannedUsers();
         Assert.Equal(typeof(OkObjectResult), userResult.GetType());
-        Assert.Equal(10, (userResult as OkObjectResult).Value);
+        Assert.Equal(10, ((KeyValuePair<string,int>)(userResult as OkObjectResult).Value).Value);
     }
 
     private IEnumerable<BlackListDto> GetBlackList()

API_SQLuedo/TestAPI/InquiryTableUnitTest.cs

@@ -0,0 +1,51 @@
+using API.Controllers;
+using Dto;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Shared;
+
+namespace TestAPI;
+
+public class InquiryTableUnitTest
+{
+    private readonly Mock<IInquiryTableService<InquiryTableDto>> _inquiryTableService;
+
+    public InquiryTableUnitTest()
+    {
+        _inquiryTableService = new Mock<IInquiryTableService<InquiryTableDto>>();
+    }
+
+    [Fact]
+    public void GetDatabaseNameFromInquiryId_Success()
+    {
+        var database = "Inquiry1";
+        _inquiryTableService.Setup(x => x.GetDatabaseNameByInquiryId(42))
+            .Returns(database);
+        var inquiryTableController =
+            new InquiryTableController(_inquiryTableService.Object, new NullLogger<InquiryTableController>());
+
+        var inquiryTableResult = inquiryTableController.GetDatabaseNameByInquiryById(42);
+
+        if (inquiryTableResult is OkObjectResult okObjectResult)
+        {
+            var valeur = okObjectResult.Value;
+            Assert.NotNull(valeur);
+            Assert.Equal(database, ((KeyValuePair<string,string>)valeur).Value);
+        }
+    }
+    
+    [Fact]
+    public void GetDatabaseNameFromInquiryId_Throws_ArgumentException()
+    {
+        _inquiryTableService.Setup(x => x.GetDatabaseNameByInquiryId(42))
+            .Throws<ArgumentException>();
+        var inquiryTableController =
+            new InquiryTableController(_inquiryTableService.Object, new NullLogger<InquiryTableController>());
+
+        var inquiryTableResult = inquiryTableController.GetDatabaseNameByInquiryById(42);
+
+        Assert.NotNull(inquiryTableResult); 
+        Assert.Equal(typeof(NotFoundResult), inquiryTableResult.GetType());
+    }
+}

API_SQLuedo/TestAPI/InquiryUnitTest.cs

@@ -37,6 +37,25 @@ public class InquiryUnitTest
         }
     }
     
+    [Fact]
+    public void GetNumberOfInquiries()
+    {
+        var inquiryList = GetInquiriesData();
+        _inquiryService.Setup(x => x.GetNumberOfInquiries())
+            .Returns(4);
+        var inquiryController = new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
+
+        var inquiriesResult = inquiryController.GetNumberOfInquiries();
+
+        if (inquiriesResult is OkObjectResult okObjectResult)
+        {
+            var valeur = (KeyValuePair<string,int>)okObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.Equal(GetInquiriesData().Count, valeur.Value);
+        }
+    }
+
     [Fact]
     public void GetInquiresListFail()
     {

API_SQLuedo/TestAPI/LessonUnitTest.cs

@@ -5,6 +5,7 @@ using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Shared;
 using TestAPI.Extensions;
+using Xunit.Sdk;
 
 namespace TestAPI;
 
@@ -101,6 +102,22 @@ public class LessonUnitTest
         }
     }
 
+    [Fact]
+    public void GetLessonIdFail_Argument_Exception()
+    {
+        _lessonService.Setup(x => x.GetLessonById(10000))
+            .Throws<ArgumentException>();
+        var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
+
+        var result = lessonsController.GetLessonById(10000);
+
+        if (result is NotFoundObjectResult nfObjectResult)
+        {
+            Assert.NotNull(nfObjectResult);
+        }
+    }
+
+
     [Fact]
     public void GetLessonTitleSuccess()
     {
@@ -145,6 +162,21 @@ public class LessonUnitTest
         }
     }
 
+    [Fact]
+    public void GetLessonTitleFail_Argument_Exception()
+    {
+        _lessonService.Setup(x => x.GetLessonByTitle("title"))
+            .Throws<ArgumentException>();
+        var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
+
+        var result = lessonsController.GetLessonByTitle("title");
+
+        if (result is NotFoundObjectResult nfObjectResult)
+        {
+            Assert.NotNull(nfObjectResult);
+        }
+    }
+
     [Fact]
     public void DeleteLessonSuccess()
     {
@@ -213,6 +245,21 @@ public class LessonUnitTest
         }
     }
 
+    [Fact]
+    public void CreateLessonFail_Argument_Exception()
+    {
+        _lessonService.Setup(x => x.CreateLesson(35672653, "duehduheudheu nouveau titre", "Le deudhe éditeur", new DateOnly(2024, 03, 16)))
+            .Throws<ArgumentException>();
+        var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
+
+        var result = lessonsController.CreateLesson(new LessonDto(35672653, "duehduheudheu nouveau titre", "Le deudhe éditeur", new DateOnly(2024, 03, 16)));
+
+        if (result is NotFoundObjectResult nfObjectResult)
+        {
+            Assert.NotNull(nfObjectResult);
+        }
+    }
+
     [Fact]
     public void UpdateLessonSuccess()
     {

API_SQLuedo/TestAPI/NotepadUnitTest.cs

@@ -0,0 +1,183 @@
+using API.Controllers;
+using Dto;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Shared;
+using TestAPI.Extensions;
+
+namespace TestAPI;
+
+public class NotepadUnitTest
+{
+    private readonly Mock<INotepadService<NotepadDto>> _notepadService;
+
+    public NotepadUnitTest()
+    {
+        _notepadService = new Mock<INotepadService<NotepadDto>>();
+    }
+
+    [Fact]
+    public void GetNotepadFromUserAndInquiryId()
+    {
+        var notepad = new NotepadDto(42, 42, "These are notes example.");
+        _notepadService.Setup(x => x.GetNotepadFromUserAndInquiryId(42, 42))
+            .Returns(notepad);
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.GetNotepadByUserAndInquiryById(42,42);
+
+        if (notepadResult is OkObjectResult okObjectResult)
+        {
+            var valeur = okObjectResult.Value;
+            Assert.NotNull(valeur);
+            Assert.Equal(notepad, valeur);
+        }
+    }
+    
+    [Fact]
+    public void GetNotepadFromUserAndInquiryId_ThrowingArgumentException()
+    {
+        var notepad = new NotepadDto(42, 42, "These are notes example.");
+        _notepadService.Setup(x => x.GetNotepadFromUserAndInquiryId(42, 10))
+            .Throws<ArgumentException>();
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.GetNotepadByUserAndInquiryById(42,10);
+        Assert.NotNull(notepadResult);
+        Assert.Equal(typeof(NotFoundResult),notepadResult.GetType());
+    }
+    
+    [Fact]
+    public void SetNotepadFromUserAndInquiryId_Success()
+    {
+        _notepadService.Setup(x => x.SetNotepadFromUserAndInquiryId(42, 42,"These are notes example."));
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,42, "These are notes example.")); 
+        Assert.NotNull(notepadResult);
+        Assert.Equal(typeof(OkResult),notepadResult.GetType());
+        Assert.Equal(typeof(OkObjectResult) , notepadController.GetNotepadByUserAndInquiryById(42,42).GetType());
+    }
+    
+    [Fact]
+    public void SetNotepadFromUserAndInquiryId_Negative_UserId()
+    {
+        _notepadService.Setup(x => x.SetNotepadFromUserAndInquiryId(-42, 42,"These are notes example.")).Throws<ArgumentException>();
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(-42,42, "These are notes example.")); 
+        Assert.NotNull(notepadResult);
+        Assert.Equal(typeof(BadRequestResult),notepadResult.GetType());
+    }
+    
+    [Fact]
+    public void SetNotepadFromUserAndInquiryId_Negative_InquiryId()
+    {
+        _notepadService.Setup(x => x.SetNotepadFromUserAndInquiryId(42, -42,"These are notes example.")).Throws<ArgumentException>();
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,-42, "These are notes example.")); 
+        Assert.NotNull(notepadResult);
+        Assert.Equal(typeof(BadRequestResult),notepadResult.GetType());
+    }
+    
+    [Fact]
+    public void SetNotepadFromUserAndInquiryId_Null_Notes()
+    {
+        _notepadService.Setup(x => x.SetNotepadFromUserAndInquiryId(42, 42,"These are notes example.")).Throws<ArgumentException>();
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,42, null)); 
+        Assert.NotNull(notepadResult);
+        Assert.Equal(typeof(BadRequestResult),notepadResult.GetType());
+    }
+    
+    [Fact]
+    public void SetNotepadFromUserAndInquiryId_Throws_ArgumentException()
+    {
+        var notepad = new NotepadDto(42, 42, "These are notes example.");
+        _notepadService.Setup(x => x.SetNotepadFromUserAndInquiryId(42, 42,"These are notes example.")).Throws<ArgumentException>();
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(notepad); 
+        Assert.NotNull(notepadResult);
+        Assert.Equal(typeof(NotFoundResult),notepadResult.GetType());
+    }
+    
+    
+    [Fact]
+    public void UpdateNotepadFromUserAndInquiryId_Success()
+    {
+        _notepadService.Setup(x => x.UpdateNotepadFromUserAndInquiryId(42, 42,"These are the new notes"));
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,42, "These are notes example."));
+        Assert.NotNull(notepadResult);
+        Assert.Equal(typeof(OkResult),notepadResult.GetType());
+        Assert.Equal(typeof(OkObjectResult) , notepadController.GetNotepadByUserAndInquiryById(42,42).GetType());
+        var updateResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,42, "These are the new notes"));
+        Assert.NotNull(updateResult);
+        Assert.Equal(typeof(OkResult),updateResult.GetType());
+    }
+    
+    [Fact]
+    public void UpdateNotepadFromUserAndInquiryId_Negative_UserId()
+    {
+        _notepadService.Setup(x => x.UpdateNotepadFromUserAndInquiryId(42, 42,"These are the new notes"));
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,42, "These are notes example.")); 
+        var updateResult = notepadController.UpdateNotepadByUserAndInquiryById(new NotepadDto(-42,42, "These are the new notes")); 
+        Assert.NotNull(updateResult);
+        Assert.Equal(typeof(BadRequestResult),updateResult.GetType());
+    }
+    
+    [Fact]
+    public void UpdateNotepadFromUserAndInquiryId_Negative_InquiryId()
+    {
+        _notepadService.Setup(x => x.UpdateNotepadFromUserAndInquiryId(42, -42,"These are the new notes"));
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,42, "These are notes example.")); 
+        var updateResult = notepadController.UpdateNotepadByUserAndInquiryById(new NotepadDto(42,-42, "These are the new notes")); 
+        Assert.NotNull(updateResult);
+        Assert.Equal(typeof(BadRequestResult),updateResult.GetType());
+    }
+    
+    [Fact]
+    public void UpdateNotepadFromUserAndInquiryId_Null_Notes()
+    {
+        _notepadService.Setup(x => x.UpdateNotepadFromUserAndInquiryId(42, 42,null)).Throws<ArgumentException>();
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,42, "These are notes example.")); 
+        var updateResult = notepadController.UpdateNotepadByUserAndInquiryById(new NotepadDto(42,42, null)); 
+        Assert.NotNull(updateResult);
+        Assert.Equal(typeof(BadRequestResult),updateResult.GetType());
+    }
+    
+    [Fact]
+    public void UpdateNotepadFromUserAndInquiryId_Throws_ArgumentException()
+    {
+        _notepadService.Setup(x => x.UpdateNotepadFromUserAndInquiryId(42, 10,"These are the new notes")).Throws<ArgumentException>();
+        var notepadController =
+            new NotepadController(_notepadService.Object, new NullLogger<NotepadController>());
+
+        var notepadResult = notepadController.SetNotepadByUserAndInquiryById(new NotepadDto(42,42, "These are notes example.")); 
+        var updateResult = notepadController.UpdateNotepadByUserAndInquiryById(new NotepadDto(42,10, "These are the new notes")); 
+        Assert.NotNull(updateResult);
+        Assert.Equal(typeof(NotFoundResult),updateResult.GetType());
+    }
+}

API_SQLuedo/TestAPI/QueryUnitTest.cs

@@ -0,0 +1,206 @@
+using API.Controllers;
+using Castle.Components.DictionaryAdapter.Xml;
+using Dto;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Shared;
+using TestAPI.Extensions;
+
+namespace TestAPI;
+
+public class QueryUnitTest
+{
+    private readonly Mock<IQueryService<QueryDto>> _queryService;
+
+    public QueryUnitTest()
+    {
+        _queryService = new Mock<IQueryService<QueryDto>>();
+    }
+
+    [Fact]
+    public void Select_Users_Success()
+    {
+        var userList = GetUsersData();
+        _queryService.Setup(x => x.ExecuteQuery("Select * from \"User\";","SQLuedo"))
+            .Returns(new QueryDto{Result = userList.ToString()});
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.ExecuteQuery("Select * from \"User\";", "SQLuedo");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+            
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+    [Fact]
+    public void Select_Users_Failed_Cause_Database_Doesnt_Exists()
+    {
+        var userList = GetUsersData();
+        _queryService.Setup(x => x.ExecuteQuery("Select * from \"User\";", "SQLuedo"))
+            .Returns(new QueryDto { Result = userList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.ExecuteQuery("Select * from \"User\";", "LABASEDEDONNEES");
+
+        if (queryResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
+
+        {
+            Assert.IsNotType<OkObjectResult>(queryResult);
+        }
+    }
+
+    [Fact]
+    public void Get_Tables_Success()
+    {
+        var tablesList = GetTables();
+        _queryService.Setup(x => x.GetTables("SQLuedo"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetTables("SQLuedo");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+    [Fact]
+    public void Get_Tables_Failed_Cause_Database_Doesnt_Exist()
+    {
+        var tablesList = GetTables();
+        _queryService.Setup(x => x.GetTables("SQLuedo"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetTables("LABSEEEEEEEEEEEEEEEEEEEE");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+
+    [Fact]
+    public void Get_Columns_Success()
+    {
+        var tablesList = GetColumns();
+        _queryService.Setup(x => x.GetColumns("SQLuedo","User"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetColumns("SQLuedo","User");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+    [Fact]
+    public void Get_Columns_Failed_Cause_Database_Doesnt_Exist()
+    {
+        var tablesList = GetColumns();
+        _queryService.Setup(x => x.GetColumns("SQLuedo", "User"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetColumns("UDHUE", "User");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+    [Fact]
+    public void Get_Columns_Failed_Cause_Table_Doesnt_Exist()
+    {
+        var tablesList = GetColumns();
+        _queryService.Setup(x => x.GetColumns("SQLuedo", "User"))
+            .Returns(new QueryDto { Result = tablesList.ToString() });
+        var queryController = new QueryController(new NullLogger<QueryController>(), _queryService.Object);
+
+        var queryResult = queryController.GetColumns("SQLuedo", "GEGEIU");
+
+        if (queryResult is OkObjectResult okObjectResult)
+        {
+
+            Assert.NotNull(okObjectResult);
+        }
+    }
+
+
+    private List<UserDto> GetUsersData()
+    {
+        List<UserDto> usersData = new List<UserDto>(4)
+        {
+            new(
+                0,
+                "Useruser",
+                "motdepasse",
+                "adressemail@gmail.com",
+                true
+            ),
+            new
+            (
+                1,
+                "Leuser",
+                "motdepasse",
+                "deuxadresse@gmail.com",
+                false
+            ),
+            new
+            (
+                2,
+                "gygyggyg",
+                "ennodlavehc",
+                "thirdadress@gmail.com",
+                false
+            ),
+            new
+            (
+                "ferferf",
+                "h_nh_78",
+                "fourthadress@gmail.com",
+                false
+            ),
+        };
+        return usersData;
+    }
+
+
+    private List<string> GetColumns()
+    {
+        List<string> columns = new List<string>(4)
+        {
+            "Id",
+            "Name",
+            "Password",
+            "IsAdmin"
+        };
+        return columns;
+    }
+
+
+
+    private List<string> GetTables()
+    {
+        List<string> columns = new List<string>(4)
+        {
+            "User",
+            "Solution",
+            "Inquiry",
+            "Success"
+        };
+        return columns;
+    }
+}

API_SQLuedo/TestAPI/SolutionUnitTest.cs

@@ -0,0 +1,52 @@
+using API.Controllers;
+using Dto;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Shared;
+
+namespace TestAPI;
+
+public class SolutionUnitTest
+{
+    private readonly Mock<ISolutionService<SolutionDto>> _solutionService;
+
+    public SolutionUnitTest()
+    {
+        _solutionService = new Mock<ISolutionService<SolutionDto>>();
+    }
+    
+    [Fact]
+    public void GetSolutionFromInquiryId_Success()
+    {
+        var solution = new SolutionDto(42,"Maxime","Sapountzis","La cuisine","Le couteau", "L'explication");
+        _solutionService.Setup(x => x.GetSolutionByInquiryId(42))
+            .Returns(solution);
+        var solutionController =
+            new SolutionController(_solutionService.Object, new NullLogger<SolutionController>());
+
+        var solutionResult = solutionController.GetSolutionByInquiryById(42);
+
+        if (solutionResult is OkObjectResult okObjectResult)
+        {
+            var valeur = okObjectResult.Value;
+            Assert.NotNull(valeur);
+            Assert.Equal(solution, valeur);
+        }
+    }
+    
+    [Fact]
+    public void GetSolutionFromInquiryId_Throws_ArgumentException()
+    {
+        var solution = new SolutionDto(42,"Maxime","Sapountzis","La cuisine","Le couteau", "L'explication");
+        _solutionService.Setup(x => x.GetSolutionByInquiryId(42))
+            .Throws<ArgumentException>();
+        var solutionController =
+            new SolutionController(_solutionService.Object, new NullLogger<SolutionController>());
+
+        var solutionResult = solutionController.GetSolutionByInquiryById(42);
+
+        Assert.NotNull(solutionResult);
+        Assert.Equal(typeof(NotFoundResult), solutionResult.GetType());
+    }
+}

API_SQLuedo/TestAPI/SuccessesUnitTest.cs

@@ -1,6 +1,7 @@
 using API.Controllers;
 using Dto;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Shared;
@@ -40,14 +41,30 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void GetSuccessesListFail()
+    public void GetSuccessesListFail_When_Result_Equal_0()
     {
         _successService.Setup(x => x.GetSuccesses(1, 4, 0))
             .Returns(new List<SuccessDto>());
         var successesController =
             new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
 
-        var successesResult = successesController.GetSuccesses(2, 3, 0);
+        var successesResult = successesController.GetSuccesses(26373, 31771, 0);
+
+        if (successesResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
+        {
+            Assert.IsNotType<OkObjectResult>(successesResult);
+        }
+    }
+
+    [Fact]
+    public void GetSuccessesListFail_When_Page_Is_A_Negative()
+    {
+        _successService.Setup(x => x.GetSuccesses(1, 4, 0))
+            .Returns(new List<SuccessDto>());
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.GetSuccesses(-1, 3, 0);
 
         if (successesResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
         {
@@ -89,7 +106,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void GetSuccessInquiryIdFail()
+    public void GetSuccessInquiryIdFail_When_Id_Not_Exist()
     {
         var successesList = GetSuccessesData();
         _successService.Setup(x => x.GetSuccessesByInquiryId(1))
@@ -108,6 +125,43 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void GetSuccessInquiryIdFail_When_Id_Negative()
+    {
+        var successesList = GetSuccessesData();
+        _successService.Setup(x => x.GetSuccessesByInquiryId(1))
+            .Returns(new List<SuccessDto> { successesList[0], successesList[1] });
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.GetSuccessByInquiryId(-1);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.IsNotType<SuccessDto>(valeur);
+            Assert.DoesNotContain(valeur, successesList);
+        }
+    }
+
+    [Fact]
+    public void GetSuccessInquiryIdFail_Argument_Exception()
+    {
+        _successService.Setup(x => x.GetSuccessesByInquiryId(1000))
+            .Throws<ArgumentException>();
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.GetSuccessByInquiryId(1000);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void GetSuccessUserIdSuccess()
     {
@@ -140,7 +194,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void GetSuccessUserIdFail()
+    public void GetSuccessUserIdFail_When_Id_Not_Found()
     {
         var successesList = GetSuccessesData();
         _successService.Setup(x => x.GetSuccessesByUserId(2))
@@ -159,6 +213,44 @@ public class SuccessesUnitTest
         }
     }
 
+
+    [Fact]
+    public void GetSuccessUserIdFail_When_Id_Negative()
+    {
+        var successesList = GetSuccessesData();
+        _successService.Setup(x => x.GetSuccessesByUserId(2))
+            .Returns(new List<SuccessDto> { successesList[2], successesList[3] });
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.GetSuccessByUserId(-1);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.IsNotType<SuccessDto>(valeur);
+            Assert.DoesNotContain(valeur, successesList);
+        }
+    }
+
+    [Fact]
+    public void GetSuccessUserIdFail_Argument_Exception()
+    {
+        _successService.Setup(x => x.GetSuccessesByUserId(1000))
+            .Throws<ArgumentException>();
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.GetSuccessByUserId(1000);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void DeleteSuccessSuccess()
     {
@@ -177,7 +269,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void DeleteSuccessFail()
+    public void DeleteSuccessFail_When_Not_Found()
     {
         _successService.Setup(x => x.DeleteSuccess(1, 1))
             .Returns(true);
@@ -192,6 +284,22 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void DeleteSuccessFail_When_Negative()
+    {
+        _successService.Setup(x => x.DeleteSuccess(1, 1))
+            .Returns(true);
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.DeleteSuccess(-1, 278);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            Assert.Null(nfObjectResult.Value);
+            Assert.IsNotType<bool>(nfObjectResult.Value);
+        }
+    }
+
     [Fact]
     public void CreateSuccessSuccess()
     {
@@ -213,7 +321,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void CreateSuccessFail()
+    public void CreateSuccessFail_When_Id_Not_Found()
     {
         _successService.Setup(x => x.CreateSuccess(8, 8, true))
             .Returns(new SuccessDto(8, 8, true));
@@ -228,6 +336,38 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void CreateSuccessFail_When_Id_Negative()
+    {
+        _successService.Setup(x => x.CreateSuccess(8, 8, true))
+            .Returns(new SuccessDto(8, 8, true));
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.CreateSuccess(new SuccessDto(-1, 818, true));
+
+        if (successesResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
+
+    [Fact]
+    public void CreateSuccessFail_Exception()
+    {
+        _successService.Setup(x => x.CreateSuccess(89889, 82837, true))
+            .Throws<Exception>();
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.CreateSuccess(new SuccessDto(89889, 82837, true));
+
+        if (successesResult is NotFoundObjectResult notFoundObjectResult)
+        {
+            Assert.NotNull(notFoundObjectResult);
+        }
+    }
+
     [Fact]
     public void UpdateSuccessSuccess()
     {
@@ -249,7 +389,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void UpdateSuccessFail()
+    public void UpdateSuccessFail_When_Ids_Are_Differents()
     {
         _successService.Setup(x => x.UpdateSuccess(1, 1, new SuccessDto(1, 2, true)))
             .Returns(new SuccessDto(1, 2, true));
@@ -264,6 +404,56 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void UpdateSuccessFail_When_Id_Negative()
+    {
+        _successService.Setup(x => x.UpdateSuccess(1, 1, new SuccessDto(1, 2, true)))
+            .Returns(new SuccessDto(1, 2, true));
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.UpdateSuccess(-2, 1, new SuccessDto(1, 2, true));
+
+        if (successesResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
+
+    [Fact]
+    public void UpdateSuccessFail_When_Id_Not_Found()
+    {
+        _successService.Setup(x => x.UpdateSuccess(1, 1, new SuccessDto(1, 2, true)))
+            .Returns(new SuccessDto(1, 2, true));
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.UpdateSuccess(1000, 1000, new SuccessDto(1000, 1000, true));
+
+        if (successesResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
+
+    [Fact]
+    public void UpdateSuccessFail_Throw_Exception()
+    {
+        _successService.Setup(x => x.UpdateSuccess(108871, 117683, new SuccessDto(1, 2, true)))
+            .Throws<Exception>();
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.UpdateSuccess(108871, 117683, new SuccessDto(1, 2, true));
+
+        if (successesResult is NotFoundObjectResult notFoundObjectResult)
+        {
+            Assert.NotNull(notFoundObjectResult);
+        }
+    }
+
+
+
     private List<SuccessDto> GetSuccessesData()
     {
         List<SuccessDto> successesData = new List<SuccessDto>(4)

API_SQLuedo/TestAPI/TestAPI.csproj

@@ -11,6 +11,7 @@
 
   <ItemGroup>
     <PackageReference Include="Asp.Versioning.Mvc" Version="8.0.0" />
+    <PackageReference Include="Docker.DotNet" Version="3.125.15" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.2" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.2">
       <PrivateAssets>all</PrivateAssets>

API_SQLuedo/TestAPI/UserUnitTest.cs

@@ -18,7 +18,7 @@ public class UserUnitTest
     }
 
     [Fact]
-    public void GetNumberOfUsers()
+    public void GetNumberOfUsersSuccess()
     {
         var userList = GetUsersData();
         _userService.Setup(x => x.GetNumberOfUsers())
@@ -35,6 +35,24 @@ public class UserUnitTest
         }
     }
 
+
+    [Fact]
+    public void GetNumberOfUsers_Fail_Cause_Not_Found()
+    {
+        var userList = GetUsersData();
+        _userService.Setup(x => x.GetNumberOfUsers())
+            .Returns(0);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetNumberOfUsers();
+
+        if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
+
+        {
+            Assert.IsNotType<OkObjectResult>(userResult);
+        }
+    }
+
     [Fact]
     public void GetUsersListSuccess()
     {
@@ -55,6 +73,22 @@ public class UserUnitTest
         }
     }
 
+    [Fact]
+    public void GetUserListFail()
+    {
+        _userService.Setup(x => x.GetUsers(1, 4, 0))
+            .Returns(new List<UserDto>());
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetUsers(2, 3, 0);
+
+        if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
+
+        {
+            Assert.IsNotType<OkObjectResult>(userResult);
+        }
+    }
+
     [Fact]
     public void GetNotAdminUsersListSuccess()
     {
@@ -65,29 +99,31 @@ public class UserUnitTest
 
         var userResult = usersController.GetNotAdminUsers(1, 4, 0);
 
-        if (userResult is OkObjectResult okObjectResult)
+        if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
-        {
-            var valeur = okObjectResult.Value;
 
-            Assert.NotNull(valeur);
+        {
-            Assert.Equal(GetUsersData().ToString(), valeur.ToString());
+            Assert.IsNotType<OkObjectResult>(userResult);
-            Assert.True(userList.Where(u => u.IsAdmin == false).SequenceEqual(valeur as IEnumerable<UserDto>, new UserIdEqualityComparer()));
         }
     }
 
     [Fact]
-    public void GetUserListFail()
+    public void GetNotAdminUsersListFail_Cause_Not_Found()
     {
-        _userService.Setup(x => x.GetUsers(1, 4, 0))
+        var userList = GetUsersData();
-            .Returns(new List<UserDto>());
+        _userService.Setup(x => x.GetNotAdminUsers(1, 4, 0))
+            .Returns(userList.Where(u => u.IsAdmin == false));
         var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
 
-        var userResult = usersController.GetUsers(2, 3, 0);
+        var userResult = usersController.GetNotAdminUsers(100, 4, 0);
-
-        if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
 
+        if (userResult is OkObjectResult okObjectResult)
         {
-            Assert.IsNotType<OkObjectResult>(userResult);
+            var valeur = okObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.Equal(GetUsersData().ToString(), valeur.ToString());
+            Assert.True(userList.Where(u => u.IsAdmin == false)
+                .SequenceEqual(valeur as IEnumerable<UserDto>, new UserIdEqualityComparer()));
         }
     }
 
@@ -115,7 +151,7 @@ public class UserUnitTest
     }
 
     [Fact]
-    public void GetUserIdFail()
+    public void GetUserIdFail_Id_Doesnt_Exist()
     {
         var userList = GetUsersData();
         _userService.Setup(x => x.GetUserById(1))
@@ -133,6 +169,42 @@ public class UserUnitTest
         }
     }
 
+
+    [Fact]
+    public void GetUserIdFail_Negative_Id()
+    {
+        var userList = GetUsersData();
+        _userService.Setup(x => x.GetUserById(1))
+            .Returns(userList[1]);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetUserById(-1);
+        if (userResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.IsNotType<UserDto>(valeur);
+            Assert.DoesNotContain(valeur, userList);
+        }
+    }
+
+    [Fact]
+    public void GetUserIdFail_Argument_Exception()
+    {
+        _userService.Setup(x => x.GetUserById(10000))
+            .Throws<ArgumentException>();
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetUserById(10000);
+        if (userResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void GetUserUsernameSuccess()
     {
@@ -155,6 +227,23 @@ public class UserUnitTest
             Assert.True(valeur.IsAdmin);
         }
     }
+
+    [Fact]
+    public void GetUserUsernameFail_Argument_Exception()
+    {
+        _userService.Setup(x => x.GetUserByUsername("Usererererrere"))
+            .Throws<ArgumentException>();
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetUserByUsername("Usererererrere");
+        if (userResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+        }
+    }
+
     [Fact]
     public void GetUserEmailSuccess()
     {
@@ -198,6 +287,7 @@ public class UserUnitTest
             Assert.False(userList == valeur);
         }
     }
+
     [Fact]
     public void GetUserEmailFail()
     {
@@ -250,6 +340,34 @@ public class UserUnitTest
         }
     }
 
+    [Fact]
+    public void DeleteUser_By_Username_Success()
+    {
+        _userService.Setup(x => x.DeleteUserByUsername("Damn"))
+            .Returns(true);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.DeleteUserByUsername("Damn");
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            Assert.Null(okObjectResult.Value);
+        }
+    }
+
+    [Fact]
+    public void DeleteUser_By_Username_Failed()
+    {
+        _userService.Setup(x => x.DeleteUserByUsername("IUDHEIUHDEHUDH"))
+            .Returns(false);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.DeleteUserByUsername("IUDHEIUHDEHUDH");
+        if (userResult is NotFoundObjectResult notFoundObjectResult)
+        {
+            Assert.Null(notFoundObjectResult.Value);
+        }
+    }
+
     [Fact]
     public void CreateUserSuccess()
     {
@@ -271,7 +389,7 @@ public class UserUnitTest
     }
 
     [Fact]
-    public void CreateUserFail()
+    public void CreateUserFail_When_Field_Null()
     {
         GetUsersData();
         _userService.Setup(x => x.CreateUser("Nom", "Passssss", "heudfk@hdye.com", true))
@@ -286,6 +404,39 @@ public class UserUnitTest
         }
     }
 
+
+    [Fact]
+    public void CreateUserWithExistingEmail()
+    {
+        GetUsersData();
+        _userService.Setup(x => x.CreateUser("Nom", "Passssss", "adressemail@gmail.com", true))
+            .Returns(new UserDto("Nom", "Passssss", "adressemail@gmail.com", true));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.CreateUser(new UserDto("user", "Passssss", "adressemail@gmail.com", true));
+
+        if (userResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(409, bdObjectResult.StatusCode);
+        }
+    }
+
+    [Fact]
+    public void CreateUserWithExistingUsername()
+    {
+        GetUsersData();
+        _userService.Setup(x => x.CreateUser("Nom", "Passssss", "adressemail@gmail.com", true))
+            .Returns(new UserDto("Nom", "Passssss", "adressemail@gmail.com", true));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.CreateUser(new UserDto("Useruser", "Passssss", "adressemail@gmail.com", true));
+
+        if (userResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
+
     [Fact]
     public void UpdateUserSuccess()
     {
@@ -320,6 +471,154 @@ public class UserUnitTest
             Assert.Equal(400, bdObjectResult.StatusCode);
         }
     }
+    [Fact]
+    public void UpdateUserFailWithExistingUsername()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Useruser")).Returns(true);
+        _userService.Setup(x => x.IsEmailTaken("heudfk@hdye.com")).Returns(false);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Useruser", "Passssss", "heudfk@hdye.com", true)))
+            .Returns(new UserDto("Useruser", "Passssss", "heudfk@hdye.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Useruser", "Passssss", "heudfk@hdye.com", true));
+
+        if (userResult is StatusCodeResult statusCodeResult)
+        {
+            Assert.Equal(409, statusCodeResult.StatusCode);
+        }
+    }
+    [Fact]
+    public void UpdateUserFailWithExistingEmail()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Test1234")).Returns(false);
+        _userService.Setup(x => x.IsEmailTaken("adressemail@gmail.com")).Returns(true);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Test1234", "Passssss", "adressemail@gmail.com", true)))
+            .Returns(new UserDto("Test1234", "Passssss", "adressemail@gmail.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Test1234", "Passssss", "adressemail@gmail.com", true));
+
+        if (userResult is StatusCodeResult statusCodeResult)
+        {
+            Assert.Equal(409, statusCodeResult.StatusCode);
+        }
+    }
+    [Fact]
+    public void UpdateUserFailWithExistingEmailAndExistingUsername()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Useruser")).Returns(true);
+        _userService.Setup(x => x.IsEmailTaken("adressemail@gmail.com")).Returns(true);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Useruser", "Passssss", "adressemail@gmail.com", true)))
+            .Returns(new UserDto("Useruser", "Passssss", "adressemail@gmail.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Useruser", "Passssss", "adressemail@gmail.com", true));
+
+        if (userResult is StatusCodeResult statusCodeResult)
+        {
+            Assert.Equal(409, statusCodeResult.StatusCode);
+        }
+    }
+    [Fact]
+    public void UpdateUserSucessWithSameEmail()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Test1234")).Returns(false);
+        _userService.Setup(x => x.IsEmailTaken("deuxadresse@gmail.com")).Returns(true);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Test1234", "Passssss", "deuxadresse@gmail.com", true)))
+            .Returns(new UserDto("Test1234", "Passssss", "deuxadresse@gmail.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Test1234", "Passssss", "deuxadresse@gmail.com", true));
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            UserDto valeur = okObjectResult.Value as UserDto;
+
+            Assert.NotNull(valeur);
+            Assert.Equal("Test1234", valeur.Username);
+            Assert.Equal("Passssss", valeur.Password);
+            Assert.Equal("deuxadresse@gmail.com", valeur.Email);
+            Assert.True(valeur.IsAdmin);
+        }
+    }
+    [Fact]
+    public void UpdateUserSucessWithSameUsername()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Leuser")).Returns(true);
+        _userService.Setup(x => x.IsEmailTaken("heudfk@hdye.com")).Returns(false);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Test1234", "Passssss", "heudfk@hdye.com", true)))
+            .Returns(new UserDto("Leuser", "Passssss", "heudfk@hdye.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Leuser", "Passssss", "heudfk@hdye.com", true));
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            UserDto valeur = okObjectResult.Value as UserDto;
+
+            Assert.NotNull(valeur);
+            Assert.Equal("Leuser", valeur.Username);
+            Assert.Equal("Passssss", valeur.Password);
+            Assert.Equal("heudfk@hdye.com", valeur.Email);
+            Assert.True(valeur.IsAdmin);
+        }
+    }
+
+
+    [Fact]
+    public void PromoteUserSuccess()
+    {
+        _userService.Setup(x => x.PromoteUser(1))
+            .Returns(new UserDto(
+                1,
+                "Leuser",
+                "motdepasse",
+                "deuxadresse@gmail.com",
+                true
+            ));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.PromoteUser(1);
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            UserDto valeur = okObjectResult.Value as UserDto;
+
+            Assert.NotNull(valeur);
+            Assert.Equal("Leuser", valeur.Username);
+            Assert.Equal("motdepasse", valeur.Password);
+            Assert.Equal("deuxadresse@gmail.com", valeur.Email);
+            Assert.True(valeur.IsAdmin);
+        }
+    }
+
+    [Fact]
+    public void PromoteUserFail()
+    {
+        _userService.Setup(x => x.PromoteUser(1))
+            .Returns(new UserDto(
+                1,
+                "Leuser",
+                "motdepasse",
+                "deuxadresse@gmail.com",
+                true
+            ));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.PromoteUser(356262);
+
+        if (userResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(404, bdObjectResult.StatusCode);
+        }
+    }
 
     private List<UserDto> GetUsersData()
     {

API_SQLuedo/TestEF/Mapper/InquiryMapperUnitTest.cs

@@ -78,10 +78,10 @@ namespace TestEF.Mapper
         public void TestDtoToModel()
         {
             InquiryDto inquiry = new InquiryDto(_id, _title, _description, _isUser);
-            var inquiryMod = inquiry.FromDtoToEntity();
+            var inquiryMod = inquiry.FromDtoToModel();
 
             Assert.NotNull(inquiryMod);
-            Assert.IsType<InquiryEntity>(inquiryMod);
+            Assert.IsType<Inquiry>(inquiryMod);
             Assert.Equal(1, inquiryMod.Id);
             Assert.Equal(_title, inquiryMod.Title);
             Assert.Equal(_description, inquiryMod.Description);

API_SQLuedo/TestEF/Service/TestBlackListDataService.cs

@@ -26,24 +26,24 @@ public class TestBlackListDataService
     [Fact]
     public void BanUser_Success()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test101", Email = "example101@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test102", Email = "example102@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test103", Email = "example103@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
-        var banResult = _blackListDataService.BanUser("Test1");
+        var banResult = _blackListDataService.BanUser("Test101");
         Assert.True(banResult);
     }
     
     [Fact]
     public void GetNbBannedUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example1@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test61", Email = "example61@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example2@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test62", Email = "example62@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example3@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test63", Email = "example63@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
-        var banResult1 = _blackListDataService.BanUser("Test1");
+        var banResult1 = _blackListDataService.BanUser("Test61");
-        var banResult2 = _blackListDataService.BanUser("Test2");
+        var banResult2 = _blackListDataService.BanUser("Test62");
-        var banResult3 = _blackListDataService.BanUser("Test3");
+        var banResult3 = _blackListDataService.BanUser("Test63");
         Assert.True(banResult1);
         Assert.True(banResult2);
         Assert.True(banResult3);
@@ -53,9 +53,9 @@ public class TestBlackListDataService
     [Fact]
     public void BanUser_Fail()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test71", Email = "example71@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test72", Email = "example72@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test73", Email = "example73@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var banResult = _blackListDataService.BanUser("Test42");
         Assert.False(banResult);
@@ -64,24 +64,105 @@ public class TestBlackListDataService
     [Fact]
     public void IsBanned_Success()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example1@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test81", Email = "example81@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test82", Email = "example82@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test83", Email = "example83@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
-        var banResult = _blackListDataService.BanUser("Test1");
+        var banResult = _blackListDataService.BanUser("Test81");
         Assert.True(banResult);
-        Assert.NotNull(_blackListDataService.GetUserBannedByEmail("example1@email.com"));
+        Assert.NotNull(_blackListDataService.GetUserBannedByEmail("example81@email.com"));
     }
     
     [Fact]
     public void UnbanUser_Success()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example1@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test91", Email = "example91@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test92", Email = "example92@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test93", Email = "example93@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
-        var banResult = _blackListDataService.BanUser("Test1");
+        var banResult = _blackListDataService.BanUser("Test91");
         Assert.True(banResult);
-        Assert.True(_blackListDataService.UnbanUser("example1@email.com"));
+        Assert.True(_blackListDataService.UnbanUser("example91@email.com"));
+    }
+
+    [Fact]
+    public void UnbanUser_Fail_Cause_Email_Null()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test91", Email = "example91@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test92", Email = "example92@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test93", Email = "example93@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.BanUser("Test91");
+        Assert.True(banResult);
+        Assert.False(_blackListDataService.UnbanUser(null));
+    }
+
+    [Fact]
+    public void GetNumberOfBanned_Success()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024,03,30)});
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetNumberOfBannedUsers();
+        Assert.Equal(3,banResult);
+    }
+
+    [Fact]
+    public void GetBannedUser_Success_Positive_Value_Ordered_None()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(1,3,0);
+        Assert.Equal(3, banResult.Count());
+    }
+
+    [Fact]
+    public void GetBannedUser_Success_Positive_Value_Ordered_Email()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(1, 3, BlackListOdrerCriteria.ByEmail);
+        Assert.Equal(3, banResult.Count());
+    }
+
+
+    [Fact]
+    public void GetBannedUser_Success_Positive_Value_Ordered_ExpirationDate()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(1, 3, BlackListOdrerCriteria.ByExpirationDate);
+        Assert.Equal(3, banResult.Count());
+    }
+
+    [Fact]
+    public void GetBannedUser_Success_Positive_Value_Ordered_Default()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(1, 3,default);
+        Assert.Equal(3, banResult.Count());
+    }
+
+
+
+    [Fact]
+    public void GetBannedUser_Success_Negative_Value()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(-1, -3, 0);
+        Assert.Equal(3, banResult.Count());
     }
 }

API_SQLuedo/TestEF/Service/TestInquiryDataService.cs

@@ -37,6 +37,19 @@ public class TestInquiryDataService
         Assert.Equal(2, result.Count());
     }
     
+    [Fact]
+    public void GetNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetNumberOfInquiries();
+
+        Assert.Equal(3, result);
+    }
+    
     [Fact]
     public void GetInquiries_OrderedByTitle_ReturnsCorrectNumberOfInquiries()
     {
@@ -76,6 +89,45 @@ public class TestInquiryDataService
         Assert.Equal(2, result.Count());
     }
 
+    [Fact]
+    public void GetInquiries_OrderedById_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, InquiryOrderCriteria.ById);
+
+        Assert.Equal(2, result.Count());
+    }
+
+    [Fact]
+    public void GetInquiries_OrderedByDefault_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, default);
+
+        Assert.Equal(2, result.Count());
+    }
+
+    [Fact]
+    public void GetInquiries_OrderedDefault_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, default);
+
+        Assert.Equal(2, result.Count());
+    }
+
     [Fact]
     public void GetInquiryById_ReturnsCorrectInquiry()
     {

API_SQLuedo/TestEF/Service/TestInquiryTableDataService.cs

@@ -0,0 +1,62 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+
+namespace TestEF.Service;
+
+public class TestInquiryTableDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly InquiryTableDataService _inquiryTableDataService;
+
+    public TestInquiryTableDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _inquiryTableDataService = new InquiryTableDataService(_dbContext);
+    }
+
+    [Fact]
+    public void GetDatabaseFromInquiryId_Success()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Description", IsUser = false });
+        var inquiryTable = new InquiryTableEntity()
+        {
+            OwnerId = 42,
+            DatabaseName = "Database",
+            ConnectionInfo = "ConnectionString"
+        };
+        _dbContext.InquiryTables.Add(inquiryTable);
+        _dbContext.SaveChanges();
+        var result = _inquiryTableDataService.GetDatabaseNameByInquiryId(42);
+        Assert.Equal("Database",result);
+    }
+    
+    [Fact]
+    public void GetSolution_NotFound()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Description", IsUser = false });
+        var inquiryTable = new InquiryTableEntity()
+        {
+            OwnerId = 42,
+            DatabaseName = "Database",
+            ConnectionInfo = "ConnectionString"
+        };
+        _dbContext.InquiryTables.Add(inquiryTable);
+        _dbContext.SaveChanges();
+
+        Assert.Throws<ArgumentException>(() =>
+        {
+            _inquiryTableDataService.GetDatabaseNameByInquiryId(10);
+        });
+    }
+}

API_SQLuedo/TestEF/Service/TestNotepadDataService.cs

@@ -0,0 +1,169 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure.Internal;
+using Model.OrderCriteria;
+
+namespace TestEF.Service;
+
+public class TestNotepadDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly NotepadDataService _notepadDataService;
+
+    public TestNotepadDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _notepadDataService = new NotepadDataService(_dbContext);
+    }
+
+    [Fact]
+    public void GetNotepad_Success()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        var notepad = new NotepadEntity { UserId = 42, InquiryId = 42, Notes = "These are some notes" };
+        _dbContext.Notepads.Add(notepad);
+        _dbContext.SaveChanges();
+
+        var result = _notepadDataService.GetNotepadFromUserAndInquiryId(42, 42);
+
+        Assert.Equal(notepad,result);
+    }
+    
+    [Fact]
+    public void GetNotepad_Fail_UserNotFound()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        var notepad = new NotepadEntity { UserId = 42, InquiryId = 42, Notes = "These are some notes" };
+        _dbContext.Notepads.Add(notepad);
+        _dbContext.SaveChanges();
+        Assert.Throws<ArgumentException>(() =>
+        {
+            _notepadDataService.GetNotepadFromUserAndInquiryId(10, 42);
+        });
+    }
+    
+    [Fact]
+    public void GetNotepad_Fail_InquiryNotFound()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        var notepad = new NotepadEntity { UserId = 42, InquiryId = 42, Notes = "These are some notes" };
+        _dbContext.Notepads.Add(notepad);
+        _dbContext.SaveChanges();
+        Assert.Throws<ArgumentException>(() =>
+        {
+            _notepadDataService.GetNotepadFromUserAndInquiryId(42, 10);
+        });
+    }
+    
+    [Fact]
+    public void GetNotepad_Fail_NotepadNotFound()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 1, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        Assert.Throws<ArgumentException>(() =>
+        {
+            _notepadDataService.GetNotepadFromUserAndInquiryId(42, 1);
+        });
+    }
+    
+    [Fact]
+    public void SetNotepad_Success()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var notepad = new NotepadEntity { UserId = 42, InquiryId = 42, Notes = "Some notes again" };
+        _notepadDataService.SetNotepadFromUserAndInquiryId(42,42, "Some notes again");
+        _dbContext.SaveChanges();
+
+        var result = _notepadDataService.GetNotepadFromUserAndInquiryId(42, 42);
+
+        Assert.Equal(notepad.UserId,result.UserId);
+        Assert.Equal(notepad.InquiryId,result.InquiryId);
+        Assert.Equal(notepad.Notes,result.Notes);
+    }
+    
+    [Fact]
+    public void SetNotepad_Fail_UserNotFound()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        var notepad = new NotepadEntity { UserId = 42, InquiryId = 42, Notes = "These are some notes" };
+        _dbContext.SaveChanges();
+        Assert.Throws<ArgumentException>(() =>
+        {
+            _notepadDataService.SetNotepadFromUserAndInquiryId(10, 42, "Some notes");
+        });
+    }
+    
+    [Fact]
+    public void SetNotepad_Fail_InquiryNotFound()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        var notepad = new NotepadEntity { UserId = 42, InquiryId = 42, Notes = "These are some notes" };
+        _dbContext.SaveChanges();
+        Assert.Throws<ArgumentException>(() =>
+        {
+            _notepadDataService.SetNotepadFromUserAndInquiryId(42, 10, "Some notes");
+        });
+    }
+    
+    [Fact]
+    public void SetNotepad_Fail_NotepadAlreadyExists()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        var notepad = new NotepadEntity { UserId = 42, InquiryId = 42, Notes = "Some notes" };
+        _dbContext.Notepads.Add(notepad);
+        _dbContext.SaveChanges();
+        Assert.Throws<ArgumentException>(() =>
+        {
+            _notepadDataService.SetNotepadFromUserAndInquiryId(42, 42, "Some notes");
+        });
+    }
+    
+    [Fact]
+    public void UpdateNotepad_Success()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Descritpion", IsUser = false });
+        _dbContext.Users.Add(new UserEntity
+            { Id = 42, Username = "Username", Email = "email@example.com", Password = "password", IsAdmin = true });
+        var notepad = new NotepadEntity { UserId = 42, InquiryId = 42, Notes = "Some notes" };
+        _dbContext.Notepads.Add(notepad);
+        _dbContext.SaveChanges();
+        _notepadDataService.UpdateNotepadFromUserAndInquiryId(42,42, "New Notes");
+        _dbContext.SaveChanges();
+        Assert.Equal("New Notes", _notepadDataService.GetNotepadFromUserAndInquiryId(42,42).Notes);
+    }
+}

API_SQLuedo/TestEF/Service/TestSolutionDataService.cs

@@ -0,0 +1,75 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+
+namespace TestEF.Service;
+
+public class TestSolutionDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly SolutionDataService _solutionDataService;
+
+    public TestSolutionDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _solutionDataService = new SolutionDataService(_dbContext);
+    }
+
+    [Fact]
+    public void GetSolution_Success()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Description", IsUser = false });
+        var solution = new SolutionEntity
+        {
+            MurdererFirstName = "Maxime",
+            MurdererLastName = "Sapountzis",
+            MurderPlace = "La cuisine",
+            MurderWeapon = "Le couteau",
+            Explaination = "Parce que",
+            OwnerId = 42,
+        };
+        _dbContext.Solutions.Add(solution);
+        _dbContext.SaveChanges();
+
+        var result = _solutionDataService.GetSolutionByInquiryId(42);
+
+        Assert.Equal(solution.MurdererFirstName,result.MurdererFirstName);
+        Assert.Equal(solution.MurdererLastName,result.MurdererLastName);
+        Assert.Equal(solution.MurderPlace,result.MurderPlace);
+        Assert.Equal(solution.MurderWeapon,result.MurderWeapon);
+        Assert.Equal(solution.Explaination,result.Explaination);
+        Assert.Equal(solution.OwnerId,result.OwnerId);
+    }
+    
+    [Fact]
+    public void GetSolution_NotFound()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity
+            { Id = 42, Title = "Titre", Description = "Description", IsUser = false });
+        var solution = new SolutionEntity
+        {
+            MurdererFirstName = "Maxime",
+            MurdererLastName = "Sapountzis",
+            MurderPlace = "La cuisine",
+            MurderWeapon = "Le couteau",
+            Explaination = "Parce que",
+            OwnerId = 42,
+        };
+        _dbContext.Solutions.Add(solution);
+        _dbContext.SaveChanges();
+
+        Assert.Throws<ArgumentException>(() =>
+        {
+            _solutionDataService.GetSolutionByInquiryId(10);
+        });
+    }
+}

API_SQLuedo/TestEF/Service/TestUserDataService.cs

@@ -27,9 +27,9 @@ public class TestUserDataService
     [Fact]
     public void GetUsers_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test10", Email = "example1@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test12", Email = "example2@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test13", Email = "example3@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetUsers(1, 2, UserOrderCriteria.None);
         Assert.Equal(2, result.Count());
@@ -38,9 +38,9 @@ public class TestUserDataService
     [Fact]
     public void GetNotAdminUsers_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test14", Email = "example4@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test15", Email = "example5@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test16", Email = "example6@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.None);
         Assert.Equal(1, result.Count());
@@ -49,9 +49,9 @@ public class TestUserDataService
     [Fact]
     public void GetNotAdminUsers_BadPage_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test17", Email = "example7@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test18", Email = "example8@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test19", Email = "example9@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetNotAdminUsers(-42, 2, UserOrderCriteria.None);
         Assert.Equal(1, result.Count());
@@ -60,9 +60,9 @@ public class TestUserDataService
     [Fact]
     public void GetNotAdminUsers_BadNumber_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test20", Email = "example10@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test21", Email = "example11@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test22", Email = "example12@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetNotAdminUsers(1, -42, UserOrderCriteria.None);
         Assert.Equal(1, result.Count());
@@ -71,9 +71,9 @@ public class TestUserDataService
     [Fact]
     public void GetNotAdminUsers_OrderedById_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test23", Email = "example13@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test24", Email = "example14@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test51", Email = "example15@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.ById);
         Assert.Equal(1, result.Count());
@@ -82,9 +82,9 @@ public class TestUserDataService
     [Fact]
     public void GetNotAdminUsers_OrderedByUsername_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test25", Email = "example16@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test26", Email = "example17@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test27", Email = "example18@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.ByUsername);
         Assert.Equal(1, result.Count());
@@ -93,9 +93,9 @@ public class TestUserDataService
     [Fact]
     public void GetNotAdminUsers_OrderedByEmail_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test52", Email = "example45@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test53", Email = "example46@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test54", Email = "example17@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.ByEmail);
         Assert.Equal(1, result.Count());
@@ -104,9 +104,9 @@ public class TestUserDataService
     [Fact]
     public void GetNotAdminUsers_OrderedByIsAdmin_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test28", Email = "example19@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test29", Email = "example20@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test30", Email = "example21@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.ByIsAdmin);
         Assert.Equal(1, result.Count());
@@ -115,9 +115,9 @@ public class TestUserDataService
     [Fact]
     public void GetNumberOfUsers_ReturnsCorrectNumberOfUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test31", Email = "example22@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test32", Email = "example23@email.com", Password = "password", IsAdmin = false });
-        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test3", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test33", Email = "example24@email.com", Password = "password", IsAdmin = true });
         _dbContext.SaveChanges();
         var result = _userDataService.GetNumberOfUsers();
         Assert.Equal(3, result);
@@ -126,29 +126,29 @@ public class TestUserDataService
     [Fact]
     public void GetUserById_ReturnsCorrectUser()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test34", Email = "example25@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test35", Email = "example26@email.com", Password = "password", IsAdmin = false });
         _dbContext.SaveChanges();
         var result = _userDataService.GetUserById(1);
-        Assert.Equal("Test1", result.Username);
+        Assert.Equal("Test34", result.Username);
     }
 
     [Fact]
     public void GetUserByUsername_ReturnsCorrectUser()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test36", Email = "example27@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test37", Email = "example28@email.com", Password = "password", IsAdmin = false });
         _dbContext.SaveChanges();
-        var result = _userDataService.GetUserByUsername("Test1");
+        var result = _userDataService.GetUserByUsername("Test36");
         Assert.Equal(1, result.Id);
     }
     [Fact]
     public void GetUserByEmail_ReturnsCorrectUser()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test38", Email = "example29@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test39", Email = "example30@email.com", Password = "password", IsAdmin = false });
         _dbContext.SaveChanges();
-        var result = _userDataService.GetUserByEmail("example@email.com");
+        var result = _userDataService.GetUserByEmail("example29@email.com");
         Assert.Equal(1, result.Id);
     }
 
@@ -196,8 +196,8 @@ public class TestUserDataService
     [Fact]
     public void GetUsers_WithBadPage_ReturnsClassicUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test40", Email = "example31@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test41", Email = "example32@email.com", Password = "password", IsAdmin = false });
         _dbContext.SaveChanges();
 
         var result = _userDataService.GetUsers(-1, 2, UserOrderCriteria.None);
@@ -208,8 +208,8 @@ public class TestUserDataService
     [Fact]
     public void GetUsers_WithBadNumber_ReturnsClassicUsers()
     {
-        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test43", Email = "example33@email.com", Password = "password", IsAdmin = true });
-        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test2", Email = "example@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test44", Email = "example34@email.com", Password = "password", IsAdmin = false });
         _dbContext.SaveChanges();
 
         var result = _userDataService.GetUsers(1, -42, UserOrderCriteria.None);
@@ -253,6 +253,26 @@ public class TestUserDataService
 
         Assert.False(result);
     }
+    [Fact]
+    public void isEmailTaken_ReturnFalse()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test81", Email = "example81@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        var result = _userDataService.IsEmailTaken("example895@email.com");
+
+        Assert.False(result);
+    }
+    [Fact]
+    public void isEmailTaken_ReturnTrue()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test82", Email = "example82@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        var result = _userDataService.IsEmailTaken("example82@email.com");
+
+        Assert.True(result);
+    }
     
     [Fact]
     public void DeleteUserByUsername_WithoutExisting_ReturnsFalse()