route character

WF_EF_Api/Contextlib/DbCharacterManager.cs

@@ -2,6 +2,7 @@
 using Microsoft.EntityFrameworkCore;
 using Shared;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -13,11 +14,13 @@ namespace Contextlib
     {
         private WTFContext _context;
         private GenericRepository<Character> _repo;
+        private DbImagesManager _dbI;
 
         public DbCharacterManager(WTFContext context)
         {
             _context = context ?? throw new ArgumentNullException(nameof(context), "Database context cannot be null.");
             _repo = new GenericRepository<Character>(_context);
+            _dbI = new DbImagesManager(context);
         }
 
         /// <summary>
@@ -32,6 +35,12 @@ namespace Contextlib
             {
                 throw new ArgumentNullException(nameof(character), "character cannot be null.");
             }
+            var image = await _dbI.GetImageByPath(character.Images.ImgPath);
+            if (image != null)
+            {
+                character.IdImage = image.Id;
+                character.Images = image;
+            }
             _repo.Insert(character);
             await _context.SaveChangesAsync();
         }
@@ -93,6 +102,12 @@ namespace Contextlib
             return lastCharId;
         }
 
+        public async Task<PaginationResult<Character>> GetSomeChar(int page, int count)
+        {
+            var charLst = _repo.GetItems(page, count, [nameof(Character.Images)]).ToList();
+            return new PaginationResult<Character>(charLst.Count, 0, charLst.Count, charLst);
+        }
+
         /// <summary>
         /// Removes a character from the database by its ID.
         /// </summary>
@@ -119,9 +134,11 @@ namespace Contextlib
             if (charac != null)
             {
                 bool change = false;
-                if (character.IdImage != 0)
+                var image = await _dbI.GetImageByPath(character.Images.ImgPath);
+                if (image != null)
                 {
-                    charac.IdImage = character.IdImage;
+                    charac.IdImage = image.Id;
+                    charac.Images = image;
                     change = true;
                 }
                 if (character.Name != null)

WF_EF_Api/Dto2Entities/Extention.cs

@@ -261,6 +261,7 @@ namespace Dto2Entities
             Character character = new Character();
             character.Id = item.Id;
             character.Name = item.Name;
+            character.Images = new Images();
             character.Images.ImgPath = item.imagePath ;
             return character;
         }

WF_EF_Api/ServicesApi/CharacterService.cs

@@ -33,7 +33,7 @@ namespace ServicesApi
 
         public async Task<CharacterDTO> GetCharById(int id)
         {
-            return characterService.GetCharById(id).Result.ToDto();
+            return (await characterService.GetCharById(id)).ToDto();
         }
 
         public async Task<CharacterDTO> GetCharByName(string name)
@@ -46,6 +46,12 @@ namespace ServicesApi
             return await characterService.GetLastCharId();
         }
 
+        public async Task<PaginationResult<CharacterDTO>> GetSomeChar(int page, int count)
+        {
+            var characters = (await characterService.GetSomeChar(page, count)).items;
+            return new PaginationResult<CharacterDTO>(characters.Count(), page, count, characters.ToDto());
+        }
+
         public async Task RemoveCharacter(int id)
         {
             await characterService.RemoveCharacter(id);

WF_EF_Api/Shared/ICharacterService.cs

@@ -35,5 +35,7 @@ namespace Shared
 
         // Retrieves the unique identifier of the last added character.
         Task<int> GetLastCharId();
+
+        Task<PaginationResult<TChar>> GetSomeChar(int page, int count);
     }
 }

WF_EF_Api/WfApi/Controllers/CharacterController.cs

@@ -0,0 +1,128 @@
+using System.Net;
+using DTO;
+using Entity;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Shared;
+
+namespace WfApi.Controllers
+{
+    [ApiController]
+    [Route("api/v1/character")] //Version API
+    public class CharacterController : ControllerBase
+    {
+        private readonly ICharacterService<CharacterDTO> _character;
+
+        private readonly ILogger<CharacterController> _logger;
+
+        public CharacterController(ICharacterService<CharacterDTO> characterService, ILogger<CharacterController> logger)
+        {
+            _character = characterService;
+            _logger = logger;
+
+        }
+
+        [HttpGet("{id}")] // Indiquer que l'id est dans l'URL
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public async Task<IActionResult> GetCharacter(int id)
+        {
+            try
+            {
+                try
+                {
+                    var character = await _character.GetCharById(id);
+                    return Ok(character);
+                }
+                catch(KeyNotFoundException e)
+                {
+                    return NotFound();
+                }
+            }
+            catch (Exception e)
+            {
+                return StatusCode((int)HttpStatusCode.InternalServerError, new { message = "Internal Server Error (" + e + ")" });
+            }
+        }
+
+        [HttpGet("all")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetAllSource(int index = 0, int count = 10)
+        {
+            try
+            {
+                var result = await _character.GetSomeChar(index, count);
+
+                if (result != null)
+                {
+                    return await Task.FromResult<IActionResult>(Ok(result));
+                }
+                else
+                {
+                    return NoContent();
+                }
+            }
+            catch (Exception e)
+            {
+                return StatusCode((int)HttpStatusCode.InternalServerError, new { message = "Internal Server Error (" + e + ")" });
+            }
+        }
+
+        [HttpPost]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        public async Task<IActionResult> CreateCharacter([FromBody] CharacterDTO newCharacter)
+        {
+            try
+            {
+                if (newCharacter == null)
+                {
+                    return BadRequest(new { message = "Source data is required." });
+                }
+                try
+                {
+                    var existingSource = await _character.GetCharById(newCharacter.Id);
+                    return Conflict(new { message = "A source with this ID already exists." });
+                }
+                catch (KeyNotFoundException e)
+                {
+                    await _character.AddCharacter(newCharacter);
+                    return CreatedAtAction(nameof(GetAllSource), new { id = newCharacter.Id }, newCharacter);
+                }
+            }
+            catch (Exception e)
+            {
+                return StatusCode((int)HttpStatusCode.InternalServerError, new { message = "Internal Server Error (" + e + ")" });
+            }
+        }
+
+        [HttpPut()]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> UpdateCharacter([FromQuery] int id, [FromBody] CharacterDTO updatedCharacter)
+        {
+            try
+            {
+                if (updatedCharacter == null)
+                {
+                    return BadRequest(new { message = "new source data is required." });
+                }
+
+                var result = _character.UpdateCharacter(id, updatedCharacter);
+
+                return Ok(result);
+            }
+            catch (Exception e)
+            {
+                return StatusCode((int)HttpStatusCode.InternalServerError, new { message = "Internal Server Error (" + e + ")" });
+            }
+        }
+    }
+}