add ArticleUser

Verax_API_EF/Verax_API_EF/API/API.csproj

@@ -21,6 +21,7 @@
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
+        <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="8.0.1" />
         <PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0"/>
     </ItemGroup>
 

Verax_API_EF/Verax_API_EF/API/Controllers/ArticleController.cs

@@ -12,14 +12,19 @@ namespace API.Controllers
     {
         
         private readonly IArticleService _articleService;
+        private readonly ILogger<ArticleController> _logger;
         
-        public ArticleController(IArticleService articleService)
+        public ArticleController(IArticleService articleService, ILogger<ArticleController> logger)
         {
-            _articleService = articleService;
+            this._articleService = articleService;
+            this._logger = logger;
         }
         
         [HttpGet]
         public async Task<IActionResult> GetAllArticles([FromQuery] int index = 0, [FromQuery] int count = 10, [FromQuery] ArticleOrderCriteria orderCriterium = ArticleOrderCriteria.None)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(GetAllArticles), index, count, orderCriterium);
+            try 
             {
                 var result = (await _articleService.GetAllArticles(index, count, orderCriterium)).Select(a => a.ToDTO());
                 if (result == null)
@@ -28,36 +33,93 @@ namespace API.Controllers
                 }
                 return Ok(result);
             }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
         
         [HttpGet("/article/{id}")]
-        public async Task<Article?> GetArticleById(int id, [FromQuery] int index = 0, [FromQuery] int count = 10, [FromQuery] ArticleOrderCriteria orderCriterium = ArticleOrderCriteria.None)
+        public async Task<IActionResult> GetArticleById(int id)
         {
-            var result =  await _articleService.GetArticleById(id, index, count, orderCriterium);
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(GetArticleById), id);
+            try 
+            {
+                var result = (await _articleService.GetArticleById(id)).ToDTO();
                 if (result == null)
                 {
-                return null;
+                    return NotFound($"Article ID {id} not found");
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
             }
-            return result;
         }
         
         
         
         [HttpPost("/article")]
