Ajout des controller notepad, solution et des services associés + modification des controllers et services actuels pour se conformer au site PHP

API_SQLuedo/API/Controllers/InquiryTableController.cs

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

API_SQLuedo/API/Controllers/LessonsController.cs

@@ -40,6 +40,16 @@ namespace API.Controllers
             return Ok(_lessonDataService.GetLessons(page, number, orderCriteria));
         }
         
+        [HttpGet("lessons/number")]
+        [ProducesResponseType(typeof(KeyValuePair<string,int>), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetNumberOfLessons()
+        {
+            var nbLesson = _lessonDataService.GetNumberOfLessons();
+            _logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson);
+            return Ok(new KeyValuePair<string,int>("nbLessons",nbLesson));
+        }
+
         [HttpGet("lesson/{id:int}")]
         [ProducesResponseType(typeof(LessonDto), 200)]
         [ProducesResponseType(typeof(string), 404)]

API_SQLuedo/API/Controllers/NotepadController.cs

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

API_SQLuedo/API/Controllers/ParagraphsController.cs

@@ -40,6 +40,22 @@ namespace API.Controllers
             return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria));
         }
         
+        [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;
+            if (nbParagraph == 0)
+            {
+                _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}")]
         [ProducesResponseType(typeof(ParagraphDto), 200)]
         [ProducesResponseType(typeof(string), 404)]

API_SQLuedo/API/Controllers/SolutionController.cs

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

API_SQLuedo/API/Program.cs

@@ -28,6 +28,12 @@ builder.Services.AddScoped<IBlackListService<BlackListDto>, BlackListDataService
 builder.Services.AddScoped<IInquiryService<InquiryEntity>, InquiryDataService>();
 builder.Services.AddScoped<IInquiryService<InquiryDto>, InquiryDataServiceApi>();
 
+builder.Services.AddScoped<ISolutionService<SolutionEntity>, SolutionDataService>();
+builder.Services.AddScoped<ISolutionService<SolutionDto>, SolutionDataServiceAPI>();
+
+builder.Services.AddScoped<IInquiryTableService<InquiryTableEntity>, InquiryTableDataService>();
+builder.Services.AddScoped<IInquiryTableService<InquiryTableDto>, InquiryTableDataServiceAPI>();
+
 builder.Services.AddScoped<IParagraphService<ParagraphEntity>, ParagraphDataService>();
 builder.Services.AddScoped<IParagraphService<ParagraphDto>, ParagraphDataServiceApi>();
 
@@ -37,6 +43,9 @@ builder.Services.AddScoped<ISuccessService<SuccessDto>, SuccessDataServiceApi>()
 builder.Services.AddScoped<ILessonService<LessonEntity>, LessonDataService>();
 builder.Services.AddScoped<ILessonService<LessonDto>, LessonDataServiceApi>();
 
+builder.Services.AddScoped<INotepadService<NotepadEntity>, NotepadDataService>();
+builder.Services.AddScoped<INotepadService<NotepadDto>, NotepadDataServiceAPI>();
+
 builder.Services.AddDbContext<DbContext, UserDbContext>();
 builder.Services.AddDbContext<WebAPIDbContext>(options => options.UseInMemoryDatabase("appDb"));
 builder.Services.AddIdentityApiEndpoints<IdentityUser>().AddEntityFrameworkStores<WebAPIDbContext>();

API_SQLuedo/API/Service/InquiryTableDataServiceAPI.cs

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

API_SQLuedo/API/Service/LessonDataServiceAPI.cs

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

API_SQLuedo/API/Service/NotepadDataServiceAPI.cs

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

API_SQLuedo/API/Service/ParagraphDataServiceAPI.cs

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

API_SQLuedo/API/Service/SolutionDataServiceAPI.cs

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

API_SQLuedo/DbDataManager/Service/InquiryTableDataService.cs

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

API_SQLuedo/DbDataManager/Service/LessonDataService.cs

@@ -51,6 +51,11 @@ public class LessonDataService : ILessonService<LessonEntity>
         return lessons;
     }
 
+    public int GetNumberOfLessons()
+    {
+        return DbContext.Lessons.Count();
+    }
+
     public LessonEntity GetLessonById(int id)
     {
         var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);

API_SQLuedo/DbDataManager/Service/NotepadDataService.cs

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

API_SQLuedo/DbDataManager/Service/ParagraphDataService.cs

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

API_SQLuedo/DbDataManager/Service/SolutionDataService.cs

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

API_SQLuedo/Shared/IInquiryTableService.cs

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

API_SQLuedo/Shared/ILessonService.cs

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

API_SQLuedo/Shared/INotepadService.cs

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

API_SQLuedo/Shared/IParagraphService.cs

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

API_SQLuedo/Shared/ISolutionService.cs

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

API_SQLuedo/StubbedContextLib/StubbedContext.cs

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