Merge pull request 'deploiement' (#50) from deploiement into master

Reviewed-on: #50

.drone.yml

@@ -20,11 +20,11 @@ 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:
@@ -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
@@ -57,3 +57,37 @@ steps:
       CODEFIRST_CLIENTDRONE_ENV_POSTGRES_DB:
         from_secret: db_database
       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,8 +492,7 @@ fabric.properties
 .idea/caches/build_file_checksums.ser
 
 
-# Migrations et fichiers db
+# Fichier db
-**/Migrations/**
 *.db
 
 /**/.idea/

API_SQLuedo/API/Controllers/BlackListController.cs

@@ -1,11 +1,9 @@
 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;
 
@@ -13,7 +11,8 @@ namespace API.Controllers;
 [Authorize]
 [ApiVersion("1.0")]
 [ApiController]
-public class BlackListController(ILogger<UsersController> logger, IBlackListService<BlackListDto> blackListService) : ControllerBase
+public class BlackListController(ILogger<UsersController> logger, IBlackListService<BlackListDto> blackListService)
+    : ControllerBase
 {
     [HttpGet("user/ban/{page:int}/{number:int}")]
     [ProducesResponseType(typeof(IEnumerable<BlackListDto>), 200)]
@@ -52,6 +51,7 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
             logger.LogInformation("[INFORMATION] Utilisateur banni avec l'email {email} a été trouvé.", email);
             return Ok(res);
         }
+
         logger.LogError("[ERREUR] Aucun utilisateur banni trouvé avec l'email {email}.", email);
         return NotFound("Utilisateur non trouvé !");
     }

API_SQLuedo/API/Controllers/InquiriesController.cs

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

API_SQLuedo/API/Controllers/LessonsController.cs

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

API_SQLuedo/API/Controllers/ParagraphsController.cs

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

API_SQLuedo/API/Controllers/SuccessesController.cs