-        public async Task<Article?> CreateArticle(Article article)
+        public async Task<IActionResult> CreateArticle(Article article)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(CreateArticle), article);
+            try 
+            {
+                var result = (await _articleService.CreateArticle(article)).ToDTO();
+                if (result == null)
+                {
+                    return BadRequest($"Article not created");
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
             {
-            return await _articleService.CreateArticle(article);
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
 
         [HttpDelete("/article/{id}")]
-        public async Task<Article?> DeleteArticle(long id)
+        public async Task<IActionResult> DeleteArticle(long id)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(DeleteArticle), id);
+            try 
+            {
+                var result = await _articleService.DeleteArticle(id);
+                if (result == null)
                 {
-            return await _articleService.DeleteArticle(id);
+                    return NotFound($"Article ID {id} not found");
+                }
+                return Ok(result.ToDTO());
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
     
         [HttpPut("/article/{id}")]
-        public async Task<bool> UpdateArticle(long id, Article? a)
+        public async Task<IActionResult> UpdateArticle(long id, Article? a)
         {
-            return await _articleService.UpdateArticle(id, a); 
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(UpdateArticle), id, a);
+            try 
+            {
+                var result = await _articleService.UpdateArticle(id, a);
+                if (result == false)
+                {
+                    return NotFound($"Article ID {id} not found");
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
         
         

Verax_API_EF/Verax_API_EF/API/Controllers/ArticleUserController.cs

@@ -0,0 +1,121 @@
+using API_Services;
+using Entities;
+using Microsoft.AspNetCore.Mvc;
+
+namespace API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class ArticleUserController : ControllerBase
+{
+    
+    private readonly IArticleUserService _us;
+    private readonly ILogger<ArticleUserController> _logger;
+    public ArticleUserController(IArticleUserService us, ILogger<ArticleUserController> logger)
+    {
+        this._us = us;
+        this._logger = logger;
+    }
+    
+    
+    [HttpGet("/articleUsers")]
+    public async Task<IActionResult> GetAllArticleUsers()
+    {
+        _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(GetAllArticleUsers), "");
+        try
+        {
+            var result =  await _us.GetAllArticleUsers();
+            if (result == null)
+            {
+                return NoContent();
+            }
+            return Ok(result);
+        }
+        catch (Exception error)
+        {
+            _logger.LogError(error.Message);
+            return BadRequest(error.Message);
+        }
+    }
+         
+    [HttpGet("/user/{pseudo}/article")]
+    public async Task<IActionResult> GetArticleUser(string pseudo)
+    {
+        _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(GetArticleUser), pseudo);
+        try
+        {
+            var result =  await _us.GetArticleUser(pseudo);
+            if (result == null)
+            {
+                return NoContent();
+            }
+            return Ok(result);
+        }
+        catch (Exception error)
+        {
+            _logger.LogError(error.Message);
+            return BadRequest(error.Message);
+        }
+    }
+    
+    [HttpPost("/user/{pseudo}/article")]
+    public async Task<IActionResult> CreateArticleUser(ArticleUserEntity articleUser)
+    {
+        _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(CreateArticleUser), articleUser);
+        try
+        {
+            var result = await _us.CreateArticleUser(articleUser);
+            if (result == null)
+            {
+                return BadRequest($"ArticleUser {articleUser.UserEntityPseudo} already exists");
+            }
+            return Ok(result);
+        }
+        catch (Exception error)
+        {
+            _logger.LogError(error.Message);
+            return BadRequest(error.Message);
+        }
+    }
+    
+    [HttpDelete("/user/{pseudo}/article")]
+    public async Task<IActionResult> DeleteArticleUser(string pseudo)
+    {
+        _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(DeleteArticleUser), pseudo);
+        try
+        {
+            var result = await _us.DeleteArticleUser(pseudo);
+            if (!result)
+            {
+                return BadRequest($"ArticleUser {pseudo} does not exist");
+            }
+            return Ok(result);
+        }
+        catch (Exception error)
+        {
+            _logger.LogError(error.Message);
+            return BadRequest(error.Message);
+        }
+    }
+    
+    [HttpPut("/user/{pseudo}/article")]
+    public async Task<IActionResult> UpdateArticleUser(ArticleUserEntity articleUser)
+    {
+        _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(UpdateArticleUser), articleUser);
+        try
+        {
+            var result = await _us.UpdateArticleUser(articleUser);
+            if (!result)
+            {
+                return BadRequest($"ArticleUser {articleUser.UserEntityPseudo} does not exist");
+            }
+            return Ok(result);
+        }
+        catch (Exception error)
+        {
+            _logger.LogError(error.Message);
+            return BadRequest(error.Message);
+        }
+    }
+        
+}

Verax_API_EF/Verax_API_EF/API/Controllers/FormulaireController.cs

@@ -13,50 +13,116 @@ namespace API.Controllers
     public class FormulaireController : ControllerBase
     {
         private readonly IFormulaireService _form;
+        private readonly ILogger<FormulaireController> _logger;
 
-        public FormulaireController(IFormulaireService iform)
+        public FormulaireController(IFormulaireService iform, ILogger<FormulaireController> logger)
         {
             this._form = iform;
+            this._logger = logger;
         }
 
-        [HttpGet("/forms")]
+        [HttpGet("/formulaires")]
         public async Task<IActionResult> GetAllForm([FromQuery] int index = 0, [FromQuery] int count = 10, [FromQuery] FormOrderCriteria orderCriteria = FormOrderCriteria.None)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(GetAllForm), index, count, orderCriteria);
+            try
             {
                 var result = (await _form.GetAllForm(index, count, orderCriteria)).Select(f => f.ToDTO());
                 if (result == null)
                 {
-                return NotFound();
+                    return NotFound($"No form found");
                 }
                 return Ok(result);
             }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+            
