ajout de DeleteNotePad

.drone.yml

@@ -20,17 +20,17 @@ steps:
       - cd API_SQLuedo/
       - dotnet restore API_SQLuedo.sln
       - dotnet test API_SQLuedo.sln -c Release --no-build --no-restore
-    depends_on: [build]
+    depends_on: [ build ]
 
   - name: code-inspection
     image: hub.codefirst.iut.uca.fr/marc.chevaldonne/codefirst-dronesonarplugin-dotnet8
-    secrets: [SECRET_SONAR_LOGIN]
+    secrets: [ SECRET_SONAR_LOGIN ]
     environment:
       sonar_host: https://codefirst.iut.uca.fr/sonar/
       sonar_token:
         from_secret: SECRET_SONAR_LOGIN
       project_key: API_SQLuedo
-      coverage_exclusions: "**/Test*/**,**/*Context*/**,**/Program.cs,**/Migrations/**"
+      coverage_exclusions: "**/Test*/**,**/*Context*/**,**/Program.cs"
     commands:
       - cd API_SQLuedo/
       - dotnet restore API_SQLuedo.sln
@@ -40,7 +40,7 @@ steps:
       - reportgenerator -reports:"**/coverage.cobertura.xml" -reporttypes:SonarQube -targetdir:"coveragereport"
       - dotnet publish API_SQLuedo.sln -c Release --no-restore -o CI_PROJECT_DIR/build/release
       - dotnet sonarscanner end /d:sonar.login=$${sonar_token}
-    depends_on: [build]
+    depends_on: [ build ]
 
   - name: deploy-sqluedo-db
     image: hub.codefirst.iut.uca.fr/thomas.bellembois/codefirst-dockerproxy-clientdrone:latest
@@ -56,38 +56,4 @@ steps:
         from_secret: db_password
       CODEFIRST_CLIENTDRONE_ENV_POSTGRES_DB:
         from_secret: db_database
-      ADMINS: erwanmenager,maximesapountzis,johnnyratton,victorgaborit,clementchieu
+      ADMINS: erwanmenager,maximesapountzis,johnnyratton,victorgaborit,clementchieu 
-    depends_on: [tests]
-
-  # Build and push API image
-  - name: api-image-build-and-push
-    image: plugins/docker
-    settings:
-      dockerfile: API_SQLuedo/API/Dockerfile
-      context: API_SQLuedo/
-      registry: hub.codefirst.iut.uca.fr
-      repo: hub.codefirst.iut.uca.fr/johnny.ratton/api_sqluedo
-      mirror: https://proxy.iut.uca.fr:8443
-      username:
-        from_secret: secret_registry_username
-      password:
-        from_secret: secret_registry_password
-
-  # Deploy API
-  - name: deploy-api-from-image
-    image: hub.codefirst.iut.uca.fr/thomas.bellembois/codefirst-dockerproxy-clientdrone:latest
-    environment:
-      IMAGENAME: hub.codefirst.iut.uca.fr/johnny.ratton/api_sqluedo:latest
-      CONTAINERNAME: sqluedo-api
-      COMMAND: create
-      OVERWRITE: true
-      CODEFIRST_CLIENTDRONE_ENV_DB_HOST:
-        from_secret: db_host
-      CODEFIRST_CLIENTDRONE_ENV_DB_USER:
-        from_secret: db_username
-      CODEFIRST_CLIENTDRONE_ENV_DB_PASSWORD:
-        from_secret: db_password
-      CODEFIRST_CLIENTDRONE_ENV_DB_DATABASE:
-        from_secret: db_database
-      ADMINS: erwanmenager,maximesapountzis,johnnyratton,victorgaborit,clementchieu
-    depends_on: [ api-image-build-and-push, deploy-sqluedo-db ]

.gitignore

@@ -492,7 +492,8 @@ fabric.properties
 .idea/caches/build_file_checksums.ser
 
 
-# Fichier db
+# Migrations et fichiers db
+**/Migrations/**
 *.db
 
 /**/.idea/

API_SQLuedo/API/API.csproj

@@ -21,7 +21,6 @@
       <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

@@ -1,9 +1,11 @@
 using Asp.Versioning;
 using Dto;
+using Entities;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Model.OrderCriteria;
 using Shared;
+using Shared.Mapper;
 
 namespace API.Controllers;
 
@@ -11,8 +13,7 @@ namespace API.Controllers;
 [Authorize]
 [ApiVersion("1.0")]
 [ApiController]
-public class BlackListController(ILogger<UsersController> logger, IBlackListService<BlackListDto> blackListService)
+public class BlackListController(ILogger<UsersController> logger, IBlackListService<BlackListDto> blackListService) : ControllerBase
-    : ControllerBase
 {
     [HttpGet("user/ban/{page:int}/{number:int}")]
     [ProducesResponseType(typeof(IEnumerable<BlackListDto>), 200)]
@@ -29,7 +30,7 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
         logger.LogInformation("[INFORMATION] {nb} Email(s) banni(s) trouvé(s)", users.Count);
         return Ok(users);
     }
-
+    
     [HttpGet("user/ban/number")]
     [ProducesResponseType(typeof(UserDto), 200)]
     [ProducesResponseType(typeof(string), 204)]
@@ -39,7 +40,7 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
         logger.LogInformation("[INFORMATION] {nb} Email(s) banni(s) trouvé(s)", nb);
         return Ok(new KeyValuePair<string,int>("number",nb));
     }
-
+    
     [HttpPost("user/ban")]
     [ProducesResponseType(typeof(UserDto), 200)]
     [ProducesResponseType(typeof(string), 404)]
@@ -49,13 +50,12 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
         if (res != null)
         {
             logger.LogInformation("[INFORMATION] Utilisateur banni avec l'email {email} a été trouvé.", email);
-            return Ok(res);
+            return Ok(res);   
         }
-
         logger.LogError("[ERREUR] Aucun utilisateur banni trouvé avec l'email {email}.", email);
         return NotFound("Utilisateur non trouvé !");
     }
-
+    
     [HttpDelete("user/ban/{username:alpha}")]
     [ProducesResponseType(typeof(UserDto), 200)]
     [ProducesResponseType(typeof(string), 404)]
@@ -73,7 +73,7 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
             return NotFound();
         }
     }
-
+    
     [HttpPost("user/unban")]
     [ProducesResponseType(typeof(UserDto), 200)]
     [ProducesResponseType(typeof(string), 404)]

API_SQLuedo/API/Controllers/InquiriesController.cs

@@ -5,145 +5,146 @@ using Model.OrderCriteria;
 using Shared;
 using Asp.Versioning;
 
-namespace API.Controllers;
+namespace API.Controllers
-
-[Route("api/v{version:apiVersion}/[controller]")]
-[Authorize]
-[ApiVersion("1.0")]
-[ApiController]
-public class InquiriesController : Controller
 {
-    private readonly IInquiryService<InquiryDto> _inquiryDataService;
+    [Route("api/v{version:apiVersion}/[controller]")]
-
+    [Authorize]
-    private readonly ILogger<InquiriesController> _logger;
+    [ApiVersion("1.0")]
-
+    [ApiController]
-    public InquiriesController(IInquiryService<InquiryDto> inquiryDataService, ILogger<InquiriesController> logger)
+    public class InquiriesController : Controller
     {
-        _inquiryDataService = inquiryDataService;
+        private readonly IInquiryService<InquiryDto> _inquiryDataService;
-        _logger = logger;
-    }
 
-    [HttpGet("inquiries/{page:int}/{number:int}/{orderCriteria}")]
+        private readonly ILogger<InquiriesController> _logger;
-    [ProducesResponseType(typeof(InquiryDto), 200)]
-    [ProducesResponseType(typeof(string), 204)]
-    public IActionResult GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
-    {
-        var nbInquiry = _inquiryDataService.GetInquiries(page, number, orderCriteria).Count();
-        if (nbInquiry == 0)
-        {
-            _logger.LogError("[ERREUR] Aucune enquête trouvée.");
-            return StatusCode(204);
-        }
-
-        _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
-        return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria));
-    }
 