@@ -5,203 +5,202 @@ 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
 {
-    [Route("api/v{version:apiVersion}/[controller]")]
+    private readonly ISuccessService<SuccessDto> _successDataService;
-    [Authorize]
+
-    [ApiVersion("1.0")]
+    private readonly ILogger<SuccessesController> _logger;
-    [ApiController]
+
-    public class SuccessesController : Controller
+    public SuccessesController(ISuccessService<SuccessDto> successDataService, ILogger<SuccessesController> logger)
+    {
+        _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)
     {
-        private readonly ISuccessService<SuccessDto> _successDataService;
+        switch (e.Message)
-
+        {
-        private readonly ILogger<SuccessesController> _logger;
+            case { } msg when msg.Contains("userId"):
-
+                _logger.LogError("[ERREUR] Impossible de trouver l'utilisateur pour la manipulation du succès");
-        public SuccessesController(ISuccessService<SuccessDto> successDataService, ILogger<SuccessesController> logger)
+                return NotFound("Impossible de trouver l'utilisateur pour la manipulation du succès");
-        {
+            case { } msg when msg.Contains("inquiryId"):
-            _successDataService = successDataService;
+                _logger.LogError("[ERREUR] Impossible de trouver l'enquête pour la manipulation du succès");
-            _logger = logger;
+                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");
-        [HttpGet("successes/{page:int}/{number:int}/{orderCriteria}")]
+                return Conflict("Impossible de manipuler le succès car il n'existe pas");
-        [ProducesResponseType(typeof(SuccessDto), 200)]
+            default:
-        [ProducesResponseType(typeof(string), 204)]
+                _logger.LogError("[ERREUR] Erreur inattendue, impossible de manipuler le succès");
-        [ProducesResponseType(typeof(string), 400)]
+                return BadRequest("Erreur inattendue, impossible de manipuler le succès");
-        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,229 +5,231 @@ 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
 {
-    [Route("api/v{version:apiVersion}/[controller]")]
+    [HttpGet("users/{page:int}/{number:int}")]
-    [Authorize]
+    [ProducesResponseType(typeof(UserDto), 200)]
-    [ApiVersion("1.0")]
+    [ProducesResponseType(typeof(string), 204)]
-    [ApiController]
+    public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
-    public class UsersController(ILogger<UsersController> logger, IUserService<UserDto> userService) : ControllerBase
     {
-        [HttpGet("users/{page:int}/{number:int}")]
+        var users = userService.GetUsers(page, number, orderCriteria).ToList();
-        [ProducesResponseType(typeof(UserDto), 200)]
+        if (users.Count == 0)
-        [ProducesResponseType(typeof(string), 204)]
+        {
-        public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
-        {
+            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);
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+        return Ok(users);
-                return StatusCode(204);
+    }
-            }
+
-
+    [HttpGet("users/not-admin/{page:int}/{number:int}")]
-            logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+    [ProducesResponseType(typeof(UserDto), 200)]
-            return Ok(users);
+    [ProducesResponseType(typeof(string), 204)]
-        }
+    public IActionResult GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
-        
+    {
-        [HttpGet("users/not-admin/{page:int}/{number:int}")]
+        var users = userService.GetNotAdminUsers(page, number, orderCriteria).ToList();
-        [ProducesResponseType(typeof(UserDto), 200)]
+        if (users.Count == 0)
-        [ProducesResponseType(typeof(string), 204)]
+        {
-        public IActionResult GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
-        {
+            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);
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+        return Ok(users);
-                return StatusCode(204);
+    }
-            }
+
-
+    [HttpGet("users/number")]
-            logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+    [ProducesResponseType(typeof(UserDto), 200)]
-            return Ok(users);
+    [ProducesResponseType(typeof(string), 204)]
-        }
+    public IActionResult GetNumberOfUsers()
-        
+    {
-        [HttpGet("users/number")]
+        var users = userService.GetNumberOfUsers();
-        [ProducesResponseType(typeof(UserDto), 200)]
+        if (users == 0)
-        [ProducesResponseType(typeof(string), 204)]
+        {
-        public IActionResult GetNumberOfUsers()
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
-        {
+            return StatusCode(204);
-            var users = userService.GetNumberOfUsers();
+        }
-            if (users == 0)
+
-            {
+        logger.LogInformation("[INFORMATION] {users} Utilisateur(s) trouvé(s)", users);
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+        return Ok(new KeyValuePair<string, int>("nbUsers", users));
-                return StatusCode(204);
+    }
-            }
+
-
+    [HttpGet("user/{id:int}")]
-            logger.LogInformation("[INFORMATION] {users} Utilisateur(s) trouvé(s)", users);
+    [ProducesResponseType(typeof(UserDto), 200)]
-            return Ok(new KeyValuePair<string,int>("nbUsers", users));
+    [ProducesResponseType(typeof(string), 404)]
-        }
+    public IActionResult GetUserById(int id)
-
+    {
-        [HttpGet("user/{id:int}")]
+        try
-        [ProducesResponseType(typeof(UserDto), 200)]
+        {
-        [ProducesResponseType(typeof(string), 404)]
+            logger.LogInformation("[INFORMATION] Utilisateur avec l'id {id} a été trouvé.", id);
-        public IActionResult GetUserById(int id)
+            return Ok(userService.GetUserById(id));
-        {
+        }
-            try
+        catch (ArgumentException)
-            {
+        {
-                logger.LogInformation("[INFORMATION] Utilisateur avec l'id {id} a été trouvé.", id);
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
-                return Ok(userService.GetUserById(id));
+            return NotFound();
-            }
+        }
-            catch (ArgumentException)
+    }
-            {
+
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
+    [HttpGet("user/{username:alpha}")]
-                return NotFound();
+    [ProducesResponseType(typeof(UserDto), 200)]
-            }
+    [ProducesResponseType(typeof(string), 404)]
-        }
+    public IActionResult GetUserByUsername(string username)
-
+    {
-        [HttpGet("user/{username:alpha}")]
+        try
-        [ProducesResponseType(typeof(UserDto), 200)]
+        {
-        [ProducesResponseType(typeof(string), 404)]
+            logger.LogInformation("[INFORMATION] Utilisateur avec l'username {username} a été trouvé.", username);
-        public IActionResult GetUserByUsername(string username)
+            return Ok(userService.GetUserByUsername(username));
-        {
+        }
-            try
+        catch (ArgumentException)
-            {
+        {
-                logger.LogInformation("[INFORMATION] Utilisateur avec l'username {username} a été trouvé.", username);
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {username}.", username);
-                return Ok(userService.GetUserByUsername(username));
+            return NotFound("Utilisateur non trouvé !");
-            }
+        }
-            catch (ArgumentException)
+    }
-            {
+
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {username}.", username);
+    [HttpGet("user/email/{email}")]
-                return NotFound("Utilisateur non trouvé !");
+    [ProducesResponseType(typeof(UserDto), 200)]
-            }
+    [ProducesResponseType(typeof(string), 404)]
-        }
+    public IActionResult GetByEmail(string email)
-        [HttpGet("user/email/{email}")]
+    {
-        [ProducesResponseType(typeof(UserDto), 200)]
+        try
-        [ProducesResponseType(typeof(string), 404)]
+        {
-        public IActionResult GetByEmail(string email)
+            logger.LogInformation("[INFORMATION] Utilisateur avec l'username {email} a été trouvé.", email);
-        {
+            return Ok(userService.GetUserByEmail(email));
-            try
+        }
-            {
+        catch (ArgumentException)
-                logger.LogInformation("[INFORMATION] Utilisateur avec l'username {email} a été trouvé.", email);
+        {
-                return Ok(userService.GetUserByEmail(email));
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {email}.", email);
-            }
+            return NotFound();
-            catch (ArgumentException)
+        }
-            {
+    }
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {email}.", email);
+
-                return NotFound();
+    [HttpDelete("user/{id:int}")]
-            }
+    [ProducesResponseType(typeof(UserDto), 200)]
-        }
+    [ProducesResponseType(typeof(string), 404)]
-
+    public IActionResult DeleteUser(int id)
-        [HttpDelete("user/{id:int}")]
+    {
-        [ProducesResponseType(typeof(UserDto), 200)]
+        var success = userService.DeleteUser(id);
-        [ProducesResponseType(typeof(string), 404)]
+        if (success)
-        public IActionResult DeleteUser(int id)
+        {
-        {
+            logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id);
-            var success = userService.DeleteUser(id);
+            return Ok();
-            if (success)
+        }
-            {
+        else
-                logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id);
+        {
-                return Ok();
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
-            }
+            return NotFound();
-            else
+        }
-            {
+    }
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
+
-                return NotFound();
+    [HttpDelete("user/username/{username:alpha}")]
-            }
+    [ProducesResponseType(typeof(UserDto), 200)]
-        }
+    [ProducesResponseType(typeof(string), 404)]
-        
+    public IActionResult DeleteUserByUsername(string username)
-        [HttpDelete("user/username/{username:alpha}")]
+    {
-        [ProducesResponseType(typeof(UserDto), 200)]
+        var success = userService.DeleteUserByUsername(username);
-        [ProducesResponseType(typeof(string), 404)]
+        if (success)
-        public IActionResult DeleteUserByUsername(string username)
+        {
-        {
+            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.",
-            var success = userService.DeleteUserByUsername(username);
+                username);
-            if (success)
+            return Ok();
-            {
+        }
-                logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.", username);
+        else
-                return Ok();
+        {
-            }
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec le pseudo {username}.", username);
-            else
+            return NotFound();
-            {
+        }
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec le pseudo {username}.", username);
+    }
-                return NotFound();
+
-            }
+    [HttpPost]
-        }
+    [ProducesResponseType(typeof(UserDto), 201)]
-
+    [ProducesResponseType(typeof(string), 400)]
-        [HttpPost]
+    [ProducesResponseType(typeof(string), 409)]
-        [ProducesResponseType(typeof(UserDto), 201)]
+    [ProducesResponseType(typeof(string), 410)]
-        [ProducesResponseType(typeof(string), 400)]
+    public IActionResult CreateUser([FromBody] UserDto dto)
-        [ProducesResponseType(typeof(string), 409)]
+    {
-        [ProducesResponseType(typeof(string), 410)]
+        if (dto.Username == null || dto.Password == null || dto.Email == null)
-        public IActionResult CreateUser([FromBody] UserDto dto)
+        {
-        {
+            return BadRequest();
-            if (dto.Username == null || dto.Password == null || dto.Email == null)
+        }
-            {
+
-                return BadRequest();
+        if (userService.IsEmailTaken(dto.Email))
-            }
+        {
-
+            return StatusCode(409, "Email déjà utilisé");
-            if (userService.IsEmailTaken(dto.Email))
+        }
-            {
+
-                return StatusCode(409, "Email déjà utilisé");
+        if (userService.IsUsernameTaken(dto.Username))
-            }
+        {
-
+            return StatusCode(410, "Username déjà utilisé");
-            if (userService.IsUsernameTaken(dto.Username))
+        }
-            {
+
-                return StatusCode(410, "Username déjà utilisé");
+        // return Ok(userService.CreateUser(username, password, email, isAdmin));
-            }
+        logger.LogInformation(
-
+            "[INFORMATION] Un utilisateur a été créé : username - {username}, password - {password}, email - {email}, isAdmin - {isAdmin}",
-            // return Ok(userService.CreateUser(username, password, email, isAdmin));
+            dto.Username, dto.Password, dto.Email, dto.IsAdmin);
-            logger.LogInformation(
+        return Created(nameof(GetUsers),
-                "[INFORMATION] Un utilisateur a été créé : username - {username}, password - {password}, email - {email}, isAdmin - {isAdmin}",
+            userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin));
-                dto.Username, dto.Password, dto.Email, dto.IsAdmin);
+    }
-            return Created(nameof(GetUsers),
+
-                userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin));
+    [HttpPut("user/{id:int}")]
-        }
+    [ProducesResponseType(typeof(UserDto), 200)]
-
+    [ProducesResponseType(typeof(string), 400)]
-        [HttpPut("user/{id:int}")]
+    [ProducesResponseType(typeof(string), 404)]
-        [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 409)]
-        [ProducesResponseType(typeof(string), 400)]
+    public IActionResult UpdateUser(int id, [FromBody] UserDto userDto)
-        [ProducesResponseType(typeof(string), 404)]
+    {
-        [ProducesResponseType(typeof(string), 409)]
+        if (id != userDto.Id)
-        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);
-            if (id != userDto.Id)
+            return BadRequest();
-            {
+        }
-                logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
+
-                return BadRequest();
+        if (!ModelState.IsValid)
-            }
+        {
-
+            logger.LogError(
-            if (!ModelState.IsValid)
+                "[ERREUR] Problème controller - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
-            {
+            return BadRequest();
-                logger.LogError(
+        }
-                    "[ERREUR] Problème controller - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
+
-                return BadRequest();
+        if (userDto.Username == userService.GetUserById(id).Username && !userService.IsEmailTaken(userDto.Email)
-            }
+            || (userDto.Email == userService.GetUserById(id).Email &&
-
+                !userService.IsUsernameTaken(userDto.Username))
-            if (userDto.Username == userService.GetUserById(id).Username && !userService.IsEmailTaken(userDto.Email)
+            || (!userService.IsEmailTaken(userDto.Email) && !userService.IsUsernameTaken(userDto.Username)))
-                || (userDto.Email == userService.GetUserById(id).Email &&
+        {
-                    !userService.IsUsernameTaken(userDto.Username))
+            logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
-                || (!userService.IsEmailTaken(userDto.Email) && !userService.IsUsernameTaken(userDto.Username)))
+                id);
-            {
+            return Ok(userService.UpdateUser(id, userDto));
-                logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
+        }
-                    id);
+
-                return Ok(userService.UpdateUser(id, userDto));
+        logger.LogError("[ERREUR] Email ou nom d'utilisateur déjà utilisé");
-            }
+        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)]
-        [HttpPut("user/promote/{id:int}")]
+    [ProducesResponseType(typeof(string), 404)]
-        [ProducesResponseType(typeof(UserDto), 200)]
+    public IActionResult PromoteUser(int id)
-        [ProducesResponseType(typeof(string), 404)]
+    {
-        public IActionResult PromoteUser(int id)
+        var userPromoted = userService.GetUserById(id);
-        {
+        if (userPromoted != null)
-            var userPromoted = userService.GetUserById(id);
+        {
-            if (userPromoted != null)
+            userPromoted = userService.PromoteUser(id);
-            {
+            logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} a été effectuée");
-                userPromoted = userService.PromoteUser(id);
+            return Ok(userPromoted);
-                logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} a été effectuée");
+        }
-                return Ok(userPromoted);
+        else
-            }
+        {
-            else
+            logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} à échouée",
-            {
+                id);
-                logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} à échouée",
+            return NotFound();
-                    id);
-                return NotFound();
-            }
         }
     }
 }