+        }
         
-        [HttpGet("{id}")]
+        [HttpGet("/formulaire/{id}")]
         public async Task<IActionResult> GetById(long id)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(GetById), id);
+            try
             {
                 var result = (await _form.GetById(id)).ToDTO();
                 if (result == null)
                 {
-                return NotFound();
+                    return NotFound($"form ID {id} not found");
                 }
                 return Ok(result);
             }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+           
             
-        [HttpPost]
-        public async Task<Formulaire?> CreateForm(Formulaire formulaire)
+        }
+        
+        [HttpPost ("/formulaire")]
+        public async Task<IActionResult> CreateForm(Formulaire formulaire)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(CreateForm), formulaire);
+            try
+            {
+                var result = (await _form.CreateForm(formulaire)).ToDTO();
+                if (result == null)
+                {
+                    return BadRequest($"Form Id {formulaire.Id} already exists");
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
             {
-            return await _form.CreateForm(formulaire);
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
         
-        [HttpDelete("{id}")]
-        public async Task<bool> DeleteForm(long id)
+        [HttpDelete("/formulaire/{id}")]
+        public async Task<IActionResult> DeleteForm(long id)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(DeleteForm), id);
+            try
             {
-            return await _form.DeleteForm(id);
+                var result =  await _form.DeleteForm(id);
+                if (result == false)
+                {
+                    return NotFound($"Form Id {id} not found");
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
         
-        [HttpPut("{id}")]
-        public async Task<bool> UpdateForm(long id, Formulaire formulaire)
+        [HttpPut("/formulaire/{id}")]
+        public async Task<IActionResult> UpdateForm(long id, Formulaire formulaire)
         {
-            return await _form.UpdateForm(id, formulaire);
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(UpdateForm), formulaire);
+
+            try
+            {
+                var result = await _form.UpdateForm(id, formulaire);
+                if (result == false)
+                {
+                    return NotFound($"form Id {id} not found");
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
     }
 }

Verax_API_EF/Verax_API_EF/API/Controllers/UserController.cs

@@ -3,6 +3,7 @@ using Microsoft.AspNetCore.Mvc;
 using API_Services;
 using Model;
 using API_Mapping;
+using Entities;
 
 
 namespace API.Controllers
@@ -12,51 +13,115 @@ namespace API.Controllers
     public class UserController : ControllerBase
     {
         private readonly IUserService _us;
-
-        public UserController(IUserService us)
+        private readonly ILogger<UserController> _logger;
+        public UserController(IUserService us, ILogger<UserController> logger)
         {
             this._us = us;
+            this._logger = logger;
         }
         
         [HttpGet("/users")]
         public async Task<IActionResult> GetAll([FromQuery] int index = 0, [FromQuery] int count = 10, [FromQuery] UserOrderCriteria orderCriteria = UserOrderCriteria.None)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(GetAll), index, count, orderCriteria);
+            try
             {
                 var result = (await _us.GetAll(index, count, orderCriteria)).Select(u => u.ToDTO());
                 if (result == null)
                 {
-                return NotFound();
+                    return NotFound($"No user found with the given parameters");
                 }
                 return Ok(result);
             }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
         
         [HttpGet("/user/{pseudo}")]
         public async Task<IActionResult> GetByPseudo(string pseudo)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(GetByPseudo), pseudo);
+            try
             {
                 var result = (await _us.GetByPseudo(pseudo)).ToDTO();
                 if (result == null)
                 {
-                return NotFound();
+                    return NotFound($"Psuedo {pseudo} not found");
                 }
                 return Ok(result);
             }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+            
+        }
         
         [HttpPost("/user")]
-        public async Task<bool> Create(User user)
+        public async Task<IActionResult> Create(User user)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(Create), user);
+            try
             {
-            return await _us.Create(user);
+                var result = await _us.Create(user);
+                if (result == false)
+                {
+                    return BadRequest($"User {user.Pseudo} already exists");
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+            
         }
         
         
         [HttpPut("/user/{pseudo}")]
-        public async Task<bool> Update(User user, string pseudo)
+        public async Task<IActionResult> Update(User user, string pseudo)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(Update), user, pseudo);
+            try
+            {
+                var result = await _us.Update(user,pseudo);
+                if (result == false)
                 {
-            return await _us.Update(user,pseudo);
+                    return NotFound();
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+            
         }
         
         [HttpDelete("/user/{pseudo}")]
-        public async Task<bool> Delete(string pseudo)
+        public async Task<IActionResult> Delete(string pseudo)
+        {
+            _logger.LogInformation("Executing {Action} - with parameters: {Parameters}",nameof(Delete), pseudo);
+            try
+            {
+                var result = await _us.Delete(pseudo);
+                if (result == false)
                 {
-            return await _us.Delete(pseudo);
+                    return NotFound();
+                }
+                return Ok(result);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
    
         

Verax_API_EF/Verax_API_EF/API/Program.cs

@@ -23,6 +23,7 @@ builder.Services.AddDbContext<LibraryContext>(options =>
 builder.Services.AddScoped<IArticleService, DbManagerArticle>();
 builder.Services.AddScoped<IUserService, DbManagerUser>();
 builder.Services.AddScoped<IFormulaireService, DbManagerFormulaire>();
+builder.Services.AddScoped<IArticleUserService, DbManagerArticleUser>();
 
 var app = builder.Build();
 

Verax_API_EF/Verax_API_EF/API_DbDataManager/DbManagerArticle.cs

@@ -45,34 +45,11 @@ public class DbManagerArticle : IArticleService
         return await Task.FromResult(articles.AsEnumerable());
     }
     
-    public Task<Article?> GetArticleById(int id, int index, int count, ArticleOrderCriteria orderCriterium)
+    public Task<Article?> GetArticleById(int id)
     {
-        List<Article> articles = new List<Article>();
-        switch (orderCriterium)
-        {
-            case ArticleOrderCriteria.None:
-                articles = _context.ArticleSet.Where(a => a.Id == id).Select(a => a.ToModel()).ToList();
-                break;
-            case ArticleOrderCriteria.ByLectureTime:
-                articles = _context.ArticleSet.Where(a => a.Id == id).OrderBy(a => a.LectureTime).Select(a => a.ToModel()).ToList();
-                break;
-            case ArticleOrderCriteria.ByTitle:
-                articles = _context.ArticleSet.Where(a => a.Id == id).OrderBy(a => a.Title).Select(a => a.ToModel()).ToList();
-                break;
-            case ArticleOrderCriteria.ByAuthor:
-                articles = _context.ArticleSet.Where(a => a.Id == id).OrderBy(a => a.Author).Select(a => a.ToModel()).ToList();
-                break;
-            case ArticleOrderCriteria.ByDatePublished:
-                articles = _context.ArticleSet.Where(a => a.Id == id).OrderBy(a => a.DatePublished).Select(a => a.ToModel()).ToList();
-                break;
-            case ArticleOrderCriteria.ByDescription:
-                articles = _context.ArticleSet.Where(a => a.Id == id).OrderBy(a => a.Description).Select(a => a.ToModel()).ToList();
-                break;
-            default:
-                articles = _context.ArticleSet.Where(a => a.Id == id).Select(a => a.ToModel()).ToList();
-                break;
-        }
-        return Task.FromResult(articles.FirstOrDefault());
+        var entity = _context.ArticleSet.FirstOrDefault(a => a.Id == id);
+        if (entity == null) return Task.FromResult<Article?>(null);
+        return Task.FromResult(entity.ToModel());
     }
 
     
@@ -80,6 +57,7 @@ public class DbManagerArticle : IArticleService
     {
         var entity = new Entities.ArticleEntity()
         {
+            Id = article.Id,
             Title = article.Title,
             Description = article.Description,
             Author = article.Author,

Verax_API_EF/Verax_API_EF/API_DbDataManager/DbManagerArticleUser.cs

@@ -0,0 +1,67 @@
+using API_Services;
+using DbContextLib;
+using Entities;
+using Model;
+
+namespace DbDataManager;
+
+public class DbManagerArticleUser : IArticleUserService
+{
+    private readonly LibraryContext _context;
+    
+    public DbManagerArticleUser(LibraryContext context)
+    {
+        _context = context;
+    }
+    
+    public async Task<IEnumerable<ArticleUserEntity?>> GetAllArticleUsers()
+    {
+        var entities = _context.ArticleUserSet.ToList();
+        if (entities == null) return await Task.FromResult<IEnumerable<ArticleUserEntity?>>(null);
+        return await Task.FromResult(entities.AsEnumerable());
+    }
+
+    public async Task<ArticleUserEntity?> GetArticleUser(string pseudo)
+    {
+        var entity = _context.ArticleUserSet.FirstOrDefault(a => a.UserEntityPseudo.Equals(pseudo));
+        if (entity == null) return await Task.FromResult<ArticleUserEntity?>(null);
+        return await Task.FromResult(entity);
+    }
+    
+    
+    public async Task<ArticleUserEntity?> CreateArticleUser(ArticleUserEntity articleUser)
+    {
+        var result = await GetArticleUser(articleUser.UserEntityPseudo);
+        if (result != null) return await Task.FromResult<ArticleUserEntity?>(null);
+        var entity = new ArticleUserEntity()
+        {
+            ArticleEntityId = articleUser.ArticleEntityId,
+            UserEntityPseudo = articleUser.UserEntityPseudo
+        };
+        if (entity == null) return await Task.FromResult<ArticleUserEntity?>(null);
+        _context.ArticleUserSet.Add(entity);
+        await _context.SaveChangesAsync();
+        return await Task.FromResult(entity);
+    }
+    
+    public async Task<bool> DeleteArticleUser(string pseudo)
+    {
+        var entity = _context.ArticleUserSet.FirstOrDefault(a => a.UserEntityPseudo.Equals(pseudo));
+        if (entity == null) return await Task.FromResult(false);
+        _context.ArticleUserSet.Remove(entity);
+        await _context.SaveChangesAsync();
+        return await Task.FromResult(true);
+    }
+    
+    public async Task<bool> UpdateArticleUser(ArticleUserEntity articleUser)
+    {
+        var entity = _context.ArticleUserSet.FirstOrDefault(a => a.UserEntityPseudo.Equals(articleUser.UserEntityPseudo));
+        if (entity == null) return await Task.FromResult(false);
+        entity.ArticleEntityId = articleUser.ArticleEntityId;
+        entity.UserEntityPseudo = articleUser.UserEntityPseudo;
+        await _context.SaveChangesAsync();
+        return await Task.FromResult(true);
+    }
+
+    
+}

Verax_API_EF/Verax_API_EF/API_DbDataManager/DbManagerFormulaire.cs

@@ -21,22 +21,22 @@ public class DbManagerFormulaire : IFormulaireService
         switch (orderCriteria)
         {
             case FormOrderCriteria.None:
-                formulaireList = _context.FormSet.Select(f => f.ToModel()).ToList();
+                formulaireList = _context.FormSet.Skip(index * count).Select(f => f.ToModel()).ToList();
                 break;
             case FormOrderCriteria.ByTheme:
-                formulaireList = _context.FormSet.OrderBy(f => f.Theme).Select(f => f.ToModel()).ToList();
+                formulaireList = _context.FormSet.Skip(index * count).OrderBy(f => f.Theme).Select(f => f.ToModel()).ToList();
                 break;
             case FormOrderCriteria.ByLien:
-                formulaireList = _context.FormSet.OrderBy(f => f.Link).Select(f => f.ToModel()).ToList();
+                formulaireList = _context.FormSet.Skip(index * count).OrderBy(f => f.Link).Select(f => f.ToModel()).ToList();
                 break;
             case FormOrderCriteria.ByDate:
-                formulaireList = _context.FormSet.OrderBy(f => f.DatePublication).Select(f => f.ToModel()).ToList();
+                formulaireList = _context.FormSet.Skip(index * count).OrderBy(f => f.DatePublication).Select(f => f.ToModel()).ToList();
                 break;
             case FormOrderCriteria.ByPseudo:
-                formulaireList = _context.FormSet.OrderBy(f => f.UserEntityPseudo).Select(f => f.ToModel()).ToList();
+                formulaireList = _context.FormSet.Skip(index * count).OrderBy(f => f.UserEntityPseudo).Select(f => f.ToModel()).ToList();
                 break;
             default:
-                formulaireList = _context.FormSet.Select(f => f.ToModel()).ToList();
+                formulaireList = _context.FormSet.Skip(index * count).Select(f => f.ToModel()).ToList();
                 break;
         }
         return await Task.FromResult(formulaireList.AsEnumerable());

Verax_API_EF/Verax_API_EF/API_DbDataManager/DbManagerUser.cs

@@ -15,6 +15,35 @@ public class DbManagerUser: IUserService
         _context = context;
     }
     
+    public async Task<IEnumerable<User?>> GetAll(int index, int count, UserOrderCriteria orderCriteria)
+    {
+        List<User> users = new List<User>();
+        switch(orderCriteria)
+        {
+            case UserOrderCriteria.None:
+                users = _context.UserSet.Skip(index * count).Select(u => u.ToModel()).ToList();
+                break;
+            case UserOrderCriteria.ByFirstName:
+                users = _context.UserSet.Skip(index * count).OrderBy(u => u.Prenom).Select(u => u.ToModel()).ToList();
+                break;
+            case UserOrderCriteria.ByLastName:
+                users = _context.UserSet.Skip(index * count).OrderBy(u => u.Nom).Select(u => u.ToModel()).ToList();
+                break;
+            default:
+                users = _context.UserSet.Skip(index * count).Select(u => u.ToModel()).ToList();
+                break;
+
+        }
+        return await Task.FromResult(users.AsEnumerable());
+
+    }
+    
+    public async Task<User?> GetByPseudo(string pseudo)
+    {
+        var entity = _context.UserSet.FirstOrDefault(u => u.Pseudo == pseudo);
+        return await Task.FromResult(entity.ToModel());
+    }
+    
     public async Task<bool> Create(User user)
     {
         var entity = new UserEntity()
@@ -51,35 +80,10 @@ public class DbManagerUser: IUserService
         _context.UserSet.Remove(entity);
         await _context.SaveChangesAsync();
         return await Task.FromResult(true);
-        
     }
     
-    public async Task<User?> GetByPseudo(string pseudo)
-    {
-        var entity = _context.UserSet.FirstOrDefault(u => u.Pseudo == pseudo);
-        return await Task.FromResult(entity.ToModel());
-    }
     
-    public async Task<IEnumerable<User?>> GetAll(int index, int count, UserOrderCriteria orderCriteria)
-    {
-        List<User> users = new List<User>();
-        switch(orderCriteria)
-        {
-            case UserOrderCriteria.None:
-                users = _context.UserSet.Select(u => u.ToModel()).ToList();
-                break;
-            case UserOrderCriteria.ByFirstName:
-                users = _context.UserSet.OrderBy(u => u.Prenom).Select(u => u.ToModel()).ToList();
-                break;
-            case UserOrderCriteria.ByLastName:
-                users = _context.UserSet.OrderBy(u => u.Nom).Select(u => u.ToModel()).ToList();
-                break;
-            default:
-                users = _context.UserSet.Select(u => u.ToModel()).ToList();
-                break;
     
-        }
-        return await Task.FromResult(users.AsEnumerable());
     
-    }
+   
 }

Verax_API_EF/Verax_API_EF/API_Mapping/ArticleMapper.cs

@@ -5,7 +5,7 @@ namespace API_Mapping;
 
 public static class ArticleMapper
 {
-    public static ArticleDTO ToDTO(this Article a) => new()
+    public static ArticleDTO ToDTO(this Article? a) => new()
     {
         Id = a.Id,
         Title = a.Title,

Verax_API_EF/Verax_API_EF/API_Services/API_Services.csproj

@@ -7,6 +7,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+      <ProjectReference Include="..\Entities\Entities.csproj" />
       <ProjectReference Include="..\Model\Model.csproj" />
     </ItemGroup>
 

Verax_API_EF/Verax_API_EF/API_Services/IArticleService.cs

@@ -7,7 +7,7 @@ namespace API_Services
         
         Task<IEnumerable<Article?>> GetAllArticles(int index, int count, ArticleOrderCriteria orderCriterium);
         
-        Task<Article?> GetArticleById(int id, int index, int count, ArticleOrderCriteria orderCriterium);
+        Task<Article?> GetArticleById(int id);
 
 
         Task<Article?> CreateArticle(Article article);

Verax_API_EF/Verax_API_EF/API_Services/IArticleUserService.cs

@@ -0,0 +1,15 @@
+using Entities;
+
+namespace API_Services;
+
+public interface IArticleUserService
+{
+    Task<IEnumerable<ArticleUserEntity>> GetAllArticleUsers();
+    Task<ArticleUserEntity?> GetArticleUser(string pseudo);
+        
+    Task<ArticleUserEntity?> CreateArticleUser(ArticleUserEntity articleUser);
+    
+    Task<bool> DeleteArticleUser(string pseudo);
+    
+    Task<bool> UpdateArticleUser(ArticleUserEntity articleUser);
+}

Verax_API_EF/Verax_API_EF/API_Services/IUserService.cs

@@ -1,18 +1,20 @@
-using Model;
+using Entities;
+using Model;
 
 namespace API_Services
 {
     public interface IUserService
     {
+        
+        Task<IEnumerable<User?>> GetAll(int index, int count, UserOrderCriteria orderCriteria);
+        Task<User?> GetByPseudo(string pseudo);
         Task<bool> Create(User user);
         Task<bool> Update(User user, string pseudo);
 
         Task<bool> Delete(string pseudo);
 
  
-        Task<User?> GetByPseudo(string pseudo);
 
-        Task<IEnumerable<User?>> GetAll(int index, int count, UserOrderCriteria orderCriteria);
 
 
 

Verax_API_EF/Verax_API_EF/Entities/ArticleEntity.cs

@@ -1,7 +1,10 @@
+using System.ComponentModel.DataAnnotations;
+
 namespace Entities;
 
 public class ArticleEntity
 {
+    [Key]
     public long Id { get; set; }
     public string Title { get; set; } = string.Empty;
     public string Description { get; set; } = string.Empty;

Verax_API_EF/Verax_API_EF/Entities/FormEntity.cs

@@ -1,7 +1,10 @@
+using System.ComponentModel.DataAnnotations;
+
 namespace Entities;
 
 public class FormEntity
 {
+    [Key]
     public long Id { get; set; }
     public string Theme { get; set; } = string.Empty;
     public string DatePublication { get; set; } = string.Empty;

Verax_API_EF/Verax_API_EF/Model/Article.cs

@@ -2,7 +2,7 @@ namespace Model;
 
 public class Article
 {
-    public long Id { get; set; }
+    public long Id;
     public string Title { get; set; } = string.Empty;
     public string Description { get; set; } = string.Empty;
     public string DatePublished { get; set; } = string.Empty;