-    [HttpGet("inquiry/{id:int}")]
+        public InquiriesController(IInquiryService<InquiryDto> inquiryDataService, ILogger<InquiriesController> logger)
-    [ProducesResponseType(typeof(InquiryDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult GetInquiryById(int id)
-    {
-        try
-        {
-            _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été trouvé.", id);
-            return Ok(_inquiryDataService.GetInquiryById(id));
-        }
-        catch (ArgumentException)
         {
-            _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+            _inquiryDataService = inquiryDataService;
-            return NotFound();
+            _logger = logger;
         }
-    }
 
-    [HttpGet("inquiry/{title:alpha}")]
+        [HttpGet("inquiries/{page:int}/{number:int}/{orderCriteria}")]
-    [ProducesResponseType(typeof(InquiryDto), 200)]
+        [ProducesResponseType(typeof(InquiryDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(string), 204)]
-    public IActionResult GetInquiryByTitle(string title)
+        public IActionResult GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
-    {
-        try
         {
-            _logger.LogInformation("[INFORMATION] L'enquête avec le titre {title} a été trouvé.", title);
+            var nbInquiry = _inquiryDataService.GetInquiries(page, number, orderCriteria).Count();
-            return Ok(_inquiryDataService.GetInquiryByTitle(title));
+            if (nbInquiry == 0)
+            {
+                _logger.LogError("[ERREUR] Aucune enquête trouvée.");
+                return StatusCode(204);
+            }
+
+            _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
+            return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria));
         }
-        catch (ArgumentException)
+        
+        [HttpGet("inquiries/number")]
+        [ProducesResponseType(typeof(InquiryDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetNumberOfInquiries()
         {
-            _logger.LogError("[ERREUR] Aucune enquête trouvée avec le titre {title}.", title);
+            var nbInquiry = _inquiryDataService.GetNumberOfInquiries();
-            return NotFound();
+            _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
+            return Ok(new KeyValuePair<string,int>("nbInquiries", nbInquiry));
         }
-    }
 
-    [HttpDelete("inquiry/{id:int}")]
+        [HttpGet("inquiry/{id:int}")]
-    [ProducesResponseType(typeof(InquiryDto), 200)]
+        [ProducesResponseType(typeof(InquiryDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(string), 404)]
-    public IActionResult DeleteInquiry(int id)
+        public IActionResult GetInquiryById(int id)
-    {
-        var success = _inquiryDataService.DeleteInquiry(id);
-        if (success)
-        {
-            _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été supprimé.", id);
-            return Ok(_inquiryDataService.DeleteInquiry(id));
-        }
-        else
         {
-            _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+            try
-            return NotFound();
+            {
+                _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été trouvé.", id);
+                return Ok(_inquiryDataService.GetInquiryById(id));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+                return NotFound();
+            }
         }
-    }
 
-    [HttpPost]
+        [HttpGet("inquiry/{title:alpha}")]
-    [ProducesResponseType(typeof(InquiryDto), 201)]
+        [ProducesResponseType(typeof(InquiryDto), 200)]
-    [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
-    public IActionResult CreateInquiry([FromBody] InquiryDto dto)
+        public IActionResult GetInquiryByTitle(string title)
-    {
-        if (dto.Title == null || dto.Description == null)
         {
-            return BadRequest();
+            try
+            {
+                _logger.LogInformation("[INFORMATION] L'enquête avec le titre {title} a été trouvé.", title);
+                return Ok(_inquiryDataService.GetInquiryByTitle(title));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucune enquête trouvée avec le titre {title}.", title);
+                return NotFound();
+            }
         }
 
-        _logger.LogInformation(
+        [HttpDelete("inquiry/{id:int}")]
-            "[INFORMATION] Une enquête a été créé : title - {title}, description - {description}, isUser - {isUser}",
+        [ProducesResponseType(typeof(InquiryDto), 200)]
-            dto.Title, dto.Description, dto.IsUser);
+        [ProducesResponseType(typeof(string), 404)]
-        return Created(nameof(GetInquiries),
+        public IActionResult DeleteInquiry(int id)
-            _inquiryDataService.CreateInquiry(dto.Title, dto.Description, dto.IsUser));
-    }
-
-    [HttpPut("inquiry/{id:int}")]
-    [ProducesResponseType(typeof(InquiryDto), 200)]
-    [ProducesResponseType(typeof(string), 400)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult UpdateInquiry(int id, [FromBody] InquiryDto InquiryDto)
-    {
-        if (id != InquiryDto.Id)
         {
-            _logger.LogError("[ERREUR] Problème ID - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
+            var success = _inquiryDataService.DeleteInquiry(id);
-            return BadRequest();
+            if (success)
+            {
+                _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été supprimé.", id);
+                return Ok(_inquiryDataService.DeleteInquiry(id));
+            }
+            else
+            {
+                _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+                return NotFound();
+            }
         }
 
-        if (!ModelState.IsValid)
+        [HttpPost]
+        [ProducesResponseType(typeof(InquiryDto), 201)]
+        [ProducesResponseType(typeof(string), 400)]
+        public IActionResult CreateInquiry([FromBody] InquiryDto dto)
         {
-            _logger.LogError(
+            if (dto.Title == null || dto.Description == null)
-                "[ERREUR] Problème controlleur - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
+            {
-            return BadRequest();
+                return BadRequest();
+            }
+
+            _logger.LogInformation(
+                "[INFORMATION] Une enquête a été créé : title - {title}, description - {description}, isUser - {isUser}",
+                dto.Title, dto.Description, dto.IsUser);
+            return Created(nameof(GetInquiries),
+                _inquiryDataService.CreateInquiry(dto.Title, dto.Description, dto.IsUser));
         }
 
-        if (InquiryDto != null)
+        [HttpPut("inquiry/{id:int}")]
+        [ProducesResponseType(typeof(InquiryDto), 200)]
+        [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult UpdateInquiry(int id, [FromBody] InquiryDto InquiryDto)
         {
-            _logger.LogInformation("[INFORMATION] La mise à jour de l'enquête avec l'id {id} a été effectuée", id);
+            if (id != InquiryDto.Id)
-            return Ok(_inquiryDataService.UpdateInquiry(id, InquiryDto));
+            {
-        }
+                _logger.LogError("[ERREUR] Problème ID - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
-
+                return BadRequest();
-        _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+            }
-        return NotFound();
+
-    }
+            if (!ModelState.IsValid)
+            {
+                _logger.LogError(
+                    "[ERREUR] Problème controlleur - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
+                return BadRequest();
+            }
+
+            if (InquiryDto != null)
+            {
+                _logger.LogInformation("[INFORMATION] La mise à jour de l'enquête avec l'id {id} a été effectuée", id);
+                return Ok(_inquiryDataService.UpdateInquiry(id, InquiryDto));
+            }
 
-    [HttpGet("inquiries/number")]
+            _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
-    [ProducesResponseType(typeof(InquiryDto), 200)]
+            return NotFound();
-    [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

@@ -1,42 +0,0 @@
-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(_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

@@ -1,172 +1,155 @@
-using Microsoft.AspNetCore.Authorization;
+using System.Net;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Dto;
 using Model.OrderCriteria;
 using Shared;
 using Asp.Versioning;
 
-namespace API.Controllers;
+namespace API.Controllers
-
-[Route("api/v{version:apiVersion}/[controller]")]
-        [Authorize]
-        [ApiVersion("1.0")]
-        [ApiController]
-        public class LessonsController : Controller
 {
-    private readonly ILessonService<LessonDto> _lessonDataService;
+    [Route("api/v{version:apiVersion}/[controller]")]
-
+    [Authorize]
-    private readonly ILogger<LessonsController> _logger;
+    [ApiVersion("1.0")]
-
+    [ApiController]
-    public LessonsController(ILessonService<LessonDto> lessonDataService, ILogger<LessonsController> logger)
+    public class LessonsController : Controller
     {
-        _lessonDataService = lessonDataService;
+        private readonly ILessonService<LessonDto> _lessonDataService;
-        _logger = logger;
-    }
 
-    [HttpGet("lessons/{page:int}/{number:int}/{orderCriteria}")]
+        private readonly ILogger<LessonsController> _logger;
-    [ProducesResponseType(typeof(LessonDto), 200)]
-    [ProducesResponseType(typeof(string), 204)]
-    public IActionResult GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
-    {
-        var nbLesson = _lessonDataService.GetLessons(page, number, orderCriteria).Count();
-        if (nbLesson == 0)
-        {
-            _logger.LogError("[ERREUR] Aucune leçon trouvée.");
-            return StatusCode(204);
-        }
 
-        _logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson);
+        public LessonsController(ILessonService<LessonDto> lessonDataService, ILogger<LessonsController> logger)
-        return Ok(_lessonDataService.GetLessons(page, number, orderCriteria));
-    }
-    
-    [HttpGet("lessons/number")]
-    [ProducesResponseType(typeof(LessonDto), 200)]
-    [ProducesResponseType(typeof(string), 204)]
-    public IActionResult GetNumberOfLessons()
-    {
-        var nbLesson = _lessonDataService.GetNumberOfLessons();
-        if (nbLesson == 0)
         {
-            _logger.LogError("[ERREUR] Aucune leçon trouvée.");
+            _lessonDataService = lessonDataService;
-            return StatusCode(204);
+            _logger = logger;
         }
 
-        _logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson);
+        [HttpGet("lessons/{page:int}/{number:int}/{orderCriteria}")]
-        return Ok(new KeyValuePair<string,int>("nbLessons", nbLesson));
+        [ProducesResponseType(typeof(LessonDto), 200)]
-    }
+        [ProducesResponseType(typeof(string), 204)]
-
+        public IActionResult GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
-    [HttpGet("lesson/{id:int}")]
-    [ProducesResponseType(typeof(LessonDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult GetLessonById(int id)
-    {
-        try
         {
-            _logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été trouvé.", id);
+            var nbLesson = _lessonDataService.GetLessons(page, number, orderCriteria).Count();
-            return Ok(_lessonDataService.GetLessonById(id));
+            if (nbLesson == 0)
-        }
+            {
-        catch (ArgumentException)
+                _logger.LogError("[ERREUR] Aucune leçon trouvée.");
-        {
+                return StatusCode(204);
-            _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
+            }
-            return NotFound();
-        }
-    }
 
-    [HttpGet("lesson/{title:alpha}")]
+            _logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson);
-    [ProducesResponseType(typeof(LessonDto), 200)]
+            return Ok(_lessonDataService.GetLessons(page, number, orderCriteria));
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult GetLessonByTitle(string title)
-    {
-        try
-        {
-            _logger.LogInformation("[INFORMATION] La leçon avec le titre {title} a été trouvé.", title);
-            return Ok(_lessonDataService.GetLessonByTitle(title));
-        }
-        catch (ArgumentException)
-        {
-            _logger.LogError("[ERREUR] Aucune leçon trouvée avec le titre {title}.", title);
-            return NotFound();
         }
-    }
 
-    [HttpDelete("lesson/{id:int}")]
+        [HttpGet("lesson/{id:int}")]
-    [ProducesResponseType(typeof(LessonDto), 200)]
+        [ProducesResponseType(typeof(LessonDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(string), 404)]
-    public IActionResult DeleteLesson(int id)
+        public IActionResult GetLessonById(int id)
-    {
-        var success = _lessonDataService.DeleteLesson(id);
-        if (success)
-        {
-            _logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été supprimé.", id);
-            return Ok(_lessonDataService.DeleteLesson(id));
-        }
-        else
         {
-            _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
+            try
-            return NotFound();
+            {
+                _logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été trouvé.", id);
+                return Ok(_lessonDataService.GetLessonById(id));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
+                return NotFound();
+            }
         }
-    }
 
-    [HttpPost]
+        [HttpGet("lesson/{title:alpha}")]
-    [ProducesResponseType(typeof(LessonDto), 201)]
+        [ProducesResponseType(typeof(LessonDto), 200)]
-    [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
-    [ProducesResponseType(typeof(string), 500)]
+        public IActionResult GetLessonByTitle(string title)
-    public IActionResult CreateLesson([FromBody] LessonDto dto)
-    {
-        if (dto.Title == null || dto.LastPublisher == null)
         {
-            return BadRequest();
+            try
+            {
+                _logger.LogInformation("[INFORMATION] La leçon avec le titre {title} a été trouvé.", title);
+                return Ok(_lessonDataService.GetLessonByTitle(title));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucune leçon trouvée avec le titre {title}.", title);
+                return NotFound();
+            }
         }
 
-        try
+        [HttpDelete("lesson/{id:int}")]
+        [ProducesResponseType(typeof(LessonDto), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult DeleteLesson(int id)
         {
-            var createdLesson = _lessonDataService.CreateLesson(dto.Id, dto.Title, dto.LastPublisher,
+            var success = _lessonDataService.DeleteLesson(id);
-                dto.LastEdit ?? DateOnly.FromDateTime(DateTime.Now));
+            if (success)
-            if (createdLesson != null)
             {
-                _logger.LogInformation(
+                _logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été supprimé.", id);
-                    "[INFORMATION] Une leçon a été créé : title - {title}, lastPublisher - {publisher}, lastEdit - {lastEdit}",
+                return Ok(_lessonDataService.DeleteLesson(id));
-                    dto.Title, dto.LastPublisher, dto.LastEdit);
-                return Created(nameof(GetLessons), createdLesson);
             }
             else
             {
-                return StatusCode(500);
+                _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
+                return NotFound();
             }
         }
-        catch (ArgumentException e)
-        {
-            _logger.LogError("[ERREUR] " + e.Message);
-            return Created();
-        }
-    }
 
-    [HttpPut("lesson/{id:int}")]
+        [HttpPost]
-    [ProducesResponseType(typeof(LessonDto), 200)]
+        [ProducesResponseType(typeof(LessonDto), 201)]
-    [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 400)]
-    [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(string), 500)]
-    public IActionResult UpdateLesson(int id, [FromBody] LessonDto LessonDto)
+        public IActionResult CreateLesson([FromBody] LessonDto dto)
-    {
-        if (id != LessonDto.Id)
         {
-            _logger.LogError("[ERREUR] Problème ID - La mise à jour de la leçon avec l'id {id} a échouée.", id);
+            if (dto.Title == null || dto.LastPublisher == null)
-            return BadRequest();
+            {
+                return BadRequest();
+            }
+            try
+            {
+                var createdLesson = _lessonDataService.CreateLesson(dto.Id, dto.Title, dto.LastPublisher, dto.LastEdit ?? DateOnly.FromDateTime(DateTime.Now));
+                if (createdLesson != null)
+                {
+                    _logger.LogInformation(
+                        "[INFORMATION] Une leçon a été créé : title - {title}, lastPublisher - {publisher}, lastEdit - {lastEdit}",
+                        dto.Title, dto.LastPublisher, dto.LastEdit);
+                    return Created(nameof(GetLessons), createdLesson);
+                }
+                else
+                {
+                    return StatusCode(500);
+                }
+            }
+            catch (ArgumentException e)
+            {
+                _logger.LogError("[ERREUR] " + e.Message);
+                return Created();
+            }
         }
 
-        if (!ModelState.IsValid)
+        [HttpPut("lesson/{id:int}")]
+        [ProducesResponseType(typeof(LessonDto), 200)]
+        [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult UpdateLesson(int id, [FromBody] LessonDto LessonDto)
         {
-            _logger.LogError("[ERREUR] Problème controlleur - La mise à jour de la leçon avec l'id {id} a échouée.",
+            if (id != LessonDto.Id)
-                id);
+            {
-            return BadRequest();
+                _logger.LogError("[ERREUR] Problème ID - La mise à jour de la leçon avec l'id {id} a échouée.", id);
-        }
+                return BadRequest();
+            }
 
-        if (LessonDto != null)
+            if (!ModelState.IsValid)
-        {
+            {
-            _logger.LogInformation("[INFORMATION] La mise à jour de la leçon avec l'id {id} a été effectuée", id);
+                _logger.LogError("[ERREUR] Problème controlleur - La mise à jour de la leçon avec l'id {id} a échouée.",
-            return Ok(_lessonDataService.UpdateLesson(id, LessonDto));
+                    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);
+                return Ok(_lessonDataService.UpdateLesson(id, LessonDto));
+            }
 
-        _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
+            _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
-        return NotFound();
+            return NotFound();
+        }
     }
 }

API_SQLuedo/API/Controllers/NotepadController.cs

@@ -1,5 +1,6 @@
 using Asp.Versioning;
 using Dto;
+using Entities;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Shared;
@@ -10,88 +11,67 @@ namespace API.Controllers;
 [Authorize]
 [ApiVersion("1.0")]
 [ApiController]
-public class NotepadController : Controller
+public class NotepadController(ILogger<NotepadController> logger, INotePadService<NotepadDto> notePadService) : ControllerBase
 {
-    private readonly INotepadService<NotepadDto> _notepadDataService;
+    [HttpGet("notePad/{id:int}")]
-
+    [ProducesResponseType(typeof(UserDto), 200)]
-    private readonly ILogger<NotepadController> _logger;
+    [ProducesResponseType(typeof(string), 404)]
-
+    public IActionResult GetNotePadById(int id)
-    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(
+            logger.LogInformation(" [INFORMATION] Le bloc note avec l'id {id} a été trouvé.", id);
-                "[INFORMATION] Le bloc-notes de l'utilisateur avec l'id {id} et l'enquête avec l'id {idInquiry} a été trouvé.",
+            return Ok(notePadService.GetNotePadById(id));
-                userId, inquiryId);
-            return Ok(_notepadDataService.GetNotepadFromUserAndInquiryId(userId,inquiryId));
         }
         catch (ArgumentException)
         {
-            _logger.LogError(
+            logger.LogError("[ERREUR] Aucun bloc n'a été trouvé pour l'id {id}.", id);
-                "[ERREUR] Aucun bloc-notes trouvé pour l'utilisateur avec l'id {id} et l'enquête avec l'id {inquiryId}.",
-                userId, inquiryId);
             return NotFound();
         }
     }
-    
+    [HttpGet("notePad/{idUser:int}/{idInquiry:int}")]
-    [HttpPost("notepad")]
+    [ProducesResponseType(typeof(UserDto), 200)]
-    [ProducesResponseType(typeof(void), 200)]
+    [ProducesResponseType(typeof(string), 404)]
-    [ProducesResponseType(typeof(void), 404)]
+    public IActionResult GetNotePadByIdInquiryAndIdUser(int idUser, int idInquiry)
-    public IActionResult SetNotepadByUserAndInquiryById([FromBody] NotepadDto notepad)
     {
         try
         {
-            if (notepad.InquiryId < 0 || notepad.UserId < 0 || notepad.Notes == null)
+            logger.LogInformation(" [INFORMATION] Le bloc note a été trouvé.");
-            {
+            return Ok(notePadService.GetNotePadByIdUserAndIdInquiry(idUser, idInquiry));
-                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(
+            logger.LogError("[ERREUR] Aucun bloc n'a été trouvé.");
-                "[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();
         }
     }
-    
+    [HttpPost]
-    [HttpPut("notepad")]
+    [ProducesResponseType(typeof(UserDto), 201)]
-    [ProducesResponseType(typeof(void), 203)]
+    [ProducesResponseType(typeof(string), 409)]
-    [ProducesResponseType(typeof(void), 404)]
+    public IActionResult CreateNotePad([FromBody] NotepadDto notepadDto)
-    public IActionResult UpdateNotepadByUserAndInquiryById([FromBody] NotepadDto notepad)
     {
         try
         {
-            if (notepad.InquiryId < 0 || notepad.UserId < 0 || notepad.Notes == null)
+            var existingNotePad = notePadService.GetNotePadByIdUserAndIdInquiry(notepadDto.UserId, notepadDto.InquiryId);
-            {
+            logger.LogError("[ERREUR] Le bloc note existe déjà impossible de le crée");
-                return BadRequest();
+            return StatusCode(409, existingNotePad);
-            }
-            _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(
+            return Ok(notePadService.CreateNotePad(notepadDto.Id, notepadDto.UserId, notepadDto.InquiryId, notepadDto.Notes));
-                "[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();
+    [HttpDelete]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult DeleteNotePad(int id)
+    {
+        if (notePadService.DeleteNotePad(id))
+        {
+            logger.LogInformation("[INFORMATION] le bloc note avec l'id {id} a été supprimé.", id);
+            return Ok();
         }
+        logger.LogError("[ERREUR] Aucun bloc note trouvé avec l'id {id}.", id);
+        return NotFound();
     }
 }

API_SQLuedo/API/Controllers/ParagraphsController.cs

@@ -5,156 +5,139 @@ using Model.OrderCriteria;
 using Shared;
 using Asp.Versioning;
 
-namespace API.Controllers;
+namespace API.Controllers
-
-[Route("api/v{version:apiVersion}/[controller]")]
-[Authorize]
-[ApiVersion("1.0")]
-[ApiController]
-public class ParagraphsController : Controller
 {
-    private readonly IParagraphService<ParagraphDto> _paragraphDataService;
+    [Route("api/v{version:apiVersion}/[controller]")]
-
+    [Authorize]
-    private readonly ILogger<ParagraphsController> _logger;
+    [ApiVersion("1.0")]
-
+    [ApiController]
-    public ParagraphsController(IParagraphService<ParagraphDto> paragraphDataService,
+    public class ParagraphsController : Controller
-        ILogger<ParagraphsController> logger)
-    {
-        _paragraphDataService = paragraphDataService;
-        _logger = logger;
-    }
-
-    [HttpGet("paragraphs/{page:int}/{number:int}/{orderCriteria}")]
-    [ProducesResponseType(typeof(ParagraphDto), 200)]
-    [ProducesResponseType(typeof(string), 204)]
-    public IActionResult GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
     {
-        var nbParagraph = _paragraphDataService.GetParagraphs(page, number, orderCriteria).ToList().Count;
+        private readonly IParagraphService<ParagraphDto> _paragraphDataService;
-        if (nbParagraph == 0)
-        {
-            _logger.LogError("[ERREUR] Aucun paragraphe trouvé.");
-            return StatusCode(204);
-        }
 
-        _logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", nbParagraph);
+        private readonly ILogger<ParagraphsController> _logger;
-        return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria));
-    }
 
-    [HttpGet("paragraphs/lesson/{id:int}")]
+        public ParagraphsController(IParagraphService<ParagraphDto> paragraphDataService,
-    [ProducesResponseType(typeof(IEnumerable<ParagraphDto>), 200)]
+            ILogger<ParagraphsController> logger)
-    [ProducesResponseType(typeof(string), 204)]
-    public IActionResult GetParagraphsByLessonId(int id)
-    {
-        var paragraphs = _paragraphDataService.GetParagraphsByLessonId(id);
-        if (paragraphs.Count() == 0)
         {
-            _logger.LogError("[ERREUR] Aucun paragraphe trouvé.");
+            _paragraphDataService = paragraphDataService;
-            return StatusCode(204);
+            _logger = logger;
         }
 
-        _logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", paragraphs.Count());
+        [HttpGet("paragraphs/{page:int}/{number:int}/{orderCriteria}")]
-        return Ok(paragraphs);
+        [ProducesResponseType(typeof(ParagraphDto), 200)]
-    }
+        [ProducesResponseType(typeof(string), 204)]
-
+        public IActionResult GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
-    [HttpGet("paragraph/{id:int}")]
-    [ProducesResponseType(typeof(ParagraphDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult GetParagraphById(int id)
-    {
-        try
         {
-            _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id);
+            var nbParagraph = _paragraphDataService.GetParagraphs(page, number, orderCriteria).ToList().Count;
-            return Ok(_paragraphDataService.GetParagraphById(id));
+            if (nbParagraph == 0)
+            {
+                _logger.LogError("[ERREUR] Aucun paragraphe trouvé.");
+                return StatusCode(204);
+            }
+
+            _logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", nbParagraph);
+            return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria));
         }
-        catch (ArgumentException)
-        {
-            _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
-            return NotFound();
-        }
-    }
 
-    [HttpGet("paragraph/{title:alpha}")]
+        [HttpGet("paragraph/{id:int}")]
-    [ProducesResponseType(typeof(ParagraphDto), 200)]
+        [ProducesResponseType(typeof(ParagraphDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(string), 404)]
-    public IActionResult GetParagraphByTitle(string title)
+        public IActionResult GetParagraphById(int id)
-    {
-        try
         {
-            _logger.LogInformation("[INFORMATION] Le paragraphe avec le titre {title} a été trouvé.", title);
+            try
-            return Ok(_paragraphDataService.GetParagraphByTitle(title));
+            {
+                _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id);
+                return Ok(_paragraphDataService.GetParagraphById(id));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
+                return NotFound();
+            }
         }
-        catch (ArgumentException)
-        {
-            _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec le titre {title}.", title);
-            return NotFound();
-        }
-    }
 
-    [HttpDelete("paragraph/{id:int}")]
+        [HttpGet("paragraph/{title:alpha}")]
-    [ProducesResponseType(typeof(ParagraphDto), 200)]
+        [ProducesResponseType(typeof(ParagraphDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(string), 404)]
-    public IActionResult DeleteParagraph(int id)
+        public IActionResult GetParagraphByTitle(string title)
-    {
-        var success = _paragraphDataService.DeleteParagraph(id);
-        if (success)
         {
-            _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été supprimé.", id);
+            try
-            return Ok(_paragraphDataService.DeleteParagraph(id));
+            {
+                _logger.LogInformation("[INFORMATION] Le paragraphe avec le titre {title} a été trouvé.", title);
+                return Ok(_paragraphDataService.GetParagraphByTitle(title));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec le titre {title}.", title);
+                return NotFound();
+            }
         }
-        else
-        {
-            _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
-            return NotFound();
-        }
-    }
 
-    [HttpPost]
+        [HttpDelete("paragraph/{id:int}")]
-    [ProducesResponseType(typeof(ParagraphDto), 201)]
+        [ProducesResponseType(typeof(ParagraphDto), 200)]
-    [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
-    public IActionResult CreateParagraph([FromBody] ParagraphDto dto)
+        public IActionResult DeleteParagraph(int id)
-    {
-        if (dto.ContentTitle == null || dto.ContentContent == null || dto.Title == null || dto.Content == null ||
-            dto.Info == null || dto.Query == null ||
-            dto.Comment == null)
         {
-            return BadRequest();
+            var success = _paragraphDataService.DeleteParagraph(id);
+            if (success)
+            {
+                _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été supprimé.", id);
+                return Ok(_paragraphDataService.DeleteParagraph(id));
+            }
+            else
+            {
+                _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
+                return NotFound();
+            }
         }
 
-        _logger.LogInformation(
+        [HttpPost]
-            "[INFORMATION] Un paragraphe a été créé : title - {title}, content - {content}, info - {info}, query - {query}, comment - {comment}",
+        [ProducesResponseType(typeof(ParagraphDto), 201)]
-            dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
+        [ProducesResponseType(typeof(string), 400)]
-        return Created(nameof(GetParagraphs),
+        public IActionResult CreateParagraph([FromBody] ParagraphDto dto)
-            _paragraphDataService.CreateParagraph(dto.ContentTitle, dto.ContentContent, dto.Title, dto.Content,
-                dto.Info, dto.Query, dto.Comment,
-                dto.LessonId));
-    }
-
-    [HttpPut("paragraph/{id:int}")]
-    [ProducesResponseType(typeof(ParagraphDto), 200)]
-    [ProducesResponseType(typeof(string), 400)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult UpdateParagraph(int id, [FromBody] ParagraphDto ParagraphDto)
-    {
-        if (id != ParagraphDto.Id)
         {
-            _logger.LogError("[ERREUR] Problème ID - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
+            if (dto.ContentTitle == null || dto.ContentContent == null || dto.Title == null || dto.Content == null || dto.Info == null || dto.Query == null ||
-            return BadRequest();
+                dto.Comment == null)
+            {
+                return BadRequest();
+            }
+
+            _logger.LogInformation(
+                "[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,
+                    dto.LessonId));
         }
 
-        if (!ModelState.IsValid)
+        [HttpPut("paragraph/{id:int}")]
+        [ProducesResponseType(typeof(ParagraphDto), 200)]
+        [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult UpdateParagraph(int id, [FromBody] ParagraphDto ParagraphDto)
         {
-            _logger.LogError(
+            if (id != ParagraphDto.Id)
-                "[ERREUR] Problème controlleur - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
+            {
-            return BadRequest();
+                _logger.LogError("[ERREUR] Problème ID - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
-        }
+                return BadRequest();
+            }
+
+            if (!ModelState.IsValid)
+            {
+                _logger.LogError(
+                    "[ERREUR] Problème controlleur - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
+                return BadRequest();
+            }
+
+            if (ParagraphDto != null)
+            {
+                _logger.LogInformation("[INFORMATION] La mise à jour du paragraphe avec l'id {id} a été effectuée", id);
+                return Ok(_paragraphDataService.UpdateParagraph(id, ParagraphDto));
+            }
 
-        if (ParagraphDto != null)
+            _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
-        {
+            return NotFound();
-            _logger.LogInformation("[INFORMATION] La mise à jour du paragraphe avec l'id {id} a été effectuée", id);
-            return Ok(_paragraphDataService.UpdateParagraph(id, ParagraphDto));
         }
-
-        _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
-        return NotFound();
     }
 }

API_SQLuedo/API/Controllers/QueryController.cs

@@ -1,65 +0,0 @@
-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 Content(queryResult.Result, "application/json");
-        }
-
-        [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 Content(queryResult.Result, "application/json");
-        }
-
-
-        [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 Content(queryResult.Result, "application/json");
-        }
-    }
-}

API_SQLuedo/API/Controllers/SolutionController.cs

@@ -1,43 +0,0 @@
-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/SuccessesController.cs

@@ -5,202 +5,203 @@ using Model.OrderCriteria;
 using Shared;
 using Asp.Versioning;
 
-namespace API.Controllers;
+namespace API.Controllers
-
-[Route("api/v{version:apiVersion}/[controller]")]
-[Authorize]
-[ApiVersion("1.0")]
-[ApiController]
-public class SuccessesController : Controller
 {
-    private readonly ISuccessService<SuccessDto> _successDataService;
+    [Route("api/v{version:apiVersion}/[controller]")]
-
+    [Authorize]
-    private readonly ILogger<SuccessesController> _logger;
+    [ApiVersion("1.0")]
-
+    [ApiController]
-    public SuccessesController(ISuccessService<SuccessDto> successDataService, ILogger<SuccessesController> logger)
+    public class SuccessesController : Controller
-    {
-        _successDataService = successDataService;
-        _logger = logger;
-    }
-
-    [HttpGet("successes/{page:int}/{number:int}/{orderCriteria}")]
-    [ProducesResponseType(typeof(SuccessDto), 200)]
-    [ProducesResponseType(typeof(string), 204)]
-    [ProducesResponseType(typeof(string), 400)]
-    public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
-    {
-        if (page < 1 || number < 1)
-        {
-            _logger.LogError("[ERREUR] La page ou le nombre de succès est inférieur à 1.");
-            return BadRequest("La page ou le nombre de succès est inférieur à 1.");
-        }
-
-        var nbUser = _successDataService.GetSuccesses(page, number, orderCriteria).ToList().Count;
-        if (nbUser == 0)
-        {
-            _logger.LogError("[ERREUR] Aucun Succès trouvé.");
-            return StatusCode(204);
-        }
-
-        _logger.LogInformation("[INFORMATION] {nb} Succès(s) trouvé(s)", nbUser);
-        return Ok(_successDataService.GetSuccesses(page, number, orderCriteria));
-    }
-
-    [HttpGet("success/user/{id:int}")]
-    [ProducesResponseType(typeof(SuccessDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult GetSuccessByUserId(int id)
-    {
-        if (id < 1)
-        {
-            _logger.LogError("[ERREUR] L'id de l'utilisateur est inférieur à 1.");
-            return BadRequest("L'id de l'utilisateur est inférieur à 1.");
-        }
-
-        try
-        {
-            _logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", id);
-            return Ok(_successDataService.GetSuccessesByUserId(id));
-        }
-        catch (ArgumentException)
-        {
-            _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", id);
-            return NotFound("Aucun utilisateur trouvé avec l'id de l'utilisateur.");
-        }
-    }
-
-    [HttpGet("success/inquiry/{id:int}")]
-    [ProducesResponseType(typeof(SuccessDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult GetSuccessByInquiryId(int id)
-    {
-        if (id < 1)
-        {
-            _logger.LogError("[ERREUR] L'id de l'enquête doit être inférieur à 1.");
-            return BadRequest("L'id de l'enquête doit être inférieur à 1.");
-        }
-
-        try
-        {
-            _logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.",
-                id);
-            return Ok(_successDataService.GetSuccessesByInquiryId(id));
-        }
-        catch (ArgumentException)
-        {
-            _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", id);
-            return NotFound("Aucune enquête trouvée avec l'id de l'enquête.");
-        }
-    }
-
-    [HttpDelete("success/{idUser:int}/{idInquiry:int}")]
-    [ProducesResponseType(typeof(SuccessDto), 200)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult DeleteSuccess(int idUser, int idInquiry)
-    {
-        if (idUser < 1 || idInquiry < 1)
-        {
-            _logger.LogInformation("[INFORMATION] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-            return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-        }
-
-        var success = _successDataService.DeleteSuccess(idUser, idInquiry);
-        if (success)
-        {
-            _logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", idUser);
-            return Ok(success);
-        }
-        else
-        {
-            _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", idUser);
-            return NotFound();
-        }
-    }
-
-    [HttpPost]
-    [ProducesResponseType(typeof(SuccessDto), 201)]
-    [ProducesResponseType(typeof(string), 409)]
-    [ProducesResponseType(typeof(string), 404)]
-    [ProducesResponseType(typeof(string), 400)]
-    public IActionResult CreateSuccess([FromBody] SuccessDto dto)
-    {
-        if (dto.UserId < 1 || dto.InquiryId < 1)
-        {
-            _logger.LogError("[ERREUR] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-            return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-        }
-
-        try
-        {
-            var s = _successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished);
-            _logger.LogInformation(
-                "[INFORMATION] Un succès a été créé : userId - {userId}, inquiryId - {inquiryId}, isFinished - {isFinished}",
-                dto.UserId, dto.InquiryId, dto.IsFinished);
-            return Created(nameof(GetSuccesses), s);
-        }
-        catch (Exception e)
-        {
-            return HandleError(e);
-        }
-    }
-
-    [HttpPut("success/{idUser:int}/{idInquiry:int}")]
-    [ProducesResponseType(typeof(SuccessDto), 200)]
-    [ProducesResponseType(typeof(string), 400)]
-    [ProducesResponseType(typeof(string), 404)]
-    public IActionResult UpdateSuccess(int idUser, int idInquiry, [FromBody] SuccessDto successDto)
-    {
-        if (idUser < 1 || idInquiry < 1)
-        {
-            _logger.LogError("[ERREUR] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-            return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-        }
-
-        if (idUser != successDto.UserId || idInquiry != successDto.InquiryId)
-        {
-            _logger.LogError(
-                "[ERREUR] Problème ID - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
-                idUser);
-            return BadRequest();
-        }
-
-        if (!ModelState.IsValid)
-        {
-            _logger.LogError(
-                "[ERREUR] Problème controlleur - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
-                idUser);
-            return BadRequest();
-        }
-
-        try
-        {
-            var s = _successDataService.UpdateSuccess(idUser, idInquiry, successDto);
-            _logger.LogInformation(
-                "[INFORMATION] La mise à jour du succès avec l'id de l'utilisateur {id} a été effectuée", idUser);
-            return Ok(s);
-        }
-        catch (Exception e)
-        {
-            return HandleError(e);
-        }
-    }
-
-    private IActionResult HandleError(Exception e)
     {
-        switch (e.Message)
+        private readonly ISuccessService<SuccessDto> _successDataService;
-        {
+
-            case { } msg when msg.Contains("userId"):
+        private readonly ILogger<SuccessesController> _logger;
-                _logger.LogError("[ERREUR] Impossible de trouver l'utilisateur pour la manipulation du succès");
+
-                return NotFound("Impossible de trouver l'utilisateur pour la manipulation du succès");
+        public SuccessesController(ISuccessService<SuccessDto> successDataService, ILogger<SuccessesController> logger)
-            case { } msg when msg.Contains("inquiryId"):
+        {
-                _logger.LogError("[ERREUR] Impossible de trouver l'enquête pour la manipulation du succès");
+            _successDataService = successDataService;
-                return NotFound("Impossible de trouver l'enquête pour la manipulation du succès");
+            _logger = logger;
-            case { } msg when msg.Contains("success"):
+        }
-                _logger.LogError("[ERREUR] Impossible de manipuler le succès car il n'existe pas");
+
-                return Conflict("Impossible de manipuler le succès car il n'existe pas");
+        [HttpGet("successes/{page:int}/{number:int}/{orderCriteria}")]
-            default:
+        [ProducesResponseType(typeof(SuccessDto), 200)]
-                _logger.LogError("[ERREUR] Erreur inattendue, impossible de manipuler le succès");
+        [ProducesResponseType(typeof(string), 204)]
-                return BadRequest("Erreur inattendue, impossible de manipuler le succès");
+        [ProducesResponseType(typeof(string), 400)]
+        public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
+        {
+            if (page < 1 || number < 1)
+            {
+                _logger.LogError("[ERREUR] La page ou le nombre de succès est inférieur à 1.");
+                return BadRequest("La page ou le nombre de succès est inférieur à 1.");
+            }
+
+            var nbUser = _successDataService.GetSuccesses(page, number, orderCriteria).ToList().Count;
+            if (nbUser == 0)
+            {
+                _logger.LogError("[ERREUR] Aucun Succès trouvé.");
+                return StatusCode(204);
+            }
+
+            _logger.LogInformation("[INFORMATION] {nb} Succès(s) trouvé(s)", nbUser);
+            return Ok(_successDataService.GetSuccesses(page, number, orderCriteria));
+        }
+
+        [HttpGet("success/user/{id:int}")]
+        [ProducesResponseType(typeof(SuccessDto), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetSuccessByUserId(int id)
+        {
+            if (id < 1)
+            {
+                _logger.LogError("[ERREUR] L'id de l'utilisateur est inférieur à 1.");
+                return BadRequest("L'id de l'utilisateur est inférieur à 1.");
+            }
+
+            try
+            {
+                _logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", id);
+                return Ok(_successDataService.GetSuccessesByUserId(id));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", id);
+                return NotFound("Aucun utilisateur trouvé avec l'id de l'utilisateur.");
+            }
+        }
+
+        [HttpGet("success/inquiry/{id:int}")]
+        [ProducesResponseType(typeof(SuccessDto), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetSuccessByInquiryId(int id)
+        {
+            if (id < 1)
+            {
+                _logger.LogError("[ERREUR] L'id de l'enquête doit être inférieur à 1.");
+                return BadRequest("L'id de l'enquête doit être inférieur à 1.");
+            }
+
+            try
+            {
+                _logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.",
+                    id);
+                return Ok(_successDataService.GetSuccessesByInquiryId(id));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", id);
+                return NotFound("Aucune enquête trouvée avec l'id de l'enquête.");
+            }
+        }
+
+        [HttpDelete("success/{idUser:int}/{idInquiry:int}")]
+        [ProducesResponseType(typeof(SuccessDto), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult DeleteSuccess(int idUser, int idInquiry)
+        {
+            if (idUser < 1 || idInquiry < 1)
+            {
+                _logger.LogInformation("[INFORMATION] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+                return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+            }
+
+            var success = _successDataService.DeleteSuccess(idUser, idInquiry);
+            if (success)
+            {
+                _logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", idUser);
+                return Ok(success);
+            }
+            else
+            {
+                _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", idUser);
+                return NotFound();
+            }
+        }
+
+        [HttpPost]
+        [ProducesResponseType(typeof(SuccessDto), 201)]
+        [ProducesResponseType(typeof(string), 409)]
+        [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(string), 400)]
+        public IActionResult CreateSuccess([FromBody] SuccessDto dto)
+        {
+            if (dto.UserId < 1 || dto.InquiryId < 1)
+            {
+                _logger.LogError("[ERREUR] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+                return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+            }
+
+            try
+            {
+                var s = _successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished);
+                _logger.LogInformation(
+                    "[INFORMATION] Un succès a été créé : userId - {userId}, inquiryId - {inquiryId}, isFinished - {isFinished}",
+                    dto.UserId, dto.InquiryId, dto.IsFinished);
+                return Created(nameof(GetSuccesses), s);
+            }
+            catch (Exception e)
+            {
+                return HandleError(e);
+            }
+        }
+
+        [HttpPut("success/{idUser:int}/{idInquiry:int}")]
+        [ProducesResponseType(typeof(SuccessDto), 200)]
+        [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult UpdateSuccess(int idUser, int idInquiry, [FromBody] SuccessDto successDto)
+        {
+            if (idUser < 1 || idInquiry < 1)
+            {
+                _logger.LogError("[ERREUR] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+                return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+            }
+
+            if (idUser != successDto.UserId || idInquiry != successDto.InquiryId)
+            {
+                _logger.LogError(
+                    "[ERREUR] Problème ID - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
+                    idUser);
+                return BadRequest();
+            }
+
+            if (!ModelState.IsValid)
+            {
+                _logger.LogError(
+                    "[ERREUR] Problème controlleur - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
+                    idUser);
+                return BadRequest();
+            }
+
+            try
+            {
+                var s = _successDataService.UpdateSuccess(idUser, idInquiry, successDto);
+                _logger.LogInformation(
+                    "[INFORMATION] La mise à jour du succès avec l'id de l'utilisateur {id} a été effectuée", idUser);
+                return Ok(s);
+            }
+            catch (Exception e)
+            {
+                return HandleError(e);
+            }
+        }
+
+        private IActionResult HandleError(Exception e)
+        {
+            switch (e.Message)
+            {
+                case { } msg when msg.Contains("userId"):
+                    _logger.LogError("[ERREUR] Impossible de trouver l'utilisateur pour la manipulation du succès");
+                    return NotFound("Impossible de trouver l'utilisateur pour la manipulation du succès");
+                case { } msg when msg.Contains("inquiryId"):
+                    _logger.LogError("[ERREUR] Impossible de trouver l'enquête pour la manipulation du succès");
+                    return NotFound("Impossible de trouver l'enquête pour la manipulation du succès");
+                case { } msg when msg.Contains("success"):
+                    _logger.LogError("[ERREUR] Impossible de manipuler le succès car il n'existe pas");
+                    return Conflict("Impossible de manipuler le succès car il n'existe pas");
+                default:
+                    _logger.LogError("[ERREUR] Erreur inattendue, impossible de manipuler le succès");
+                    return BadRequest("Erreur inattendue, impossible de manipuler le succès");
+            }
         }
     }
 }

API_SQLuedo/API/Controllers/UserController.cs

@@ -5,231 +5,229 @@ using Microsoft.AspNetCore.Mvc;
 using Shared;
 using Model.OrderCriteria;
 
-namespace API.Controllers;
+namespace API.Controllers
-
-[Route("api/v{version:apiVersion}/[controller]")]
-[Authorize]
-[ApiVersion("1.0")]
-[ApiController]
-public class UsersController(ILogger<UsersController> logger, IUserService<UserDto> userService) : ControllerBase
 {
-    [HttpGet("users/{page:int}/{number:int}")]
+    [Route("api/v{version:apiVersion}/[controller]")]
-    [ProducesResponseType(typeof(UserDto), 200)]
+    [Authorize]
-    [ProducesResponseType(typeof(string), 204)]
+    [ApiVersion("1.0")]
-    public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
+    [ApiController]
+    public class UsersController(ILogger<UsersController> logger, IUserService<UserDto> userService) : ControllerBase
     {
-        var users = userService.GetUsers(page, number, orderCriteria).ToList();
+        [HttpGet("users/{page:int}/{number:int}")]
-        if (users.Count == 0)
+        [ProducesResponseType(typeof(UserDto), 200)]
-        {
+        [ProducesResponseType(typeof(string), 204)]
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+        public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
-            return StatusCode(204);
+        {
-        }
+            var users = userService.GetUsers(page, number, orderCriteria).ToList();
-
+            if (users.Count == 0)
-        logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+            {
-        return Ok(users);
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
-    }
+                return StatusCode(204);
-
+            }
-    [HttpGet("users/not-admin/{page:int}/{number:int}")]
+
-    [ProducesResponseType(typeof(UserDto), 200)]
+            logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
-    [ProducesResponseType(typeof(string), 204)]
+            return Ok(users);
-    public IActionResult GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
+        }
-    {
+        
-        var users = userService.GetNotAdminUsers(page, number, orderCriteria).ToList();
+        [HttpGet("users/not-admin/{page:int}/{number:int}")]
-        if (users.Count == 0)
+        [ProducesResponseType(typeof(UserDto), 200)]
-        {
+        [ProducesResponseType(typeof(string), 204)]
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+        public IActionResult GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
-            return StatusCode(204);
+        {
-        }
+            var users = userService.GetNotAdminUsers(page, number, orderCriteria).ToList();
-
+            if (users.Count == 0)
-        logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+            {
-        return Ok(users);
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
-    }
+                return StatusCode(204);
-
+            }
-    [HttpGet("users/number")]
+
-    [ProducesResponseType(typeof(UserDto), 200)]
+            logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
-    [ProducesResponseType(typeof(string), 204)]
+            return Ok(users);
-    public IActionResult GetNumberOfUsers()
+        }
-    {
+        
-        var users = userService.GetNumberOfUsers();
+        [HttpGet("users/number")]
-        if (users == 0)
+        [ProducesResponseType(typeof(UserDto), 200)]
-        {
+        [ProducesResponseType(typeof(string), 204)]
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+        public IActionResult GetNumberOfUsers()
-            return StatusCode(204);
+        {
-        }
+            var users = userService.GetNumberOfUsers();
-
+            if (users == 0)
-        logger.LogInformation("[INFORMATION] {users} Utilisateur(s) trouvé(s)", users);
+            {
-        return Ok(new KeyValuePair<string, int>("nbUsers", users));
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
-    }
+                return StatusCode(204);
-
+            }
-    [HttpGet("user/{id:int}")]
+
-    [ProducesResponseType(typeof(UserDto), 200)]
+            logger.LogInformation("[INFORMATION] {users} Utilisateur(s) trouvé(s)", users);
-    [ProducesResponseType(typeof(string), 404)]
+            return Ok(new KeyValuePair<string,int>("nbUsers", users));
-    public IActionResult GetUserById(int id)
+        }
-    {
+
-        try
+        [HttpGet("user/{id:int}")]
-        {
+        [ProducesResponseType(typeof(UserDto), 200)]
-            logger.LogInformation("[INFORMATION] Utilisateur avec l'id {id} a été trouvé.", id);
+        [ProducesResponseType(typeof(string), 404)]
-            return Ok(userService.GetUserById(id));
+        public IActionResult GetUserById(int id)
-        }
+        {
-        catch (ArgumentException)
+            try
-        {
+            {
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
+                logger.LogInformation("[INFORMATION] Utilisateur avec l'id {id} a été trouvé.", id);
-            return NotFound();
+                return Ok(userService.GetUserById(id));
-        }
+            }
-    }
+            catch (ArgumentException)
-
+            {
-    [HttpGet("user/{username:alpha}")]
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
-    [ProducesResponseType(typeof(UserDto), 200)]
+                return NotFound();
-    [ProducesResponseType(typeof(string), 404)]
+            }
-    public IActionResult GetUserByUsername(string username)
+        }
-    {
+
-        try
+        [HttpGet("user/{username:alpha}")]
-        {
+        [ProducesResponseType(typeof(UserDto), 200)]
-            logger.LogInformation("[INFORMATION] Utilisateur avec l'username {username} a été trouvé.", username);
+        [ProducesResponseType(typeof(string), 404)]
-            return Ok(userService.GetUserByUsername(username));
+        public IActionResult GetUserByUsername(string username)
-        }
+        {
-        catch (ArgumentException)
+            try
-        {
+            {
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {username}.", username);
+                logger.LogInformation("[INFORMATION] Utilisateur avec l'username {username} a été trouvé.", username);
-            return NotFound("Utilisateur non trouvé !");
+                return Ok(userService.GetUserByUsername(username));
-        }
+            }
-    }
+            catch (ArgumentException)
-
+            {
-    [HttpGet("user/email/{email}")]
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {username}.", username);
-    [ProducesResponseType(typeof(UserDto), 200)]
+                return NotFound("Utilisateur non trouvé !");
-    [ProducesResponseType(typeof(string), 404)]
+            }
-    public IActionResult GetByEmail(string email)
+        }
-    {
+        [HttpGet("user/email/{email}")]
-        try
+        [ProducesResponseType(typeof(UserDto), 200)]
-        {
+        [ProducesResponseType(typeof(string), 404)]
-            logger.LogInformation("[INFORMATION] Utilisateur avec l'username {email} a été trouvé.", email);
+        public IActionResult GetByEmail(string email)
-            return Ok(userService.GetUserByEmail(email));
+        {
-        }
+            try
-        catch (ArgumentException)
+            {
-        {
+                logger.LogInformation("[INFORMATION] Utilisateur avec l'username {email} a été trouvé.", email);
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {email}.", email);
+                return Ok(userService.GetUserByEmail(email));
-            return NotFound();
+            }
-        }
+            catch (ArgumentException)
-    }
+            {
-
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {email}.", email);
-    [HttpDelete("user/{id:int}")]
+                return NotFound();
-    [ProducesResponseType(typeof(UserDto), 200)]
+            }
-    [ProducesResponseType(typeof(string), 404)]
+        }
-    public IActionResult DeleteUser(int id)
+
-    {
+        [HttpDelete("user/{id:int}")]
-        var success = userService.DeleteUser(id);
+        [ProducesResponseType(typeof(UserDto), 200)]
-        if (success)
+        [ProducesResponseType(typeof(string), 404)]
-        {
+        public IActionResult DeleteUser(int id)
-            logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id);
+        {
-            return Ok();
+            var success = userService.DeleteUser(id);
-        }
+            if (success)
-        else
+            {
-        {
+                logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id);
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
+                return Ok();
-            return NotFound();
+            }
-        }
+            else
-    }
+            {
-
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
-    [HttpDelete("user/username/{username:alpha}")]
+                return NotFound();
-    [ProducesResponseType(typeof(UserDto), 200)]
+            }
-    [ProducesResponseType(typeof(string), 404)]
+        }
-    public IActionResult DeleteUserByUsername(string username)
+        
-    {
+        [HttpDelete("user/username/{username:alpha}")]
-        var success = userService.DeleteUserByUsername(username);
+        [ProducesResponseType(typeof(UserDto), 200)]
-        if (success)
+        [ProducesResponseType(typeof(string), 404)]
-        {
+        public IActionResult DeleteUserByUsername(string username)
-            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.",
+        {
-                username);
+            var success = userService.DeleteUserByUsername(username);
-            return Ok();
+            if (success)
-        }
+            {
-        else
+                logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.", username);
-        {
+                return Ok();
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec le pseudo {username}.", username);
+            }
-            return NotFound();
+            else
-        }
+            {
-    }
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec le pseudo {username}.", username);
-
+                return NotFound();
-    [HttpPost]
+            }
-    [ProducesResponseType(typeof(UserDto), 201)]
+        }
-    [ProducesResponseType(typeof(string), 400)]
+
-    [ProducesResponseType(typeof(string), 409)]
+        [HttpPost]
-    [ProducesResponseType(typeof(string), 410)]
+        [ProducesResponseType(typeof(UserDto), 201)]
-    public IActionResult CreateUser([FromBody] UserDto dto)
+        [ProducesResponseType(typeof(string), 400)]
-    {
+        [ProducesResponseType(typeof(string), 409)]
-        if (dto.Username == null || dto.Password == null || dto.Email == null)
+        [ProducesResponseType(typeof(string), 410)]
-        {
+        public IActionResult CreateUser([FromBody] UserDto dto)
-            return BadRequest();
+        {
-        }
+            if (dto.Username == null || dto.Password == null || dto.Email == null)
-
+            {
-        if (userService.IsEmailTaken(dto.Email))
+                return BadRequest();
-        {
+            }
-            return StatusCode(409, "Email déjà utilisé");
+
-        }
+            if (userService.IsEmailTaken(dto.Email))
-
+            {
-        if (userService.IsUsernameTaken(dto.Username))
+                return StatusCode(409, "Email déjà utilisé");
-        {
+            }
-            return StatusCode(410, "Username déjà utilisé");
+
-        }
+            if (userService.IsUsernameTaken(dto.Username))
-
+            {
-        // return Ok(userService.CreateUser(username, password, email, isAdmin));
+                return StatusCode(410, "Username déjà utilisé");
-        logger.LogInformation(
+            }
-            "[INFORMATION] Un utilisateur a été créé : username - {username}, password - {password}, email - {email}, isAdmin - {isAdmin}",
+
-            dto.Username, dto.Password, dto.Email, dto.IsAdmin);
+            // return Ok(userService.CreateUser(username, password, email, isAdmin));
-        return Created(nameof(GetUsers),
+            logger.LogInformation(
-            userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin));
+                "[INFORMATION] Un utilisateur a été créé : username - {username}, password - {password}, email - {email}, isAdmin - {isAdmin}",
-    }
+                dto.Username, dto.Password, dto.Email, dto.IsAdmin);
-
+            return Created(nameof(GetUsers),
-    [HttpPut("user/{id:int}")]
+                userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin));
-    [ProducesResponseType(typeof(UserDto), 200)]
+        }
-    [ProducesResponseType(typeof(string), 400)]
+
-    [ProducesResponseType(typeof(string), 404)]
+        [HttpPut("user/{id:int}")]
-    [ProducesResponseType(typeof(string), 409)]
+        [ProducesResponseType(typeof(UserDto), 200)]
-    public IActionResult UpdateUser(int id, [FromBody] UserDto userDto)
+        [ProducesResponseType(typeof(string), 400)]
-    {
+        [ProducesResponseType(typeof(string), 404)]
-        if (id != userDto.Id)
+        [ProducesResponseType(typeof(string), 409)]
-        {
+        public IActionResult UpdateUser(int id, [FromBody] UserDto userDto)
-            logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
+        {
-            return BadRequest();
+            if (id != userDto.Id)
-        }
+            {
-
+                logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
-        if (!ModelState.IsValid)
+                return BadRequest();
-        {
+            }
-            logger.LogError(
+
-                "[ERREUR] Problème controller - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
+            if (!ModelState.IsValid)
-            return BadRequest();
+            {
-        }
+                logger.LogError(
-
+                    "[ERREUR] Problème controller - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
-        if (userDto.Username == userService.GetUserById(id).Username && !userService.IsEmailTaken(userDto.Email)
+                return BadRequest();
-            || (userDto.Email == userService.GetUserById(id).Email &&
+            }
-                !userService.IsUsernameTaken(userDto.Username))
+
-            || (!userService.IsEmailTaken(userDto.Email) && !userService.IsUsernameTaken(userDto.Username)))
+            if (userDto.Username == userService.GetUserById(id).Username && !userService.IsEmailTaken(userDto.Email)
-        {
+                || (userDto.Email == userService.GetUserById(id).Email &&
-            logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
+                    !userService.IsUsernameTaken(userDto.Username))
-                id);
+                || (!userService.IsEmailTaken(userDto.Email) && !userService.IsUsernameTaken(userDto.Username)))
-            return Ok(userService.UpdateUser(id, userDto));
+            {
-        }
+                logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
-
+                    id);
-        logger.LogError("[ERREUR] Email ou nom d'utilisateur déjà utilisé");
+                return Ok(userService.UpdateUser(id, userDto));
-        return StatusCode(409, "Email ou nom d'utilisateur déjà utilisé");
+            }
-    }
+            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)]
+        [HttpPut("user/promote/{id:int}")]
-    public IActionResult PromoteUser(int id)
+        [ProducesResponseType(typeof(UserDto), 200)]
-    {
+        [ProducesResponseType(typeof(string), 404)]
-        var userPromoted = userService.GetUserById(id);
+        public IActionResult PromoteUser(int id)
-        if (userPromoted != null)
+        {
-        {
+            var userPromoted = userService.GetUserById(id);
-            userPromoted = userService.PromoteUser(id);
+            if (userPromoted != null)
-            logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} a été effectuée");
+            {
-            return Ok(userPromoted);
+                userPromoted = userService.PromoteUser(id);
-        }
+                logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} a été effectuée");
-        else
+                return Ok(userPromoted);
-        {
+            }
-            logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} à échouée",
+            else
-                id);
+            {
-            return NotFound();
+                logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} à échouée",
+                    id);
+                return NotFound();
+            }
         }
     }
 }

API_SQLuedo/API/Dockerfile

@@ -1,7 +1,10 @@
+#See https://aka.ms/customizecontainer to learn how to customize your debug container and how Visual Studio uses this Dockerfile to build your images for faster debugging.
+
 FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
 USER app
 WORKDIR /app
-EXPOSE 80
+EXPOSE 8080
+EXPOSE 8081
 
 FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
 ARG BUILD_CONFIGURATION=Release
@@ -26,6 +29,4 @@ RUN dotnet publish "./API.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:Use
 FROM base AS final
 WORKDIR /app
 COPY --from=publish /app/publish .
-ENV ASPNETCORE_HTTP_PORTS=80
-ENV DOTNET_HOSTBUILDER__RELOADCONFIGONCHANGE=false
 ENTRYPOINT ["dotnet", "API.dll"]

API_SQLuedo/API/Program.cs

@@ -8,21 +8,17 @@ using Entities;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.OpenApi.Models;
-using Model;
 using Shared;
-using StubbedContextLib;
 
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services to the container.
-builder.Services.AddControllers();
 
+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>();
 
@@ -32,12 +28,6 @@ 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>();
 
@@ -47,34 +37,12 @@ builder.Services.AddScoped<ISuccessService<SuccessDto>, SuccessDataServiceApi>()
 builder.Services.AddScoped<ILessonService<LessonEntity>, LessonDataService>();
 builder.Services.AddScoped<ILessonService<LessonDto>, LessonDataServiceApi>();
 
-builder.Services.AddScoped<INotepadService<NotepadEntity>, NotepadDataService>();
+builder.Services.AddScoped<INotePadService<NotepadEntity>, NotePadDataService>();
-builder.Services.AddScoped<INotepadService<NotepadDto>, NotepadDataServiceAPI>();
+builder.Services.AddScoped<INotePadService<NotepadDto>, NotePadDataServiceApi>();
 
-
+builder.Services.AddDbContext<DbContext, UserDbContext>();
-builder.Services.AddDbContext<DbContext,UserDbContext>((serviceProvider, options) =>
+builder.Services.AddDbContext<WebAPIDbContext>(options => options.UseInMemoryDatabase("appDb"));
-{
+builder.Services.AddIdentityApiEndpoints<IdentityUser>().AddEntityFrameworkStores<WebAPIDbContext>();
-    if (builder.Environment.IsProduction())
-    {
-        Console.WriteLine("I am in production mode");
-        var address = Environment.GetEnvironmentVariable("DB_HOST", EnvironmentVariableTarget.Process)
-                      ?? throw new ArgumentException("Missing DB_HOST environment variable");
-        var database = Environment.GetEnvironmentVariable("DB_DATABASE", EnvironmentVariableTarget.Process)
-                       ?? throw new ArgumentException("Missing DB_DATABASE environment variable");
-        var user = Environment.GetEnvironmentVariable("DB_USER", EnvironmentVariableTarget.Process)
-                   ?? throw new ArgumentException("Missing DB_USER environment variable");
-        var password = Environment.GetEnvironmentVariable("DB_PASSWORD", EnvironmentVariableTarget.Process)
-                       ?? throw new ArgumentException("Missing DB_PASSWORD environment variable");
-
-        var coString = $"Host={address};Database={database};Username={user};Password={password}";
-        options.UseNpgsql(coString);
-    }
-    else
-    {
-        Console.WriteLine("I am in development mode");
-        options.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse");
-    }
-});
-builder.Services.AddIdentityApiEndpoints<IdentityUser>().AddEntityFrameworkStores<UserDbContext>();
 
 builder.Services.AddAuthorization();
 builder.Services.AddApiVersioning(o =>
@@ -124,17 +92,10 @@ builder.Services.AddCors(options =>
         {
             builder.WithOrigins("https://localhost:7171")
                 .AllowAnyMethod()
-                .AllowAnyHeader();
+                .AllowAnyHeader(); 
         });
 });
 
-var configuration = new ConfigurationBuilder()
-    .SetBasePath(Directory.GetCurrentDirectory())
-    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
-    .Build();
-
-builder.Services.AddSingleton(configuration);
-
 
 var app = builder.Build();
 
@@ -145,10 +106,6 @@ app.UseCors("AllowSpecificOrigin");
 using (var scope = app.Services.CreateScope())
 {
     var services = scope.ServiceProvider;
-    // Création base de données via les migrations
-    await using var dbContext = services.GetRequiredService<UserDbContext>();
-    //await dbContext.Database.MigrateAsync();
-
     var userManager = services.GetRequiredService<UserManager<IdentityUser>>();
 
     try
@@ -174,9 +131,12 @@ using (var scope = app.Services.CreateScope())
     }
 }
 
-
+// Configure the HTTP request pipeline.
-app.UseSwagger();
+if (app.Environment.IsDevelopment())
-app.UseSwaggerUI();
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
 
 app.UseHttpsRedirection();
 

API_SQLuedo/API/Properties/launchSettings.json

@@ -16,10 +16,7 @@
       "launchUrl": "swagger",
       "applicationUrl": "http://localhost:5015",
       "environmentVariables": {
-        "DB_HOST": "localhost",
+        "ASPNETCORE_ENVIRONMENT": "Development"
-        "DB_DATABASE": "SQLuedo",
-        "DB_USER": "admin",
-        "DB_PASSWORD" : "motdepasse"
       }
     },
     "https": {
@@ -27,23 +24,17 @@
       "dotnetRunMessages": true,
       "launchBrowser": true,
       "launchUrl": "swagger",
-      "applicationUrl": "https://localhost:8081;http://localhost:5015",
+      "applicationUrl": "https://localhost:7259;http://localhost:5015",
       "environmentVariables": {
-        "DB_HOST": "localhost",
+        "ASPNETCORE_ENVIRONMENT": "Development"
-        "DB_DATABASE": "SQLuedo",
-        "DB_USER": "admin",
-        "DB_PASSWORD" : "motdepasse"
       }
     },
     "IIS Express": {
       "commandName": "IISExpress",
       "launchBrowser": true,
-      "launchUrl": "containers/johnnyratton-sqluedo-api",
+      "launchUrl": "swagger",
       "environmentVariables": {
-        "DB_HOST": "localhost",
+        "ASPNETCORE_ENVIRONMENT": "Development"
-        "DB_DATABASE": "SQLuedo",
-        "DB_USER": "admin",
-        "DB_PASSWORD" : "motdepasse"
       }
     }
   }

API_SQLuedo/API/Service/InquiryTableDataServiceAPI.cs

@@ -1,13 +0,0 @@
-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,11 +14,6 @@ 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,19 @@
+using Dto;
+using Entities;
+using Shared;
+using Shared.Mapper;
+
+namespace API.Service;
+
+public class NotePadDataServiceApi(INotePadService<NotepadEntity> notePadService) : INotePadService<NotepadDto>
+{
+    public NotepadDto GetNotePadById(int id) => notePadService.GetNotePadById(id).FromEntityToDto();
+
+    public NotepadDto GetNotePadByIdUserAndIdInquiry(int idUser, int idInquiry) =>
+        notePadService.GetNotePadByIdUserAndIdInquiry(idUser, idInquiry).FromEntityToDto();
+
+    public NotepadDto CreateNotePad(int id, int idUser, int idInquiry, string note) =>
+        notePadService.CreateNotePad(id, idUser, idInquiry, note).FromEntityToDto();
+
+    public bool DeleteNotePad(int id) => notePadService.DeleteNotePad(id);
+}

API_SQLuedo/API/Service/NotepadDataServiceAPI.cs

@@ -1,24 +0,0 @@
-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,11 +15,6 @@ 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

@@ -1,176 +0,0 @@
-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());
-                        }
-
-                        List<object> tablesDict = new List<object>();
-                        foreach (string tableName in tableNames)
-                        {
-                            tablesDict.Add(new { 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());
-                        }
-
-                       /*List<object> columnsDict = new List<object>();
-                        foreach (string colName in columnsNames)
-                        {
-                            columnsDict.Add(new { ColumnName = colName});
-                        }*/
-
-                        string tablesJson = JsonConvert.SerializeObject(columnsNames);
-
-                        Console.WriteLine(tablesJson);
-
-                        QueryDto queryDto = new QueryDto { Result = tablesJson };
-                        return queryDto;
-                    }
-                }
-            }
-        
-    }
-}

API_SQLuedo/API/Service/SolutionDataServiceAPI.cs

@@ -1,14 +0,0 @@
-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/appsettings.json

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

API_SQLuedo/DbContextLib/Migrations/20240403065352_v1.Designer.cs

@@ -1,595 +0,0 @@
-// <auto-generated />
-using System;
-using DbContextLib;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace DbContextLib.Migrations
-{
-    [DbContext(typeof(UserDbContext))]
-    [Migration("20240403065352_v1")]
-    partial class v1
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("ProductVersion", "8.0.2")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.HasSequence("ContentLessonEntitySequence");
-
-            modelBuilder.Entity("Entities.BlackListEntity", b =>
-                {
-                    b.Property<string>("Email")
-                        .HasColumnType("text");
-
-                    b.Property<DateOnly>("ExpirationDate")
-                        .HasColumnType("date");
-
-                    b.HasKey("Email");
-
-                    b.ToTable("BlackList");
-                });
-
-            modelBuilder.Entity("Entities.ContentLessonEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer")
-                        .HasDefaultValueSql("nextval('\"ContentLessonEntitySequence\"')");
-
-                    NpgsqlPropertyBuilderExtensions.UseSequence(b.Property<int>("Id"));
-
-                    b.Property<string>("ContentContent")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContentTitle")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("LessonId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("LessonId");
-
-                    b.ToTable((string)null);
-
-                    b.UseTpcMappingStrategy();
-                });
-
-            modelBuilder.Entity("Entities.InquiryEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsUser")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Inquiries");
-                });
-
-            modelBuilder.Entity("Entities.InquiryTableEntity", b =>
-                {
-                    b.Property<int>("OwnerId")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConnectionInfo")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("DatabaseName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("OwnerId");
-
-                    b.ToTable("InquiryTable");
-                });
-
-            modelBuilder.Entity("Entities.LessonEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<DateOnly>("LastEdit")
-                        .HasColumnType("date");
-
-                    b.Property<string>("LastPublisher")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Lesson");
-                });
-
-            modelBuilder.Entity("Entities.NotepadEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<int>("InquiryId")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Notes")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("UserId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("InquiryId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("Notepad");
-                });
-
-            modelBuilder.Entity("Entities.SolutionEntity", b =>
-                {
-                    b.Property<int>("OwnerId")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Explaination")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurderPlace")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurderWeapon")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurdererFirstName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurdererLastName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("OwnerId");
-
-                    b.ToTable("Solution");
-                });
-
-            modelBuilder.Entity("Entities.SuccessEntity", b =>
-                {
-                    b.Property<int>("InquiryId")
-                        .HasColumnType("integer");
-
-                    b.Property<bool>("IsFinished")
-                        .HasColumnType("boolean");
-
-                    b.Property<int>("UserId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("InquiryId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("Success");
-                });
-
-            modelBuilder.Entity("Entities.UserEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("Email")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsAdmin")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Password")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Username")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("User");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique()
-                        .HasDatabaseName("RoleNameIndex");
-
-                    b.ToTable("AspNetRoles", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetRoleClaims", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex");
-
-                    b.ToTable("AspNetUsers", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<string>("UserId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserClaims", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
-                {
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderKey")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderDisplayName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("UserId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("LoginProvider", "ProviderKey");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserLogins", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
-                {
-                    b.Property<string>("UserId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleId")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "RoleId");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetUserRoles", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
-                {
-                    b.Property<string>("UserId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "LoginProvider", "Name");
-
-                    b.ToTable("AspNetUserTokens", (string)null);
-                });
-
-            modelBuilder.Entity("Entities.ParagraphEntity", b =>
-                {
-                    b.HasBaseType("Entities.ContentLessonEntity");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Content")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Info")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Query")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.ToTable("Paragraph");
-                });
-
-            modelBuilder.Entity("Entities.ContentLessonEntity", b =>
-                {
-                    b.HasOne("Entities.LessonEntity", "Lesson")
-                        .WithMany("Content")
-                        .HasForeignKey("LessonId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Lesson");
-                });
-
-            modelBuilder.Entity("Entities.InquiryTableEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Entities.NotepadEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Inquiry")
-                        .WithMany()
-                        .HasForeignKey("InquiryId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Entities.UserEntity", "User")
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Inquiry");
-
-                    b.Navigation("User");
-                });
-
-            modelBuilder.Entity("Entities.SolutionEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Entities.SuccessEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Inquiry")
-                        .WithMany()
-                        .HasForeignKey("InquiryId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Entities.UserEntity", "User")
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Inquiry");
-
-                    b.Navigation("User");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Entities.LessonEntity", b =>
-                {
-                    b.Navigation("Content");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

API_SQLuedo/DbContextLib/Migrations/20240403065352_v1.cs

@@ -1,452 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace DbContextLib.Migrations
-{
-    /// <inheritdoc />
-    public partial class v1 : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.CreateSequence(
-                name: "ContentLessonEntitySequence");
-
-            migrationBuilder.CreateTable(
-                name: "AspNetRoles",
-                columns: table => new
-                {
-                    Id = table.Column<string>(type: "text", nullable: false),
-                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    ConcurrencyStamp = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetRoles", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUsers",
-                columns: table => new
-                {
-                    Id = table.Column<string>(type: "text", nullable: false),
-                    UserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedUserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    Email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedEmail = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    EmailConfirmed = table.Column<bool>(type: "boolean", nullable: false),
-                    PasswordHash = table.Column<string>(type: "text", nullable: true),
-                    SecurityStamp = table.Column<string>(type: "text", nullable: true),
-                    ConcurrencyStamp = table.Column<string>(type: "text", nullable: true),
-                    PhoneNumber = table.Column<string>(type: "text", nullable: true),
-                    PhoneNumberConfirmed = table.Column<bool>(type: "boolean", nullable: false),
-                    TwoFactorEnabled = table.Column<bool>(type: "boolean", nullable: false),
-                    LockoutEnd = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
-                    LockoutEnabled = table.Column<bool>(type: "boolean", nullable: false),
-                    AccessFailedCount = table.Column<int>(type: "integer", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUsers", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "BlackList",
-                columns: table => new
-                {
-                    Email = table.Column<string>(type: "text", nullable: false),
-                    ExpirationDate = table.Column<DateOnly>(type: "date", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_BlackList", x => x.Email);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Inquiries",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Title = table.Column<string>(type: "text", nullable: false),
-                    Description = table.Column<string>(type: "text", nullable: false),
-                    IsUser = table.Column<bool>(type: "boolean", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Inquiries", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Lesson",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Title = table.Column<string>(type: "text", nullable: false),
-                    LastPublisher = table.Column<string>(type: "text", nullable: false),
-                    LastEdit = table.Column<DateOnly>(type: "date", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Lesson", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "User",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Username = table.Column<string>(type: "text", nullable: false),
-                    Password = table.Column<string>(type: "text", nullable: false),
-                    Email = table.Column<string>(type: "text", nullable: false),
-                    IsAdmin = table.Column<bool>(type: "boolean", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_User", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetRoleClaims",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    RoleId = table.Column<string>(type: "text", nullable: false),
-                    ClaimType = table.Column<string>(type: "text", nullable: true),
-                    ClaimValue = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
-                        column: x => x.RoleId,
-                        principalTable: "AspNetRoles",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserClaims",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    UserId = table.Column<string>(type: "text", nullable: false),
-                    ClaimType = table.Column<string>(type: "text", nullable: true),
-                    ClaimValue = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_AspNetUserClaims_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserLogins",
-                columns: table => new
-                {
-                    LoginProvider = table.Column<string>(type: "text", nullable: false),
-                    ProviderKey = table.Column<string>(type: "text", nullable: false),
-                    ProviderDisplayName = table.Column<string>(type: "text", nullable: true),
-                    UserId = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserLogins_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserRoles",
-                columns: table => new
-                {
-                    UserId = table.Column<string>(type: "text", nullable: false),
-                    RoleId = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
-                        column: x => x.RoleId,
-                        principalTable: "AspNetRoles",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_AspNetUserRoles_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserTokens",
-                columns: table => new
-                {
-                    UserId = table.Column<string>(type: "text", nullable: false),
-                    LoginProvider = table.Column<string>(type: "text", nullable: false),
-                    Name = table.Column<string>(type: "text", nullable: false),
-                    Value = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserTokens_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "InquiryTable",
-                columns: table => new
-                {
-                    OwnerId = table.Column<int>(type: "integer", nullable: false),
-                    DatabaseName = table.Column<string>(type: "text", nullable: false),
-                    ConnectionInfo = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_InquiryTable", x => x.OwnerId);
-                    table.ForeignKey(
-                        name: "FK_InquiryTable_Inquiries_OwnerId",
-                        column: x => x.OwnerId,
-                        principalTable: "Inquiries",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Solution",
-                columns: table => new
-                {
-                    OwnerId = table.Column<int>(type: "integer", nullable: false),
-                    MurdererFirstName = table.Column<string>(type: "text", nullable: false),
-                    MurdererLastName = table.Column<string>(type: "text", nullable: false),
-                    MurderPlace = table.Column<string>(type: "text", nullable: false),
-                    MurderWeapon = table.Column<string>(type: "text", nullable: false),
-                    Explaination = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Solution", x => x.OwnerId);
-                    table.ForeignKey(
-                        name: "FK_Solution_Inquiries_OwnerId",
-                        column: x => x.OwnerId,
-                        principalTable: "Inquiries",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Paragraph",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false, defaultValueSql: "nextval('\"ContentLessonEntitySequence\"')"),
-                    ContentContent = table.Column<string>(type: "text", nullable: false),
-                    ContentTitle = table.Column<string>(type: "text", nullable: false),
-                    LessonId = table.Column<int>(type: "integer", nullable: false),
-                    Title = table.Column<string>(type: "text", nullable: false),
-                    Content = table.Column<string>(type: "text", nullable: false),
-                    Info = table.Column<string>(type: "text", nullable: false),
-                    Query = table.Column<string>(type: "text", nullable: false),
-                    Comment = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Paragraph", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_Paragraph_Lesson_LessonId",
-                        column: x => x.LessonId,
-                        principalTable: "Lesson",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Notepad",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    UserId = table.Column<int>(type: "integer", nullable: false),
-                    InquiryId = table.Column<int>(type: "integer", nullable: false),
-                    Notes = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Notepad", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_Notepad_Inquiries_InquiryId",
-                        column: x => x.InquiryId,
-                        principalTable: "Inquiries",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_Notepad_User_UserId",
-                        column: x => x.UserId,
-                        principalTable: "User",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Success",
-                columns: table => new
-                {
-                    InquiryId = table.Column<int>(type: "integer", nullable: false),
-                    UserId = table.Column<int>(type: "integer", nullable: false),
-                    IsFinished = table.Column<bool>(type: "boolean", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Success", x => x.InquiryId);
-                    table.ForeignKey(
-                        name: "FK_Success_Inquiries_InquiryId",
-                        column: x => x.InquiryId,
-                        principalTable: "Inquiries",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_Success_User_UserId",
-                        column: x => x.UserId,
-                        principalTable: "User",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetRoleClaims_RoleId",
-                table: "AspNetRoleClaims",
-                column: "RoleId");
-
-            migrationBuilder.CreateIndex(
-                name: "RoleNameIndex",
-                table: "AspNetRoles",
-                column: "NormalizedName",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserClaims_UserId",
-                table: "AspNetUserClaims",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserLogins_UserId",
-                table: "AspNetUserLogins",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserRoles_RoleId",
-                table: "AspNetUserRoles",
-                column: "RoleId");
-
-            migrationBuilder.CreateIndex(
-                name: "EmailIndex",
-                table: "AspNetUsers",
-                column: "NormalizedEmail");
-
-            migrationBuilder.CreateIndex(
-                name: "UserNameIndex",
-                table: "AspNetUsers",
-                column: "NormalizedUserName",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Notepad_InquiryId",
-                table: "Notepad",
-                column: "InquiryId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Notepad_UserId",
-                table: "Notepad",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Paragraph_LessonId",
-                table: "Paragraph",
-                column: "LessonId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Success_UserId",
-                table: "Success",
-                column: "UserId");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "AspNetRoleClaims");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserClaims");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserLogins");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserRoles");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserTokens");
-
-            migrationBuilder.DropTable(
-                name: "BlackList");
-
-            migrationBuilder.DropTable(
-                name: "InquiryTable");
-
-            migrationBuilder.DropTable(
-                name: "Notepad");
-
-            migrationBuilder.DropTable(
-                name: "Paragraph");
-
-            migrationBuilder.DropTable(
-                name: "Solution");
-
-            migrationBuilder.DropTable(
-                name: "Success");
-
-            migrationBuilder.DropTable(
-                name: "AspNetRoles");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUsers");
-
-            migrationBuilder.DropTable(
-                name: "Lesson");
-
-            migrationBuilder.DropTable(
-                name: "Inquiries");
-
-            migrationBuilder.DropTable(
-                name: "User");
-
-            migrationBuilder.DropSequence(
-                name: "ContentLessonEntitySequence");
-        }
-    }
-}

API_SQLuedo/DbContextLib/Migrations/UserDbContextModelSnapshot.cs

@@ -1,592 +0,0 @@
-// <auto-generated />
-using System;
-using DbContextLib;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace DbContextLib.Migrations
-{
-    [DbContext(typeof(UserDbContext))]
-    partial class UserDbContextModelSnapshot : ModelSnapshot
-    {
-        protected override void BuildModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("ProductVersion", "8.0.2")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.HasSequence("ContentLessonEntitySequence");
-
-            modelBuilder.Entity("Entities.BlackListEntity", b =>
-                {
-                    b.Property<string>("Email")
-                        .HasColumnType("text");
-
-                    b.Property<DateOnly>("ExpirationDate")
-                        .HasColumnType("date");
-
-                    b.HasKey("Email");
-
-                    b.ToTable("BlackList");
-                });
-
-            modelBuilder.Entity("Entities.ContentLessonEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer")
-                        .HasDefaultValueSql("nextval('\"ContentLessonEntitySequence\"')");
-
-                    NpgsqlPropertyBuilderExtensions.UseSequence(b.Property<int>("Id"));
-
-                    b.Property<string>("ContentContent")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContentTitle")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("LessonId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("LessonId");
-
-                    b.ToTable((string)null);
-
-                    b.UseTpcMappingStrategy();
-                });
-
-            modelBuilder.Entity("Entities.InquiryEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsUser")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Inquiries");
-                });
-
-            modelBuilder.Entity("Entities.InquiryTableEntity", b =>
-                {
-                    b.Property<int>("OwnerId")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConnectionInfo")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("DatabaseName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("OwnerId");
-
-                    b.ToTable("InquiryTable");
-                });
-
-            modelBuilder.Entity("Entities.LessonEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<DateOnly>("LastEdit")
-                        .HasColumnType("date");
-
-                    b.Property<string>("LastPublisher")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Lesson");
-                });
-
-            modelBuilder.Entity("Entities.NotepadEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<int>("InquiryId")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Notes")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("UserId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("InquiryId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("Notepad");
-                });
-
-            modelBuilder.Entity("Entities.SolutionEntity", b =>
-                {
-                    b.Property<int>("OwnerId")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Explaination")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurderPlace")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurderWeapon")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurdererFirstName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurdererLastName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("OwnerId");
-
-                    b.ToTable("Solution");
-                });
-
-            modelBuilder.Entity("Entities.SuccessEntity", b =>
-                {
-                    b.Property<int>("InquiryId")
-                        .HasColumnType("integer");
-
-                    b.Property<bool>("IsFinished")
-                        .HasColumnType("boolean");
-
-                    b.Property<int>("UserId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("InquiryId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("Success");
-                });
-
-            modelBuilder.Entity("Entities.UserEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("Email")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsAdmin")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Password")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Username")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("User");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique()
-                        .HasDatabaseName("RoleNameIndex");
-
-                    b.ToTable("AspNetRoles", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetRoleClaims", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex");
-
-                    b.ToTable("AspNetUsers", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<string>("UserId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserClaims", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
-                {
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderKey")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderDisplayName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("UserId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("LoginProvider", "ProviderKey");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserLogins", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
-                {
-                    b.Property<string>("UserId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleId")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "RoleId");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetUserRoles", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
-                {
-                    b.Property<string>("UserId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "LoginProvider", "Name");
-
-                    b.ToTable("AspNetUserTokens", (string)null);
-                });
-
-            modelBuilder.Entity("Entities.ParagraphEntity", b =>
-                {
-                    b.HasBaseType("Entities.ContentLessonEntity");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Content")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Info")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Query")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.ToTable("Paragraph");
-                });
-
-            modelBuilder.Entity("Entities.ContentLessonEntity", b =>
-                {
-                    b.HasOne("Entities.LessonEntity", "Lesson")
-                        .WithMany("Content")
-                        .HasForeignKey("LessonId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Lesson");
-                });
-
-            modelBuilder.Entity("Entities.InquiryTableEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Entities.NotepadEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Inquiry")
-                        .WithMany()
-                        .HasForeignKey("InquiryId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Entities.UserEntity", "User")
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Inquiry");
-
-                    b.Navigation("User");
-                });
-
-            modelBuilder.Entity("Entities.SolutionEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Entities.SuccessEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Inquiry")
-                        .WithMany()
-                        .HasForeignKey("InquiryId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Entities.UserEntity", "User")
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Inquiry");
-
-                    b.Navigation("User");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Entities.LessonEntity", b =>
-                {
-                    b.Navigation("Content");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

API_SQLuedo/DbContextLib/UserDbContext.cs

@@ -26,8 +26,8 @@ namespace DbContextLib
             base.OnConfiguring(optionsBuilder);
             if (!optionsBuilder.IsConfigured)
             {
-                optionsBuilder.UseNpgsql(Environment.GetEnvironmentVariable("CO_STRING", EnvironmentVariableTarget.Process));
+                //optionsBuilder.UseNpgsql(Environment.GetEnvironmentVariable("CONNECTION_STRING", EnvironmentVariableTarget.Process));
-                //optionsBuilder.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse");
+                optionsBuilder.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse");
             }
         }
 

API_SQLuedo/DbDataManager/Service/InquiryTableDataService.cs

@@ -1,27 +0,0 @@
-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

@@ -57,11 +57,6 @@ public class LessonDataService : ILessonService<LessonEntity>
         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,64 @@
+using DbContextLib;
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class NotePadDataService : INotePadService<NotepadEntity>
+{
+    private UserDbContext DbContext { get; }
+    public NotePadDataService(UserDbContext context)
+    {
+        DbContext = context;
+        context.Database.EnsureCreated();
+
+    }
+    public NotepadEntity GetNotePadById(int id)
+    {
+        var notePadEntity = DbContext.Notepads.FirstOrDefault(n => n.Id == id);
+        if (notePadEntity == null)
+        {
+            throw new ArgumentException("impossible de trouver le bloc note", nameof(id));
+        }
+        return notePadEntity;
+    }
+
+    public NotepadEntity GetNotePadByIdUserAndIdInquiry(int idUser, int idInquiry)
+    {
+        var notPadEntity = DbContext.Notepads.FirstOrDefault(n => n.InquiryId == idInquiry && n.UserId == idUser);
+        if (notPadEntity == null)
+        {
+            throw new ArgumentException("impossible de trouver le bloc note", nameof(idInquiry));
+        }
+
+        return notPadEntity;
+    }
+
+    public NotepadEntity CreateNotePad(int id, int idUser, int idInquiry, string note)
+    {
+        var notePadEntity = new NotepadEntity
+        {
+            Id = id,
+            UserId = idUser,
+            InquiryId = idInquiry,
+            Notes = note
+        };
+        DbContext.Notepads.Add(notePadEntity);
+        DbContext.SaveChangesAsync();
+        return notePadEntity;
+    }
+
+    public bool DeleteNotePad(int id)
+    {
+        var notePadEntity = DbContext.Notepads.FirstOrDefault(n => n.Id == id);
+        if (notePadEntity == null)
+        {
+            return false;
+        }
+
+        DbContext.Notepads.Remove(notePadEntity);
+        DbContext.SaveChangesAsync();
+        return true;
+    }
+}

API_SQLuedo/DbDataManager/Service/NotepadDataService.cs

@@ -1,68 +0,0 @@
-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)
-        {
-            notepad.Notes = notes;
-            //throw new ArgumentException("Erreur, un bloc-notes existe déjà pour l'utilisateur et l'enquête donnée");
-        }
-        else
-        {
-            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,17 +54,6 @@ 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

@@ -1,26 +0,0 @@
-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/Dto/QueryDTO.cs

@@ -1,13 +0,0 @@
-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/Shared/IInquiryTableService.cs

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

API_SQLuedo/Shared/ILessonService.cs

@@ -5,7 +5,6 @@ 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,12 @@
+using Dto;
+
+namespace Shared;
+
+public interface INotePadService<TNotePad>
+{
+    public TNotePad GetNotePadById(int id);
+    public TNotePad GetNotePadByIdUserAndIdInquiry(int idUser, int idInquiry);
+    public TNotePad CreateNotePad(int id, int idUser, int idInquiry, string note);
+    public bool DeleteNotePad(int id);
+
+}

API_SQLuedo/Shared/INotepadService.cs

@@ -1,10 +0,0 @@
-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,7 +5,6 @@ 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

@@ -1,18 +0,0 @@
-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

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

API_SQLuedo/Shared/Mapper/LessonMapper.cs

@@ -16,6 +16,10 @@ 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/Migrations/20240624134431_Initial.Designer.cs

@@ -1,643 +0,0 @@
-// <auto-generated />
-using System;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-using StubbedContextLib;
-
-#nullable disable
-
-namespace StubbedContextLib.Migrations
-{
-    [DbContext(typeof(StubbedContext))]
-    [Migration("20240624134431_Initial")]
-    partial class Initial
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("ProductVersion", "8.0.2")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.HasSequence("ContentLessonEntitySequence");
-
-            modelBuilder.Entity("Entities.BlackListEntity", b =>
-                {
-                    b.Property<string>("Email")
-                        .HasColumnType("text");
-
-                    b.Property<DateOnly>("ExpirationDate")
-                        .HasColumnType("date");
-
-                    b.HasKey("Email");
-
-                    b.ToTable("BlackList");
-                });
-
-            modelBuilder.Entity("Entities.ContentLessonEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer")
-                        .HasDefaultValueSql("nextval('\"ContentLessonEntitySequence\"')");
-
-                    NpgsqlPropertyBuilderExtensions.UseSequence(b.Property<int>("Id"));
-
-                    b.Property<string>("ContentContent")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContentTitle")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("LessonId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("LessonId");
-
-                    b.ToTable((string)null);
-
-                    b.UseTpcMappingStrategy();
-                });
-
-            modelBuilder.Entity("Entities.InquiryEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsUser")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Inquiries");
-                });
-
-            modelBuilder.Entity("Entities.InquiryTableEntity", b =>
-                {
-                    b.Property<int>("OwnerId")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConnectionInfo")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("DatabaseName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("OwnerId");
-
-                    b.ToTable("InquiryTable");
-                });
-
-            modelBuilder.Entity("Entities.LessonEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<DateOnly>("LastEdit")
-                        .HasColumnType("date");
-
-                    b.Property<string>("LastPublisher")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Lesson");
-                });
-
-            modelBuilder.Entity("Entities.NotepadEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<int>("InquiryId")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Notes")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("UserId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("InquiryId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("Notepad");
-                });
-
-            modelBuilder.Entity("Entities.SolutionEntity", b =>
-                {
-                    b.Property<int>("OwnerId")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Explaination")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurderPlace")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurderWeapon")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurdererFirstName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurdererLastName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("OwnerId");
-
-                    b.ToTable("Solution");
-                });
-
-            modelBuilder.Entity("Entities.SuccessEntity", b =>
-                {
-                    b.Property<int>("InquiryId")
-                        .HasColumnType("integer");
-
-                    b.Property<bool>("IsFinished")
-                        .HasColumnType("boolean");
-
-                    b.Property<int>("UserId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("InquiryId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("Success");
-                });
-
-            modelBuilder.Entity("Entities.UserEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("Email")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsAdmin")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Password")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Username")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Email")
-                        .IsUnique();
-
-                    b.HasIndex("Username")
-                        .IsUnique();
-
-                    b.ToTable("User");
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1,
-                            Email = "Johnny.RATTON@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$7Dq.5Bf5WlHBMRqHBp5Ag.5PCCnvLrBXsuMGGJnV4l4WdngeDBpnW",
-                            Username = "johnny"
-                        },
-                        new
-                        {
-                            Id = 2,
-                            Email = "Maxime.SAPOUNTZIS@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$OT8g325JcE9mIdc.DiEKpem3kwNBdRcQ22vT2i5IB7KmfBfek4662",
-                            Username = "maxime"
-                        },
-                        new
-                        {
-                            Id = 3,
-                            Email = "Clement.CHIEU@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$Qc40bG8aCDvRSVjlWIn.1Orkd52fVMxBM2uQypVVwgu/mkeM8rnVK",
-                            Username = "clement"
-                        },
-                        new
-                        {
-                            Id = 4,
-                            Email = "Erwan.MENAGER@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$AW23BQcrS7d//LK0CtHuH.599OfYinEKCLkTz8Sbrtn.XYWE0u0BO",
-                            Username = "erwan"
-                        },
-                        new
-                        {
-                            Id = 5,
-                            Email = "Victor.GABORIT@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$ZOly/r95doGABtnypi8CAun1VnMRP1ct.idsUpXGe3pwjRYqv3ZQy",
-                            Username = "victor"
-                        });
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique()
-                        .HasDatabaseName("RoleNameIndex");
-
-                    b.ToTable("AspNetRoles", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetRoleClaims", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex");
-
-                    b.ToTable("AspNetUsers", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<string>("UserId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserClaims", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
-                {
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderKey")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderDisplayName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("UserId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("LoginProvider", "ProviderKey");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserLogins", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
-                {
-                    b.Property<string>("UserId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleId")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "RoleId");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetUserRoles", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
-                {
-                    b.Property<string>("UserId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "LoginProvider", "Name");
-
-                    b.ToTable("AspNetUserTokens", (string)null);
-                });
-
-            modelBuilder.Entity("Entities.ParagraphEntity", b =>
-                {
-                    b.HasBaseType("Entities.ContentLessonEntity");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Content")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Info")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Query")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.ToTable("Paragraph");
-                });
-
-            modelBuilder.Entity("Entities.ContentLessonEntity", b =>
-                {
-                    b.HasOne("Entities.LessonEntity", "Lesson")
-                        .WithMany("Content")
-                        .HasForeignKey("LessonId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Lesson");
-                });
-
-            modelBuilder.Entity("Entities.InquiryTableEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Entities.NotepadEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Inquiry")
-                        .WithMany()
-                        .HasForeignKey("InquiryId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Entities.UserEntity", "User")
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Inquiry");
-
-                    b.Navigation("User");
-                });
-
-            modelBuilder.Entity("Entities.SolutionEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Entities.SuccessEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Inquiry")
-                        .WithMany()
-                        .HasForeignKey("InquiryId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Entities.UserEntity", "User")
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Inquiry");
-
-                    b.Navigation("User");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Entities.LessonEntity", b =>
-                {
-                    b.Navigation("Content");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

API_SQLuedo/StubbedContextLib/Migrations/20240624134431_Initial.cs

@@ -1,478 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
-
-namespace StubbedContextLib.Migrations
-{
-    /// <inheritdoc />
-    public partial class Initial : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.CreateSequence(
-                name: "ContentLessonEntitySequence");
-
-            migrationBuilder.CreateTable(
-                name: "AspNetRoles",
-                columns: table => new
-                {
-                    Id = table.Column<string>(type: "text", nullable: false),
-                    Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    ConcurrencyStamp = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetRoles", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUsers",
-                columns: table => new
-                {
-                    Id = table.Column<string>(type: "text", nullable: false),
-                    UserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedUserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    Email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    NormalizedEmail = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
-                    EmailConfirmed = table.Column<bool>(type: "boolean", nullable: false),
-                    PasswordHash = table.Column<string>(type: "text", nullable: true),
-                    SecurityStamp = table.Column<string>(type: "text", nullable: true),
-                    ConcurrencyStamp = table.Column<string>(type: "text", nullable: true),
-                    PhoneNumber = table.Column<string>(type: "text", nullable: true),
-                    PhoneNumberConfirmed = table.Column<bool>(type: "boolean", nullable: false),
-                    TwoFactorEnabled = table.Column<bool>(type: "boolean", nullable: false),
-                    LockoutEnd = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
-                    LockoutEnabled = table.Column<bool>(type: "boolean", nullable: false),
-                    AccessFailedCount = table.Column<int>(type: "integer", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUsers", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "BlackList",
-                columns: table => new
-                {
-                    Email = table.Column<string>(type: "text", nullable: false),
-                    ExpirationDate = table.Column<DateOnly>(type: "date", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_BlackList", x => x.Email);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Inquiries",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Title = table.Column<string>(type: "text", nullable: false),
-                    Description = table.Column<string>(type: "text", nullable: false),
-                    IsUser = table.Column<bool>(type: "boolean", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Inquiries", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Lesson",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Title = table.Column<string>(type: "text", nullable: false),
-                    LastPublisher = table.Column<string>(type: "text", nullable: false),
-                    LastEdit = table.Column<DateOnly>(type: "date", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Lesson", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "User",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Username = table.Column<string>(type: "text", nullable: false),
-                    Password = table.Column<string>(type: "text", nullable: false),
-                    Email = table.Column<string>(type: "text", nullable: false),
-                    IsAdmin = table.Column<bool>(type: "boolean", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_User", x => x.Id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetRoleClaims",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    RoleId = table.Column<string>(type: "text", nullable: false),
-                    ClaimType = table.Column<string>(type: "text", nullable: true),
-                    ClaimValue = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
-                        column: x => x.RoleId,
-                        principalTable: "AspNetRoles",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserClaims",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    UserId = table.Column<string>(type: "text", nullable: false),
-                    ClaimType = table.Column<string>(type: "text", nullable: true),
-                    ClaimValue = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_AspNetUserClaims_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserLogins",
-                columns: table => new
-                {
-                    LoginProvider = table.Column<string>(type: "text", nullable: false),
-                    ProviderKey = table.Column<string>(type: "text", nullable: false),
-                    ProviderDisplayName = table.Column<string>(type: "text", nullable: true),
-                    UserId = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserLogins_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserRoles",
-                columns: table => new
-                {
-                    UserId = table.Column<string>(type: "text", nullable: false),
-                    RoleId = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
-                        column: x => x.RoleId,
-                        principalTable: "AspNetRoles",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_AspNetUserRoles_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "AspNetUserTokens",
-                columns: table => new
-                {
-                    UserId = table.Column<string>(type: "text", nullable: false),
-                    LoginProvider = table.Column<string>(type: "text", nullable: false),
-                    Name = table.Column<string>(type: "text", nullable: false),
-                    Value = table.Column<string>(type: "text", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
-                    table.ForeignKey(
-                        name: "FK_AspNetUserTokens_AspNetUsers_UserId",
-                        column: x => x.UserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "InquiryTable",
-                columns: table => new
-                {
-                    OwnerId = table.Column<int>(type: "integer", nullable: false),
-                    DatabaseName = table.Column<string>(type: "text", nullable: false),
-                    ConnectionInfo = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_InquiryTable", x => x.OwnerId);
-                    table.ForeignKey(
-                        name: "FK_InquiryTable_Inquiries_OwnerId",
-                        column: x => x.OwnerId,
-                        principalTable: "Inquiries",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Solution",
-                columns: table => new
-                {
-                    OwnerId = table.Column<int>(type: "integer", nullable: false),
-                    MurdererFirstName = table.Column<string>(type: "text", nullable: false),
-                    MurdererLastName = table.Column<string>(type: "text", nullable: false),
-                    MurderPlace = table.Column<string>(type: "text", nullable: false),
-                    MurderWeapon = table.Column<string>(type: "text", nullable: false),
-                    Explaination = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Solution", x => x.OwnerId);
-                    table.ForeignKey(
-                        name: "FK_Solution_Inquiries_OwnerId",
-                        column: x => x.OwnerId,
-                        principalTable: "Inquiries",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Paragraph",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false, defaultValueSql: "nextval('\"ContentLessonEntitySequence\"')"),
-                    ContentContent = table.Column<string>(type: "text", nullable: false),
-                    ContentTitle = table.Column<string>(type: "text", nullable: false),
-                    LessonId = table.Column<int>(type: "integer", nullable: false),
-                    Title = table.Column<string>(type: "text", nullable: false),
-                    Content = table.Column<string>(type: "text", nullable: false),
-                    Info = table.Column<string>(type: "text", nullable: false),
-                    Query = table.Column<string>(type: "text", nullable: false),
-                    Comment = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Paragraph", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_Paragraph_Lesson_LessonId",
-                        column: x => x.LessonId,
-                        principalTable: "Lesson",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Notepad",
-                columns: table => new
-                {
-                    Id = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    UserId = table.Column<int>(type: "integer", nullable: false),
-                    InquiryId = table.Column<int>(type: "integer", nullable: false),
-                    Notes = table.Column<string>(type: "text", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Notepad", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_Notepad_Inquiries_InquiryId",
-                        column: x => x.InquiryId,
-                        principalTable: "Inquiries",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_Notepad_User_UserId",
-                        column: x => x.UserId,
-                        principalTable: "User",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "Success",
-                columns: table => new
-                {
-                    InquiryId = table.Column<int>(type: "integer", nullable: false),
-                    UserId = table.Column<int>(type: "integer", nullable: false),
-                    IsFinished = table.Column<bool>(type: "boolean", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Success", x => x.InquiryId);
-                    table.ForeignKey(
-                        name: "FK_Success_Inquiries_InquiryId",
-                        column: x => x.InquiryId,
-                        principalTable: "Inquiries",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_Success_User_UserId",
-                        column: x => x.UserId,
-                        principalTable: "User",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.InsertData(
-                table: "User",
-                columns: new[] { "Id", "Email", "IsAdmin", "Password", "Username" },
-                values: new object[,]
-                {
-                    { 1, "Johnny.RATTON@etu.uca.fr", true, "$2a$10$7Dq.5Bf5WlHBMRqHBp5Ag.5PCCnvLrBXsuMGGJnV4l4WdngeDBpnW", "johnny" },
-                    { 2, "Maxime.SAPOUNTZIS@etu.uca.fr", true, "$2a$10$OT8g325JcE9mIdc.DiEKpem3kwNBdRcQ22vT2i5IB7KmfBfek4662", "maxime" },
-                    { 3, "Clement.CHIEU@etu.uca.fr", true, "$2a$10$Qc40bG8aCDvRSVjlWIn.1Orkd52fVMxBM2uQypVVwgu/mkeM8rnVK", "clement" },
-                    { 4, "Erwan.MENAGER@etu.uca.fr", true, "$2a$10$AW23BQcrS7d//LK0CtHuH.599OfYinEKCLkTz8Sbrtn.XYWE0u0BO", "erwan" },
-                    { 5, "Victor.GABORIT@etu.uca.fr", true, "$2a$10$ZOly/r95doGABtnypi8CAun1VnMRP1ct.idsUpXGe3pwjRYqv3ZQy", "victor" }
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetRoleClaims_RoleId",
-                table: "AspNetRoleClaims",
-                column: "RoleId");
-
-            migrationBuilder.CreateIndex(
-                name: "RoleNameIndex",
-                table: "AspNetRoles",
-                column: "NormalizedName",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserClaims_UserId",
-                table: "AspNetUserClaims",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserLogins_UserId",
-                table: "AspNetUserLogins",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AspNetUserRoles_RoleId",
-                table: "AspNetUserRoles",
-                column: "RoleId");
-
-            migrationBuilder.CreateIndex(
-                name: "EmailIndex",
-                table: "AspNetUsers",
-                column: "NormalizedEmail");
-
-            migrationBuilder.CreateIndex(
-                name: "UserNameIndex",
-                table: "AspNetUsers",
-                column: "NormalizedUserName",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Notepad_InquiryId",
-                table: "Notepad",
-                column: "InquiryId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Notepad_UserId",
-                table: "Notepad",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Paragraph_LessonId",
-                table: "Paragraph",
-                column: "LessonId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Success_UserId",
-                table: "Success",
-                column: "UserId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_User_Email",
-                table: "User",
-                column: "Email",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_User_Username",
-                table: "User",
-                column: "Username",
-                unique: true);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "AspNetRoleClaims");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserClaims");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserLogins");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserRoles");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUserTokens");
-
-            migrationBuilder.DropTable(
-                name: "BlackList");
-
-            migrationBuilder.DropTable(
-                name: "InquiryTable");
-
-            migrationBuilder.DropTable(
-                name: "Notepad");
-
-            migrationBuilder.DropTable(
-                name: "Paragraph");
-
-            migrationBuilder.DropTable(
-                name: "Solution");
-
-            migrationBuilder.DropTable(
-                name: "Success");
-
-            migrationBuilder.DropTable(
-                name: "AspNetRoles");
-
-            migrationBuilder.DropTable(
-                name: "AspNetUsers");
-
-            migrationBuilder.DropTable(
-                name: "Lesson");
-
-            migrationBuilder.DropTable(
-                name: "Inquiries");
-
-            migrationBuilder.DropTable(
-                name: "User");
-
-            migrationBuilder.DropSequence(
-                name: "ContentLessonEntitySequence");
-        }
-    }
-}

API_SQLuedo/StubbedContextLib/Migrations/StubbedContextModelSnapshot.cs

@@ -1,640 +0,0 @@
-// <auto-generated />
-using System;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-using StubbedContextLib;
-
-#nullable disable
-
-namespace StubbedContextLib.Migrations
-{
-    [DbContext(typeof(StubbedContext))]
-    partial class StubbedContextModelSnapshot : ModelSnapshot
-    {
-        protected override void BuildModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("ProductVersion", "8.0.2")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.HasSequence("ContentLessonEntitySequence");
-
-            modelBuilder.Entity("Entities.BlackListEntity", b =>
-                {
-                    b.Property<string>("Email")
-                        .HasColumnType("text");
-
-                    b.Property<DateOnly>("ExpirationDate")
-                        .HasColumnType("date");
-
-                    b.HasKey("Email");
-
-                    b.ToTable("BlackList");
-                });
-
-            modelBuilder.Entity("Entities.ContentLessonEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer")
-                        .HasDefaultValueSql("nextval('\"ContentLessonEntitySequence\"')");
-
-                    NpgsqlPropertyBuilderExtensions.UseSequence(b.Property<int>("Id"));
-
-                    b.Property<string>("ContentContent")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContentTitle")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("LessonId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("LessonId");
-
-                    b.ToTable((string)null);
-
-                    b.UseTpcMappingStrategy();
-                });
-
-            modelBuilder.Entity("Entities.InquiryEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsUser")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Inquiries");
-                });
-
-            modelBuilder.Entity("Entities.InquiryTableEntity", b =>
-                {
-                    b.Property<int>("OwnerId")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConnectionInfo")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("DatabaseName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("OwnerId");
-
-                    b.ToTable("InquiryTable");
-                });
-
-            modelBuilder.Entity("Entities.LessonEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<DateOnly>("LastEdit")
-                        .HasColumnType("date");
-
-                    b.Property<string>("LastPublisher")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Lesson");
-                });
-
-            modelBuilder.Entity("Entities.NotepadEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<int>("InquiryId")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Notes")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("UserId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("InquiryId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("Notepad");
-                });
-
-            modelBuilder.Entity("Entities.SolutionEntity", b =>
-                {
-                    b.Property<int>("OwnerId")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    b.Property<string>("Explaination")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurderPlace")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurderWeapon")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurdererFirstName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("MurdererLastName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("OwnerId");
-
-                    b.ToTable("Solution");
-                });
-
-            modelBuilder.Entity("Entities.SuccessEntity", b =>
-                {
-                    b.Property<int>("InquiryId")
-                        .HasColumnType("integer");
-
-                    b.Property<bool>("IsFinished")
-                        .HasColumnType("boolean");
-
-                    b.Property<int>("UserId")
-                        .HasColumnType("integer");
-
-                    b.HasKey("InquiryId");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("Success");
-                });
-
-            modelBuilder.Entity("Entities.UserEntity", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("Email")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsAdmin")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Password")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Username")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Email")
-                        .IsUnique();
-
-                    b.HasIndex("Username")
-                        .IsUnique();
-
-                    b.ToTable("User");
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1,
-                            Email = "Johnny.RATTON@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$7Dq.5Bf5WlHBMRqHBp5Ag.5PCCnvLrBXsuMGGJnV4l4WdngeDBpnW",
-                            Username = "johnny"
-                        },
-                        new
-                        {
-                            Id = 2,
-                            Email = "Maxime.SAPOUNTZIS@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$OT8g325JcE9mIdc.DiEKpem3kwNBdRcQ22vT2i5IB7KmfBfek4662",
-                            Username = "maxime"
-                        },
-                        new
-                        {
-                            Id = 3,
-                            Email = "Clement.CHIEU@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$Qc40bG8aCDvRSVjlWIn.1Orkd52fVMxBM2uQypVVwgu/mkeM8rnVK",
-                            Username = "clement"
-                        },
-                        new
-                        {
-                            Id = 4,
-                            Email = "Erwan.MENAGER@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$AW23BQcrS7d//LK0CtHuH.599OfYinEKCLkTz8Sbrtn.XYWE0u0BO",
-                            Username = "erwan"
-                        },
-                        new
-                        {
-                            Id = 5,
-                            Email = "Victor.GABORIT@etu.uca.fr",
-                            IsAdmin = true,
-                            Password = "$2a$10$ZOly/r95doGABtnypi8CAun1VnMRP1ct.idsUpXGe3pwjRYqv3ZQy",
-                            Username = "victor"
-                        });
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedName")
-                        .IsUnique()
-                        .HasDatabaseName("RoleNameIndex");
-
-                    b.ToTable("AspNetRoles", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetRoleClaims", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("text");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex");
-
-                    b.ToTable("AspNetUsers", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
-
-                    b.Property<string>("ClaimType")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ClaimValue")
-                        .HasColumnType("text");
-
-                    b.Property<string>("UserId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserClaims", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
-                {
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderKey")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderDisplayName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("UserId")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("LoginProvider", "ProviderKey");
-
-                    b.HasIndex("UserId");
-
-                    b.ToTable("AspNetUserLogins", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
-                {
-                    b.Property<string>("UserId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleId")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "RoleId");
-
-                    b.HasIndex("RoleId");
-
-                    b.ToTable("AspNetUserRoles", (string)null);
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
-                {
-                    b.Property<string>("UserId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("LoginProvider")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Value")
-                        .HasColumnType("text");
-
-                    b.HasKey("UserId", "LoginProvider", "Name");
-
-                    b.ToTable("AspNetUserTokens", (string)null);
-                });
-
-            modelBuilder.Entity("Entities.ParagraphEntity", b =>
-                {
-                    b.HasBaseType("Entities.ContentLessonEntity");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Content")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Info")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Query")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.ToTable("Paragraph");
-                });
-
-            modelBuilder.Entity("Entities.ContentLessonEntity", b =>
-                {
-                    b.HasOne("Entities.LessonEntity", "Lesson")
-                        .WithMany("Content")
-                        .HasForeignKey("LessonId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Lesson");
-                });
-
-            modelBuilder.Entity("Entities.InquiryTableEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Entities.NotepadEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Inquiry")
-                        .WithMany()
-                        .HasForeignKey("InquiryId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Entities.UserEntity", "User")
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Inquiry");
-
-                    b.Navigation("User");
-                });
-
-            modelBuilder.Entity("Entities.SolutionEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Entities.SuccessEntity", b =>
-                {
-                    b.HasOne("Entities.InquiryEntity", "Inquiry")
-                        .WithMany()
-                        .HasForeignKey("InquiryId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Entities.UserEntity", "User")
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Inquiry");
-
-                    b.Navigation("User");
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
-                        .WithMany()
-                        .HasForeignKey("RoleId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
-                {
-                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
-                        .WithMany()
-                        .HasForeignKey("UserId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Entities.LessonEntity", b =>
-                {
-                    b.Navigation("Content");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

API_SQLuedo/StubbedContextLib/StubbedContext.cs

@@ -88,7 +88,7 @@ public class StubbedContext : UserDbContext
                 IsAdmin = true
             });
 
-        /*builder.Entity<InquiryTableEntity>().HasData(
+        builder.Entity<InquiryTableEntity>().HasData(
             new InquiryTableEntity
             {
                 OwnerId = 1,
@@ -184,29 +184,5 @@ 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

@@ -153,24 +153,7 @@ public class BlackListUnitTest
             Assert.True(GetBlackList().SequenceEqual(valeur as IEnumerable<BlackListDto>, new BlackListDtoEqualityComparer()));
         }
     }
-
+    
-    [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()
     {

API_SQLuedo/TestAPI/InquiryTableUnitTest.cs

@@ -1,51 +0,0 @@
-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/LessonUnitTest.cs

@@ -5,7 +5,6 @@ using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Shared;
 using TestAPI.Extensions;
-using Xunit.Sdk;
 
 namespace TestAPI;
 
@@ -102,22 +101,6 @@ 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()
     {
@@ -162,21 +145,6 @@ 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()
     {
@@ -245,21 +213,6 @@ 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

@@ -1,183 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -145,23 +145,6 @@ public class SuccessesUnitTest
         }
     }
 
-    [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()
     {
@@ -234,23 +217,6 @@ public class SuccessesUnitTest
         }
     }
 
-    [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()
     {
@@ -352,22 +318,6 @@ public class SuccessesUnitTest
         }
     }
 
-    [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()
     {
@@ -436,22 +386,6 @@ public class SuccessesUnitTest
         }
     }
 
-    [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()

API_SQLuedo/TestAPI/TestAPI.csproj

@@ -11,7 +11,6 @@
 
   <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

@@ -171,7 +171,7 @@ public class UserUnitTest
 
 
     [Fact]
-    public void GetUserIdFail_Negative_Id()
+    public void GetUserIdFail__Argument_Exception_Negative_Id()
     {
         var userList = GetUsersData();
         _userService.Setup(x => x.GetUserById(1))
@@ -189,22 +189,6 @@ public class UserUnitTest
         }
     }
 
-    [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()
     {
@@ -228,22 +212,6 @@ public class UserUnitTest
         }
     }
 
-    [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()
     {
@@ -340,34 +308,6 @@ 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()
     {

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.FromDtoToModel();
+            var inquiryMod = inquiry.FromDtoToEntity();
 
             Assert.NotNull(inquiryMod);
-            Assert.IsType<Inquiry>(inquiryMod);
+            Assert.IsType<InquiryEntity>(inquiryMod);
             Assert.Equal(1, inquiryMod.Id);
             Assert.Equal(_title, inquiryMod.Title);
             Assert.Equal(_description, inquiryMod.Description);

API_SQLuedo/TestEF/Service/TestBlackListDataService.cs

@@ -109,7 +109,7 @@ public class TestBlackListDataService
     }
 
     [Fact]
-    public void GetBannedUser_Success_Positive_Value_Ordered_None()
+    public void GetBannedUser_Success_Positive_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) });
@@ -119,42 +119,6 @@ public class TestBlackListDataService
         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()
     {

API_SQLuedo/TestEF/Service/TestInquiryDataService.cs

@@ -89,45 +89,6 @@ 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

@@ -1,62 +0,0 @@
-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

@@ -1,169 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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);
-        });
-    }
-}

README.md

@@ -79,7 +79,7 @@ Voilà, vous pouvez maintenant utilisez librement l'API !
 
 ---
 
-### Versionnement 
+### Versionnement
 
 Notre API est versionnée ce qui signifie qu'à chaque requête, la version souhaitée de l'API doit être fournie. Pour l'instant, il n'y a qu'une __version 1.0__.