API_SQLuedo/API/Dockerfile

@@ -1,10 +1,7 @@
-#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 8080
+EXPOSE 80
-EXPOSE 8081
 
 FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
 ARG BUILD_CONFIGURATION=Release
@@ -29,4 +26,6 @@ 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

@@ -13,8 +13,8 @@ using Shared;
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services to the container.
-
 builder.Services.AddControllers();
+
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
@@ -48,9 +48,30 @@ builder.Services.AddScoped<ILessonService<LessonDto>, LessonDataServiceApi>();
 builder.Services.AddScoped<INotepadService<NotepadEntity>, NotepadDataService>();
 builder.Services.AddScoped<INotepadService<NotepadDto>, NotepadDataServiceAPI>();
 
-builder.Services.AddDbContext<DbContext, UserDbContext>();
+builder.Services.AddDbContext<DbContext, UserDbContext>(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 =>
@@ -121,6 +142,10 @@ 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
@@ -146,12 +171,9 @@ using (var scope = app.Services.CreateScope())
     }
 }
 
-// Configure the HTTP request pipeline.
+
-if (app.Environment.IsDevelopment())
+app.UseSwagger();
-{
+app.UseSwaggerUI();
-    app.UseSwagger();
-    app.UseSwaggerUI();
-}
 
 app.UseHttpsRedirection();
 

API_SQLuedo/API/Properties/launchSettings.json

@@ -24,7 +24,7 @@
       "dotnetRunMessages": true,
       "launchBrowser": true,
       "launchUrl": "swagger",
-      "applicationUrl": "https://localhost:7259;http://localhost:5015",
+      "applicationUrl": "https://localhost:8081;http://localhost:5015",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       }
@@ -32,7 +32,7 @@
     "IIS Express": {
       "commandName": "IISExpress",
       "launchBrowser": true,
-      "launchUrl": "swagger",
+      "launchUrl": "containers/johnnyratton-sqluedo-api",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       }

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

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

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

@@ -0,0 +1,592 @@
+// <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("CONNECTION_STRING", EnvironmentVariableTarget.Process));
+                optionsBuilder.UseNpgsql(Environment.GetEnvironmentVariable("CO_STRING", EnvironmentVariableTarget.Process));
-                optionsBuilder.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse");
+                //optionsBuilder.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse");
             }
         }