New Mappers, Controllers and beginning SkinsControllerTest 🎉

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

@@ -0,0 +1,43 @@
+using Microsoft.AspNetCore.Mvc;
+
+// 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 RunesController : ControllerBase
+    {
+        // GET: api/<RunesController>
+        [HttpGet]
+        public IEnumerable<string> Get()
+        {
+            return new string[] { "value1", "value2" };
+        }
+
+        // GET api/<RunesController>/5
+        [HttpGet("{name}")]
+        public string Get(string name)
+        {
+            return "value";
+        }
+
+        // POST api/<RunesController>
+        [HttpPost]
+        public void Post([FromBody] string value)
+        {
+        }
+
+        // PUT api/<RunesController>/5
+        [HttpPut("{id}")]
+        public void Put(int id, [FromBody] string value)
+        {
+        }
+
+        // DELETE api/<RunesController>/5
+        [HttpDelete("{id}")]
+        public void Delete(int id)
+        {
+        }
+    }
+}

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

@@ -1,6 +1,7 @@
 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
@@ -24,24 +25,38 @@ namespace ApiLol.Controllers
         [HttpGet]
         public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
         {
+            _logger.LogInformation("Executing {Action} - SKIN with parameters: {Parameters}", nameof(Get), pageRequest.count);
             try
             {
-                int nbTotal = await _manager.ChampionsMgr.GetNbItems();
+                int nbTotal = await _manager.SkinsMgr.GetNbItems();
-                if (pageRequest.count + pageRequest.index > nbTotal)
+                if (pageRequest.count == 0)
                 {
-                    _logger.LogWarning($"too many, maximum {nbTotal}");
+                    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($"Champion limit exceed, max {nbTotal}");
                 }
 
-                _logger.LogInformation($"method Get call");
+                IEnumerable<SkinDtoC> dtos;
-                IEnumerable<SkinDtoC> dtos = (await _manager.SkinsMgr.GetItems(pageRequest.index, pageRequest.count))
+                if (pageRequest.name == null)
+                {
+                    dtos = (await _manager.SkinsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
                     .Select(x => x.ToDtoC());
-                return Ok(dtos);
+                }
+                else
+                {
+                    dtos = (await _manager.SkinsMgr.GetItemsByName(pageRequest.name, pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                        .Select(x => x.ToDtoC());
+                }
+                return Ok(new { Data = dtos, index = pageRequest.index, count = pageRequest.count, total = nbTotal });
 
             }
-            catch (Exception e)
+            catch (Exception error)
             {
-                return BadRequest(e.Message);
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
             }
         }
 
@@ -49,28 +64,120 @@ namespace ApiLol.Controllers
         [HttpGet("{name}")]
         public async Task<IActionResult> Get(string name)
         {
-            return Ok();
+            _logger.LogInformation("method {Action} - SKIN call with {name}", nameof(Get), name);
+            try
+            {
+                var dtos = (await _manager.SkinsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()))
+                    .Select(x => x.ToDtoC());
+                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/<SkinsController>
         [HttpPost]
-        public async Task<IActionResult> Post([FromBody] string value)
+        public async Task<IActionResult> Post([FromBody] SkinDtoC skin)
         {
-            return Ok();
+            _logger.LogInformation("method {Action} - SKIN call with {item}", nameof(Post), skin);
+            try
+            {
+                if (skin.ChampionName != null)
+                {
+                    var dtos = (await _manager.ChampionsMgr.GetItemByName(skin.ChampionName, 0, await _manager.ChampionsMgr.GetNbItems()));
+                    if (dtos.IsNullOrEmpty())
+                    {
+                        _logger.LogWarning($"Champion Name : {skin.ChampionName} not exist");
+                        return BadRequest($"Champion Name : {skin.ChampionName} not exist");
+                    }
+                    else
+                    {
+                        if (await _manager.SkinsMgr.GetNbItemsByName(skin.Name) == 0)
+                        {
+                            return CreatedAtAction(nameof(Get),
+                                (await _manager.SkinsMgr.AddItem(skin.ToModelC(dtos.First()))).ToDtoC());
+                        }
+                        _logger.LogWarning($"Name : {skin.Name} is already exist");
+                        return BadRequest($"Name : {skin.Name} is already exist");
+                    }
+                }
+                else
+                {
+                    return BadRequest("Please fill in the name of the champion");
+                }
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
 
         // PUT api/<SkinsController>/5
         [HttpPut("{name}")]
-        public async Task<IActionResult> Put(int id, [FromBody] string value)
+        public async Task<IActionResult> Put(string name, [FromBody] SkinDtoC skin)
         {
-            return Ok();
+            _logger.LogInformation("method {Action} - SKIN call with {name} and {item}", nameof(Put), name, skin);
+            try
+            {
+                var dtos = (await _manager.SkinsMgr.GetItemByName(name, 0, await _manager.SkinsMgr.GetNbItems()));
+                if (dtos.IsNullOrEmpty())
+                {
+                    return NotFound($"Name {name} not exist");
+                }
+                // Checks if the new name exists
+                if (name != skin.Name)
+                {
+                    var dtos2 = (await _manager.SkinsMgr.GetItemByName(skin.Name, 0, await _manager.ChampionsMgr.GetNbItems()));
+                    if (dtos2.IsNullOrEmpty() || dtos2.Count() > 0)
+                    {
+                        return BadRequest($"New Name {skin.Name} is already exist");
+                    }
+                }
+                var dtosChampion = (await _manager.ChampionsMgr.GetItemByName(skin.ChampionName, 0, await _manager.ChampionsMgr.GetNbItems()));
+                if (dtosChampion.IsNullOrEmpty())
+                {
+                    _logger.LogWarning($"Champion Name : {skin.ChampionName} not exist");
+                    return BadRequest($"Champion Name : {skin.ChampionName} not exist");
+                }
+                return Ok((await _manager.SkinsMgr.UpdateItem(dtos.First(), skin.ToModelC(dtosChampion.First()))).ToDtoC());
+
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
 
         // DELETE api/<SkinsController>/5
         [HttpDelete("{name}")]
         public async Task<IActionResult> Delete(string name)
         {
-            return Ok();
+            _logger.LogInformation("method {Action} - Skin call with {name}", nameof(Delete), name);
+            try
+            {
+                var dtos = (await _manager.SkinsMgr.GetItemByName(name, 0, await _manager.SkinsMgr.GetNbItems()));
+                if (dtos.IsNullOrEmpty())
+                {
+                    _logger.LogWarning("{name} was not found", name);
+                    return BadRequest();
+                }
+                return Ok(await _manager.SkinsMgr.DeleteItem(dtos.First()));
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
         }
     }
 }

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

@@ -33,7 +33,7 @@ namespace ApiLol.Controllers.v2
                 int nbTotal = await _manager.ChampionsMgr.GetNbItems();
                 if (pageRequest.count == 0)
                 {
-                    pageRequest = new PageRequest() { index = 0, count = nbTotal };
+                    pageRequest = new PageRequest() { index = 0, count = nbTotal, orderingPropertyName = pageRequest.orderingPropertyName, descending = pageRequest.descending, name = pageRequest.name };
                 }
                 else if (pageRequest.count * pageRequest.index >= nbTotal)
                 {
@@ -61,7 +61,7 @@ namespace ApiLol.Controllers.v2
                 int nbTotal = await _manager.ChampionsMgr.GetNbItems();
                 if (pageRequest.count == 0)
                 {
-                    pageRequest = new PageRequest() { index = 0, count = nbTotal };
+                    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)
                 {
@@ -69,9 +69,18 @@ namespace ApiLol.Controllers.v2
                     return BadRequest($"Champion limit exceed, max {nbTotal}");
                 }
 
-                IEnumerable<ChampionDto> dtos = (await _manager.ChampionsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                IEnumerable<ChampionDto> dtos;
+                if (pageRequest.name == null)
+                {
+                    dtos = (await _manager.ChampionsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
                         .Select(x => x.ToDto());
-                return Ok(new { Data = dtos, index = pageRequest.index, count = pageRequest.count, total = nbTotal});
+                }
+                else
+                {
+                    dtos = (await _manager.ChampionsMgr.GetItemsByName(pageRequest.name, pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                        .Select(x => x.ToDto());
+                }
+                return Ok(new { Data = dtos, index = pageRequest.index, count = pageRequest.count, total = nbTotal });
             }
             catch (Exception error)
             {
@@ -140,7 +149,7 @@ namespace ApiLol.Controllers.v2
                     var dtos2 = (await _manager.ChampionsMgr.GetItemByName(champion.Name, 0, await _manager.ChampionsMgr.GetNbItems()));
                     if (dtos2.IsNullOrEmpty() || dtos2.Count() > 0)
                     {
-                        return BadRequest("Name is already exist");
+                        return BadRequest($"New Name {champion.Name} is already exist");
                     }
                 }
                 return Ok((await _manager.ChampionsMgr.UpdateItem(dtos.First(), champion.ToModel())).ToDto());

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

@@ -1,4 +1,5 @@
-using DTO;
+using ApiLol.Mapper.enums;
+using DTO;
 using Model;
 
 namespace ApiLol.Mapper
@@ -11,15 +12,15 @@ namespace ApiLol.Mapper
             {
                 Name = rune.Name,
                 Description = rune.Description,
+                Family = rune.Family.ToDto(),
+                Icon = rune.Icon,
+                Image = rune.Image.ToDto()
             };
         }
 
-/*        public static Rune ToModel(this RuneDto runeDto)
+        public static Rune ToModel(this RuneDto rune)
         {
-            return new Rune(rune.Name)
+            return new Rune(rune.Name, rune.Family.ToModel(), rune.Icon, rune.Image.Base64, rune.Description);
-            {
+        }
-                Description = rune.Description,
-            };
-        }*/
     }
 }

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

@@ -35,5 +35,10 @@ namespace ApiLol.Mapper
             return new Skin(skinDto.Name, champ, skinDto.Price, skinDto.Icon, skinDto.Image.Base64, skinDto.Description);
         }
 
+        public static Skin ToModelC(this SkinDtoC skinDto, Champion champ)
+        {
+            return new Skin(skinDto.Name, champ, skinDto.Price, skinDto.Icon, skinDto.Image.Base64, skinDto.Description);
+        }
+
     }
 }

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

@@ -7,11 +7,47 @@ namespace ApiLol.Mapper
     {
         public static ChampionClassDto ToDto(this ChampionClass championClass)
         {
-            return (ChampionClassDto) championClass;
+            switch (championClass)
+            {
+                case ChampionClass.Unknown:
+                    return ChampionClassDto.Unknown;
+                case ChampionClass.Assassin:
+                    return ChampionClassDto.Assassin;
+                case ChampionClass.Fighter:
+                    return ChampionClassDto.Fighter;
+                case ChampionClass.Mage:
+                    return ChampionClassDto.Mage;
+                case ChampionClass.Marksman:
+                    return ChampionClassDto.Marksman;
+                case ChampionClass.Support:
+                    return ChampionClassDto.Support;
+                case ChampionClass.Tank:
+                    return ChampionClassDto.Tank;
+                default:
+                    return ChampionClassDto.Unknown;
+            }
         }
-        public static ChampionClass ToModel(this ChampionClassDto championClassDto)
+        public static ChampionClass ToModel(this ChampionClassDto championClass)
         {
-            return (ChampionClass) championClassDto;
+            switch (championClass)
+            {
+                case ChampionClassDto.Unknown:
+                    return ChampionClass.Unknown;
+                case ChampionClassDto.Assassin:
+                    return ChampionClass.Assassin;
+                case ChampionClassDto.Fighter:
+                    return ChampionClass.Fighter;
+                case ChampionClassDto.Mage:
+                    return ChampionClass.Mage;
+                case ChampionClassDto.Marksman:
+                    return ChampionClass.Marksman;
+                case ChampionClassDto.Support:
+                    return ChampionClass.Support;
+                case ChampionClassDto.Tank:
+                    return ChampionClass.Tank;
+                default:
+                    return ChampionClass.Unknown;
+            }
         }
     }
 }

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

@@ -0,0 +1,39 @@
+using DTO;
+using DTO.enums;
+using Model;
+
+namespace ApiLol.Mapper.enums
+{
+    public static class RuneFamilyMapper
+    {
+        public static RuneFamilyDto ToDto(this RuneFamily runeFamily)
+        {
+            switch (runeFamily)
+            {
+                case RuneFamily.Unknown:
+                    return RuneFamilyDto.Unknown;
+                case RuneFamily.Precision:
+                    return RuneFamilyDto.Precision;
+                case RuneFamily.Domination:
+                    return RuneFamilyDto.Domination;
+                default:
+                    return RuneFamilyDto.Unknown;
+            }
+        }
+
+        public static RuneFamily ToModel(this RuneFamilyDto runeFamily)
+        {
+            switch (runeFamily)
+            {
+                case RuneFamilyDto.Unknown:
+                    return RuneFamily.Unknown;
+                case RuneFamilyDto.Precision:
+                    return RuneFamily.Precision;
+                case RuneFamilyDto.Domination:
+                    return RuneFamily.Domination;
+                default:
+                    return RuneFamily.Unknown;
+            }
+        }
+    }
+}

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

@@ -7,49 +7,35 @@ namespace ApiLol.Mapper
     {
         public static SkillTypeDto ToDto(this SkillType skillType)
         {
-            if (skillType == SkillType.Unknown)
+            switch (skillType)
-            {
+            {
-                return SkillTypeDto.Unknown;
+                case SkillType.Unknown:
-            }
+                    return SkillTypeDto.Unknown;
-            if (skillType == SkillType.Basic)
+                case SkillType.Basic:
-            {
+                    return SkillTypeDto.Basic;
-                return SkillTypeDto.Basic;
+                case SkillType.Passive:
-            }
+                    return SkillTypeDto.Passive;
-            if (skillType == SkillType.Passive)
+                case SkillType.Ultimate:
-            {
+                    return SkillTypeDto.Ultimate;
-                return SkillTypeDto.Passive;
+                default:
-            }
+                    return SkillTypeDto.Unknown;
-            if (skillType == SkillType.Ultimate)
-            {
-                return SkillTypeDto.Ultimate;
-            }
-            else
-            {
-                return SkillTypeDto.Unknown;
             }
 
         }
         public static SkillType ToModel(this SkillTypeDto skillTypeDto)
         {
-            if (skillTypeDto == SkillTypeDto.Unknown)
+            switch (skillTypeDto)
-            {
+            {
-                return SkillType.Unknown;
+                case SkillTypeDto.Unknown:
-            }
+                    return SkillType.Unknown;
-            if (skillTypeDto == SkillTypeDto.Basic)
+                case SkillTypeDto.Basic:
-            {
+                    return SkillType.Basic;
-                return SkillType.Basic;
+                case SkillTypeDto.Passive:
-            }
+                    return SkillType.Passive;
-            if (skillTypeDto == SkillTypeDto.Passive)
+                case SkillTypeDto.Ultimate:
-            {
+                    return SkillType.Ultimate;
-                return SkillType.Passive;
+                default:
-            }
+                    return SkillType.Unknown;
-            if (skillTypeDto == SkillTypeDto.Ultimate)
-            {
-                return SkillType.Ultimate;
-            }
-            else
-            {
-                return SkillType.Unknown;
             }
 
         }

src/EntityFramework_LoL/Sources/Client/ChampionHttpClient.cs

@@ -10,17 +10,17 @@ namespace Client
 {
     public class ChampionHttpClient
     {
-        private const string ApiChampions = "api/champions";
+        private const string UrlApiChampions = "/api/v3/champions";
         private readonly HttpClient _httpClient;
         public ChampionHttpClient(HttpClient httpClient)
         {
             _httpClient = httpClient;
-            httpClient.BaseAddress = new Uri("https://localhost:7252;http://localhost:5252");
+            httpClient.BaseAddress = new Uri("https://localhost:7252");
         }
 
         public async Task<IEnumerable<ChampionDto>> GetChampion(int index, int count)
         {
-            var url = $"{ApiChampions}?index={index}&count={count}";
+            var url = $"{UrlApiChampions}?index={index}&count={count}";
             return await _httpClient.GetFromJsonAsync<IEnumerable<ChampionDto>>(url);
         }
 /*        public async void Add(ChampionDto champion)

src/EntityFramework_LoL/Sources/Client/Program.cs

@@ -3,7 +3,6 @@ using Client;
 using DTO;
 
 Console.WriteLine("Hello, World!");
-
 var championClient = new ChampionHttpClient(new HttpClient());
 
 // Get all champions

src/EntityFramework_LoL/Sources/DTO/PageRequest.cs

@@ -10,6 +10,7 @@ namespace DTO
     {
         public int index { get; set; } = 0;
         public int count { get; set; } = 0;
+        public string? name { get; set; } = null;
         public string? orderingPropertyName { get; set; } = "Name";
         public bool descending { get; set; } = false;
     }

src/EntityFramework_LoL/Sources/DTO/RuneDto.cs

@@ -12,6 +12,7 @@ namespace DTO
         public string Name { get; set; }
         public string Description { get; set; }
         public RuneFamilyDto Family { get; set; }
+        public string Icon { get; set; }
         public LargeImageDto Image { get; set; }
 
     }

src/EntityFramework_LoL/Sources/Tests/ApiTests/SkinsControllerTest.cs

@@ -0,0 +1,126 @@
+using ApiLol.Controllers;
+using DTO;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging.Abstractions;
+using StubLib;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ApiTests
+{
+    [TestClass]
+    public class SkinsControllerTest
+    {
+        private readonly StubData stub;
+        private readonly SkinsController skins;
+        public SkinsControllerTest()
+        {
+            stub = new StubData();
+            skins = new SkinsController(stub, new NullLogger<SkinsController>());
+        }
+
+/*        [TestMethod]
+        public async Task TestGetSkins()
+        {
+            //Arrange
+
+            //Act
+            var total = await stub.SkinsMgr.GetNbItems();
+            var skin = await skins.Get(new PageRequest());
+
+            //Assert
+            var objectResult = skin as OkObjectResult;
+            Assert.IsNotNull(objectResult);
+
+            var skinsResult = objectResult?.Value as IEnumerable<SkinDtoC>;
+            Assert.IsNotNull(skinsResult);
+
+            Assert.AreEqual(skinsResult.Count(), total);
+
+        }
+
+        [TestMethod]
+        public async Task TestPostSkin()
+        {
+            //Arange
+            var SkinDto = new SkinDtoC
+            {
+                Name = "Project",
+                ChampionName = "Aatrox"
+            };
+
+            //Act
+            var skinsResult = await skins.Post(SkinDto);
+
+            //Assert
+            var objectResult = skinsResult as CreatedAtActionResult;
+            Assert.IsNotNull(objectResult);
+
+            var champions = objectResult?.Value as Ski;
+            Assert.IsNotNull(champions);
+
+        }
+
+        [TestMethod]
+        public async Task TestPutSkin()
+        {
+            //Arange
+            var ChampionDto = new ChampionDto
+            {
+                Name = "Sylas",
+                Bio = "Good",
+                Class = ChampionClassDto.Tank,
+                Icon = "",
+                Image = new LargeImageDto() { Base64 = "" },
+                Skins = new List<SkinDto>()
+            };
+            var ChampionDtoPut = new ChampionDto
+            {
+                Name = "Sylas",
+                Bio = "Bad",
+                Class = ChampionClassDto.Tank,
+                Icon = "",
+                Image = new LargeImageDto() { Base64 = "" },
+                Skins = new List<SkinDto>()
+            };
+
+            //Act
+            await champs.Post(ChampionDto);
+            var championsResult = await champs.Put(ChampionDto.Name, ChampionDtoPut);
+
+            //Assert
+            var objectResult = championsResult as OkObjectResult;
+            Assert.IsNotNull(objectResult);
+
+            var champions = objectResult?.Value as ChampionDto;
+            Assert.IsNotNull(champions);
+
+            Assert.AreNotEqual(ChampionDto.Bio, champions.Bio);
+            Assert.AreEqual(ChampionDtoPut.Bio, champions.Bio);
+
+        }
+
+        [TestMethod]
+        public async Task TestDeleteChampion()
+        {
+            //Arange
+
+
+            //Act
+            var total = await stub.ChampionsMgr.GetNbItems();
+            var championsResult = await champs.Delete("Akali");
+
+            //Assert
+            var objectResult = championsResult as OkObjectResult;
+            Assert.IsNotNull(objectResult);
+
+            Assert.AreEqual(objectResult.Value, true);
+            Assert.AreNotEqual(await stub.ChampionsMgr.GetNbItems(), total);
+
+        }*/
+
+    }
+}

src/EntityFramework_LoL/Sources/Tests/UT_EF/ChampionsTest.cs

@@ -4,7 +4,7 @@ using Xunit;
 
 namespace UT_EF
 {
-    public class UnitTest1
+    public class ChampionsTest
     {
         [Fact]
         public void TestAdd()