Dictionary for ChampionDto done and beginning the RunePageController 🙈

src/EntityFramework_LoL/Sources/ApiLol/Controllers/RunePagesController.cs

@@ -0,0 +1,122 @@
+using ApiLol.Mapper;
+using DTO;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.IdentityModel.Tokens;
+using Model;
+
+// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
+
+namespace ApiLol.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class RunePagesController : ControllerBase
+    {
+        private readonly IDataManager _manager;
+        private readonly ILogger<RunePagesController> _logger;
+
+        public RunePagesController(IDataManager dataManager, ILogger<RunePagesController> logger)
+        {
+            _manager = dataManager;
+            _logger = logger;
+        }
+
+
+
+        // GET: api/<RunePagesController>
+        [HttpGet]
+        public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
+        {
+            _logger.LogInformation("Executing {Action} - RUNEPAGE with parameters: {Parameters}", nameof(Get), pageRequest);
+            try
+            {
+                int nbTotal = await _manager.RunePagesMgr.GetNbItems();
+                if (pageRequest.count == 0)
+                {
+                    pageRequest = new PageRequest() { index = 0, count = nbTotal, orderingPropertyName = pageRequest.orderingPropertyName, descending = pageRequest.descending, name = pageRequest.name };
+                }
+                else if (pageRequest.count * pageRequest.index >= nbTotal || pageRequest.count > nbTotal)
+                {
+                    _logger.LogWarning("too many, maximum {number}", nbTotal);
+                    return BadRequest($"RunePage limit exceed, max {nbTotal}");
+                }
+
+                IEnumerable<RunePageDto> dtos;
+                if (pageRequest.name == null)
+                {
+                    dtos = (await _manager.RunePagesMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                        .Select(x => x.ToDto());
+                }
+                else
+                {
+                    dtos = (await _manager.RunePagesMgr.GetItemsByName(pageRequest.name, pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                        .Select(x => x.ToDto());
+                }
+                return Ok(new PageResponse<RunePageDto> { Data = dtos, index = pageRequest.index, count = pageRequest.count, total = nbTotal });
+
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // GET api/<RunePagesController>/5
+        [HttpGet("{name}")]
+        public async Task<IActionResult> Get(string name)
+        {
+            _logger.LogInformation("method {Action} - RUNEPAGE call with {name}", nameof(Get), name);
+            try
+            {
+                var dtos = (await _manager.RunePagesMgr.GetItemByName(name, 0, await _manager.RunePagesMgr.GetNbItems()))
+                    .Select(x => x.ToDto());
+                if (dtos.IsNullOrEmpty())
+                {
+                    _logger.LogWarning($"{name} was not found");
+                    return NotFound($"{name} was not found");
+                }
+                return Ok(dtos.First());
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // POST api/<RunePagesController>
+        [HttpPost]
+        public async Task<IActionResult> Post([FromBody] RunePageDto runePage)
+        {
+            _logger.LogInformation("method {Action} - RUNEPAGE call with {item}", nameof(Post), runePage);
+            try
+            {
+                if (await _manager.RunePagesMgr.GetNbItemsByName(runePage.Name) == 0)
+                {
+                    return CreatedAtAction(nameof(Get),
+                        (await _manager.RunePagesMgr.AddItem(runePage.ToModel())).ToDto());
+                }
+                _logger.LogWarning($"Name : {runePage.Name} is already exist");
+                return BadRequest($"Name : {runePage.Name} is already exist");
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // PUT api/<RunePagesController>/5
+        [HttpPut("{id}")]
+        public void Put(int id, [FromBody] string value)
+        {
+        }
+
+        // DELETE api/<RunePagesController>/5
+        [HttpDelete("{id}")]
+        public void Delete(int id)
+        {
+        }
+    }
+}

src/EntityFramework_LoL/Sources/ApiLol/Controllers/RunesController.cs

@@ -44,7 +44,7 @@ namespace ApiLol.Controllers
                 if (pageRequest.name == null)
                 {
                     dtos = (await _manager.RunesMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
-                    .Select(x => x.ToDto());
+                        .Select(x => x.ToDto());
                 }
                 else
                 {
@@ -160,8 +160,9 @@ namespace ApiLol.Controllers
         }
 
         [HttpGet("/countRunes")]
-        public async Task<ActionResult> GetCountSkins()
+        public async Task<ActionResult> GetCountRunes()
         {
+            _logger.LogInformation("method {Action} - RUNE call", nameof(GetCountRunes));
             try
             {
                 return Ok(await _manager.RunesMgr.GetNbItems());

src/EntityFramework_LoL/Sources/ApiLol/Controllers/SkinsController.cs

@@ -185,6 +185,7 @@ namespace ApiLol.Controllers
         [HttpGet("/countSkins")]
         public async Task<ActionResult> GetCountSkins()
         {
+            _logger.LogInformation("method {Action} - SKIN call", nameof(GetCountSkins));
             try
             {
                 return Ok(await _manager.SkinsMgr.GetNbItems());

src/EntityFramework_LoL/Sources/ApiLol/Controllers/v2/ChampionsController.cs

@@ -206,6 +206,7 @@ namespace ApiLol.Controllers.v2
         [HttpGet("/countChampions")]
         public async Task<ActionResult> GetCountChampions()
         {
+            _logger.LogInformation("method {Action} - CHAMPION - V2.0 call", nameof(GetCountChampions));
             try
             {
                 return Ok(await _manager.ChampionsMgr.GetNbItems());

src/EntityFramework_LoL/Sources/ApiLol/Mapper/ChampionMapper.cs

@@ -15,7 +15,9 @@ namespace ApiLol.Mapper
                 Icon = champion.Icon,
                 Image = champion.Image.ToDto(),
                 Skins = champion.Skins.Select(e => e.ToDto()),
-                Skills = champion.Skills.Select(e => e.ToDto())
+                Skills = champion.Skills.Select(e => e.ToDto()),
+                Characteristics = champion.Characteristics.ToDictionary(c => c.Key, c => c.Value)
+
             };
         }
 
@@ -26,11 +28,11 @@ namespace ApiLol.Mapper
             {
                 champ.AddSkin(skin.ToModel(champ));
             }
-
             foreach (var skill in championDto.Skills)
             {
                 champ.AddSkill(skill.ToModel());
             }
+            champ.AddCharacteristics(championDto.Characteristics.Select(c => Tuple.Create(c.Key, c.Value)).ToArray());
             return champ;
         }
 

src/EntityFramework_LoL/Sources/ApiLol/Mapper/RunePageMapper.cs

@@ -0,0 +1,31 @@
+using ApiLol.Mapper.enums;
+using DTO;
+using Model;
+
+namespace ApiLol.Mapper
+{
+    public static class RunePageMapper
+    {
+        public static RunePageDto ToDto(this RunePage runePage)
+        {
+
+            return new RunePageDto()
+            {
+                Name = runePage.Name,
+                Runes = runePage.Runes.ToDictionary(c => c.Key.ToDto(), r => r.Value.ToDto())
+            };
+        }
+
+        public static RunePage ToModel(this RunePageDto runePageDto)
+        {
+
+            var runePage = new RunePage(runePageDto.Name);
+            foreach( var rune in runePageDto.Runes)
+            {
+                runePage[rune.Key.ToModel()] = rune.Value.ToModel();
+            }
+
+            return runePage;
+        }
+    }
+}

src/EntityFramework_LoL/Sources/ApiLol/Mapper/enums/CategoryMapper.cs

@@ -0,0 +1,50 @@
+using DTO;
+using Model;
+
+namespace ApiLol.Mapper.enums
+{
+    public static class CategoryMapper
+    {
+        public static RunePageDto.CategoryDto ToDto(this RunePage.Category category)
+        {
+            switch (category)
+            {
+                case RunePage.Category.Major:
+                    return RunePageDto.CategoryDto.Major;
+                case RunePage.Category.Minor1:
+                    return RunePageDto.CategoryDto.Minor1;
+                case RunePage.Category.Minor2:
+                    return RunePageDto.CategoryDto.Minor2;
+                case RunePage.Category.Minor3:
+                    return RunePageDto.CategoryDto.Minor3;
+                case RunePage.Category.OtherMinor1:
+                    return RunePageDto.CategoryDto.OtherMinor1;
+                case RunePage.Category.OtherMinor2:
+                    return RunePageDto.CategoryDto.OtherMinor2;
+                default:
+                    return RunePageDto.CategoryDto.Major;
+            }
+        }
+
+        public static RunePage.Category ToModel(this RunePageDto.CategoryDto category)
+        {
+            switch (category)
+            {
+                case RunePageDto.CategoryDto.Major:
+                    return RunePage.Category.Major;
+                case RunePageDto.CategoryDto.Minor1:
+                    return RunePage.Category.Minor1;
+                case RunePageDto.CategoryDto.Minor2:
+                    return RunePage.Category.Minor2;
+                case RunePageDto.CategoryDto.Minor3:
+                    return RunePage.Category.Minor3;
+                case RunePageDto.CategoryDto.OtherMinor1:
+                    return RunePage.Category.OtherMinor1;
+                case RunePageDto.CategoryDto.OtherMinor2:
+                    return RunePage.Category.OtherMinor2;
+                default:
+                    return RunePage.Category.Major;
+            }
+        }
+    }
+}

src/EntityFramework_LoL/Sources/DTO/ChampionDto.cs

@@ -7,8 +7,9 @@
         public ChampionClassDto Class { get; set; }
         public string Icon { get; set; }
         public LargeImageDto Image { get; set; }
-        public IEnumerable<SkinDto> Skins { get; set; }
-        public IEnumerable<SkillDto> Skills { get; set; }
+        public IEnumerable<SkinDto>? Skins { get; set; }
+        public IEnumerable<SkillDto>? Skills { get; set; }
+        public Dictionary<string, int>? Characteristics { get; set; }
 
     }
 }

src/EntityFramework_LoL/Sources/DTO/RunePageDto.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO
+{
+    public partial class RunePageDto
+    {
+        public string Name { get; set; }
+        public Dictionary<CategoryDto, RuneDto> Runes { get; set;  }
+    }
+
+}

src/EntityFramework_LoL/Sources/DTO/enums/RunePageDto.CategoryDto.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO
+{
+    public partial class RunePageDto
+    {
+        public enum CategoryDto
+        {
+            Major,
+            Minor1,
+            Minor2,
+            Minor3,
+            OtherMinor1,
+            OtherMinor2
+        }
+    }
+}