Merge branch 'NextStep_Controllers' 🌊

README.md

@@ -4,6 +4,18 @@
 
 </div>
 
+<div align = center>
+
+---
+
+[![Duplicated Lines (%)](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=LolProjectIUT&metric=duplicated_lines_density&token=b65c8ed30f0fbe374e41e98340dc910942b77bba)](https://codefirst.iut.uca.fr/sonar/dashboard?id=LolProjectIUT)
+[![Security Rating](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=LolProjectIUT&metric=security_rating&token=b65c8ed30f0fbe374e41e98340dc910942b77bba)](https://codefirst.iut.uca.fr/sonar/dashboard?id=LolProjectIUT)
+[![Vulnerabilities](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=LolProjectIUT&metric=vulnerabilities&token=b65c8ed30f0fbe374e41e98340dc910942b77bba)](https://codefirst.iut.uca.fr/sonar/dashboard?id=LolProjectIUT)
+
+---
+
+</div>
+
 
 **Thème du projet** : Réalisation d'une API et d'un ORM (Entity Framework) qui seront reliés à une base de données dans le thème de League of Legends <img src="https://logo-marque.com/wp-content/uploads/2020/11/League-of-Legends-Embleme.png" width="40" >
 </br>
@@ -14,7 +26,7 @@ La racine de mon GitLab contient deux dossiers essentiels pour le projet :
 
 [**src**](src) : **Toute la partie codage de l'application**
 
-[**doc**](doc) : **Documentation de l'application**
+[**doc**](doc) : **Documentation de l'application** (Images + Schéma et description de l'architecture globale de l'application)
 
 👉 [**Solution de l'application**](src/EntityFramework_LoL/Sources/LeagueOfLegends.sln)
 
@@ -59,6 +71,8 @@ Normalement, tout est bon et vous serez redirigé vers Swagger, qui est l'interf
 
 </div>
 
+Vous pouvez aussi utiliser l'API via cette url: https://codefirst.iut.uca.fr/containers/emrekartal-lolApi/Api/v3/champions
+
 - ### Comment lancer Le projet Entity Framework ? 
 
 Afin de générer les migrations et les tables, vous devez avoir installé correctement EntityFrameworkCore. Pour cela il existe la commande : **dotnet tool install --global dotnet-ef**, qui peut être lancé à partir d'un terminal. Si elle est déjà installée mais n'a pas la bonne version : **dotnet tool update --global dotnet-ef** (oui, il n'y a que l'*install* qui change. Vous êtes perspicace !).
@@ -108,8 +122,10 @@ Mon environnement de travail est basé sur un outil et un langage en particulier
 
 ---
 
+&nbsp; ![Docker](https://img.shields.io/badge/Docker-2496ED.svg?style=for-the-badge&logo=Docker&logoColor=white)
 &nbsp; ![Dotnet](https://img.shields.io/badge/Core-000?style=for-the-badge&logo=Dotnet&logoColor=white&color=purple)
-&nbsp; ![C#](https://img.shields.io/badge/Csharp-000?style=for-the-badge&logo=csharp&logoColor=white&color=blue)
+&nbsp; ![C#](https://img.shields.io/badge/C%20Sharp-239120.svg?style=for-the-badge&logo=C-Sharp&logoColor=white)
+&nbsp; ![SQLite](https://img.shields.io/badge/SQLite-003B57.svg?style=for-the-badge&logo=SQLite&logoColor=white)
 
 ---
 

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

@@ -0,0 +1,177 @@
+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 RunesController : ControllerBase
+    {
+        private readonly IDataManager _manager;
+        private readonly ILogger<RunesController> _logger;
+
+        public RunesController(IDataManager dataManager, ILogger<RunesController> logger)
+        {
+            _logger = logger;
+            this._manager = dataManager;
+        }
+
+
+        // GET: api/<RunesController>
+        [HttpGet]
+        public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
+        {
+            _logger.LogInformation("Executing {Action} - RUNE with parameters: {Parameters}", nameof(Get), pageRequest);
+            try
+            {
+                int nbTotal = await _manager.RunesMgr.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($"Rune limit exceed, max {nbTotal}");
+                }
+
+                IEnumerable<RuneDto> dtos;
+                if (pageRequest.name == null)
+                {
+                    dtos = (await _manager.RunesMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                    .Select(x => x.ToDto());
+                }
+                else
+                {
+                    dtos = (await _manager.RunesMgr.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)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // GET api/<RunesController>/5
+        [HttpGet("{name}")]
+        public async Task<IActionResult> Get(string name)
+        {
+            _logger.LogInformation("method {Action} - RUNE call with {name}", nameof(Get), name);
+            try
+            {
+                var dtos = (await _manager.RunesMgr.GetItemByName(name, 0, await _manager.RunesMgr.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/<RunesController>
+        [HttpPost]
+        public async Task<IActionResult> Post([FromBody] RuneDto rune)
+        {
+            _logger.LogInformation("method {Action} - RUNE call with {item}", nameof(Post), rune);
+            try
+            {
+                if (await _manager.RunesMgr.GetNbItemsByName(rune.Name) == 0)
+                {
+                    return CreatedAtAction(nameof(Get),
+                        (await _manager.RunesMgr.AddItem(rune.ToModel())));
+                }
+                _logger.LogWarning($"Name : {rune.Name} is already exist");
+                return BadRequest($"Name : {rune.Name} is already exist");
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // PUT api/<RunesController>/5
+        [HttpPut("{name}")]
+        public async Task<IActionResult> Put(string name, [FromBody] RuneDto rune)
+        {
+            _logger.LogInformation("method {Action} - RUNE call with {name} and {item}", nameof(Put), name, rune);
+            try
+            {
+                var dtos = (await _manager.RunesMgr.GetItemByName(name, 0, await _manager.RunesMgr.GetNbItems()));
+                if (dtos.IsNullOrEmpty())
+                {
+                    return NotFound($"Name {name} not exist");
+                }
+                // Checks if the new name exists
+                if (name != rune.Name)
+                {
+                    var dtos2 = (await _manager.RunesMgr.GetItemByName(rune.Name, 0, await _manager.RunesMgr.GetNbItems()));
+                    if (dtos2.IsNullOrEmpty() || dtos2.Count() > 0)
+                    {
+                        return BadRequest($"New Name {rune.Name} is already exist");
+                    }
+                }
+                return Ok(await _manager.RunesMgr.UpdateItem(dtos.First(),rune.ToModel()));
+
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // DELETE api/<RunesController>/5
+        [HttpDelete("{name}")]
+        public async Task<IActionResult> Delete(string name)
+        {
+            _logger.LogInformation("method {Action} - RUNE call with {name}", nameof(Delete), name);
+            try
+            {
+                var dtos = (await _manager.RunesMgr.GetItemByName(name, 0, await _manager.RunesMgr.GetNbItems()));
+                if (dtos.IsNullOrEmpty())
+                {
+                    _logger.LogWarning("{name} was not found", name);
+                    return BadRequest();
+                }
+                return Ok(await _manager.RunesMgr.DeleteItem(dtos.First()));
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        [HttpGet("/countRunes")]
+        public async Task<ActionResult<int>> GetCountSkins()
+        {
+            try
+            {
+                return Ok(await _manager.RunesMgr.GetNbItems());
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+
+            }
+        }
+    }
+}

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

@@ -1,76 +1,221 @@
-using ApiLol.Mapper;
-using DTO;
-using Microsoft.AspNetCore.Mvc;
-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 SkinsController : ControllerBase
-    {
-        private readonly IDataManager _manager;
-        private readonly ILogger<SkinsController> _logger;
-
-        public SkinsController(IDataManager dataManager, ILogger<SkinsController> logger)
-        {
-            _logger = logger;
-            this._manager = dataManager;
-        }
-
-        // GET: api/<SkinsController>
-        [HttpGet]
-        public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
-        {
-            try
-            {
-                int nbTotal = await _manager.ChampionsMgr.GetNbItems();
-                if (pageRequest.count + pageRequest.index > nbTotal)
-                {
-                    _logger.LogWarning($"too many, maximum {nbTotal}");
-                    return BadRequest($"Champion limit exceed, max {nbTotal}");
-                }
-
-                _logger.LogInformation($"method Get call");
-                IEnumerable<SkinDtoC> dtos = (await _manager.SkinsMgr.GetItems(pageRequest.index, pageRequest.count))
-                    .Select(x => x.ToDtoC());
-                return Ok(dtos);
-
-            }
-            catch (Exception e)
-            {
-                return BadRequest(e.Message);
-            }
-        }
-
-        // GET api/<SkinsController>/5
-        [HttpGet("{name}")]
-        public async Task<IActionResult> Get(string name)
-        {
-            return Ok();
-        }
-
-        // POST api/<SkinsController>
-        [HttpPost]
-        public async Task<IActionResult> Post([FromBody] string value)
-        {
-            return Ok();
-        }
-
-        // PUT api/<SkinsController>/5
-        [HttpPut("{name}")]
-        public async Task<IActionResult> Put(int id, [FromBody] string value)
-        {
-            return Ok();
-        }
-
-        // DELETE api/<SkinsController>/5
-        [HttpDelete("{name}")]
-        public async Task<IActionResult> Delete(string name)
-        {
-            return Ok();
-        }
-    }
-}
+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 SkinsController : ControllerBase
+    {
+        private readonly IDataManager _manager;
+        private readonly ILogger<SkinsController> _logger;
+
+        public SkinsController(IDataManager dataManager, ILogger<SkinsController> logger)
+        {
+            _logger = logger;
+            this._manager = dataManager;
+        }
+
+        // GET: api/<SkinsController>
+        [HttpGet]
+        public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
+        {
+            _logger.LogInformation("Executing {Action} - SKIN with parameters: {Parameters}", nameof(Get), pageRequest);
+            try
+            {
+                int nbTotal = await _manager.SkinsMgr.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($"Skin limit exceed, max {nbTotal}");
+                }
+
+                IEnumerable<SkinDtoC> dtos;
+                if (pageRequest.name == null)
+                {
+                    dtos = (await _manager.SkinsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                    .Select(x => x.ToDtoC());
+                }
+                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 error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // GET api/<SkinsController>/5
+        [HttpGet("{name}")]
+        public async Task<IActionResult> Get(string name)
+        {
+            _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] SkinDtoC skin)
+        {
+            _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(string name, [FromBody] SkinDtoC skin)
+        {
+            _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.SkinsMgr.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);
+            }
+        }
+
+        [HttpGet("/{name}/champion")]
+        public async Task<ActionResult<ChampionDto>> GetChampionBySkinName(string name)
+        {
+            _logger.LogInformation("method {Action} - Skin call with {name}", nameof(GetChampionBySkinName), 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");
+                }
+                var champion = (await _manager.ChampionsMgr.GetItemByName(dtos.First().ChampionName, 0, 1));
+                return Ok(champion.First().ToDto());
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+
+        [HttpGet("/countSkins")]
+        public async Task<ActionResult<int>> GetCountSkins()
+        {
+            try
+            {
+                return Ok(await _manager.SkinsMgr.GetNbItems());
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // DELETE api/<SkinsController>/5
+        [HttpDelete("{name}")]
+        public async Task<IActionResult> Delete(string name)
+        {
+            _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/v1/ChampionsController.cs

@@ -1,82 +1,96 @@
-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.v1
-{
-    [ApiVersion("1.0")]
-    [Route("api/v{version:apiVersion}/[controller]")]
-    [ApiController]
-    public class ChampionsController : ControllerBase
-    {
-        private readonly IDataManager _manager;
-        private readonly ILogger<ChampionsController> _logger;
-        public ChampionsController(IDataManager dataManager, ILogger<ChampionsController> logger)
-        {
-            _logger = logger;
-            this._manager = dataManager;
-        }
-
-        // GET: api/<ValuesController>
-        [HttpGet]
-        public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
-        {
-            _logger.LogInformation("Executing {Action} with parameters: {Parameters}", nameof(Get), pageRequest);
-            IEnumerable<ChampionDto> dtos = (await _manager.ChampionsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
-                .Select(x => x.ToDto());
-            return Ok(dtos);
-
-        }
-
-        // GET api/<ValuesController>/5
-        [HttpGet("{name}")]
-        public async Task<IActionResult> Get(string name)
-        {
-            _logger.LogInformation("method {Action} call with {name}", nameof(Get), name);
-            var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()))
-                .Select(x => x.ToDto());
-
-            return Ok(dtos.First());
-
-        }
-
-        // POST api/<ValuesController>
-        [HttpPost]
-        public async Task<IActionResult> Post([FromBody] ChampionDto champion)
-        {
-
-            _logger.LogInformation("method {Action} call with {item}", nameof(Post), champion);
-            return CreatedAtAction(nameof(Get),
-                    (await _manager.ChampionsMgr.AddItem(champion.ToModel())).ToDto());
-
-        }
-
-        // PUT api/<ValuesController>/5
-        [HttpPut("{name}")]
-        public async Task<IActionResult> Put(string name, [FromBody] ChampionDto champion)
-        {
-
-            _logger.LogInformation("method {Action} call with {name} and {item}", nameof(Put), name, champion);
+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.v1
+{
+    [ApiVersion("1.0")]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [ApiController]
+    public class ChampionsController : ControllerBase
+    {
+        private readonly IDataManager _manager;
+        private readonly ILogger<ChampionsController> _logger;
+        public ChampionsController(IDataManager dataManager, ILogger<ChampionsController> logger)
+        {
+            _logger = logger;
+            this._manager = dataManager;
+        }
+
+        // GET: api/<ValuesController>
+        [HttpGet]
+        public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
+        {
+            _logger.LogInformation("Executing {Action} - CHAMPION - V1.0 with parameters: {Parameters}", nameof(Get), pageRequest);
+            IEnumerable<ChampionDto> dtos = (await _manager.ChampionsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                .Select(x => x.ToDto());
+            return Ok(dtos);
+
+        }
+
+        // GET api/<ValuesController>/5
+        [HttpGet("{name}")]
+        public async Task<IActionResult> Get(string name)
+        {
+            _logger.LogInformation("method {Action} - CHAMPION - V1.0 call with {name}", nameof(Get), name);
+            var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()))
+                .Select(x => x.ToDto());
+
+            return Ok(dtos.First());
+
+        }
+
+        // POST api/<ValuesController>
+        [HttpPost]
+        public async Task<IActionResult> Post([FromBody] ChampionDto champion)
+        {
+
+            _logger.LogInformation("method {Action} - CHAMPION - V1.0 call with {item}", nameof(Post), champion);
+            return CreatedAtAction(nameof(Get),
+                    (await _manager.ChampionsMgr.AddItem(champion.ToModel())).ToDto());
+
+        }
+
+        // PUT api/<ValuesController>/5
+        [HttpPut("{name}")]
+        public async Task<IActionResult> Put(string name, [FromBody] ChampionDto champion)
+        {
+
+            _logger.LogInformation("method {Action} - CHAMPION - V1.0 call with {name} and {item}", nameof(Put), name, champion);
             var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()));
 
-            return Ok((await _manager.ChampionsMgr.UpdateItem(dtos.First(), champion.ToModel())).ToDto());
-
-        }
-
-        // DELETE api/<ValuesController>/5
-        [HttpDelete("{name}")]
-        public async Task<IActionResult> Delete(string name)
-        {
-
-            _logger.LogInformation("method {Action} call with {name}", nameof(Delete), name);
-            var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()));
-
-            return Ok(await _manager.ChampionsMgr.DeleteItem(dtos.First()));
-
-        }
-    }
+            return Ok((await _manager.ChampionsMgr.UpdateItem(dtos.First(), champion.ToModel())).ToDto());
+
+        }
+
+        [HttpGet("/countChampions")]
+        public async Task<ActionResult<int>> GetCountChampions()
+        {
+            try
+            {
+                return Ok(await _manager.ChampionsMgr.GetNbItems());
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // DELETE api/<ValuesController>/5
+        [HttpDelete("{name}")]
+        public async Task<IActionResult> Delete(string name)
+        {
+
+            _logger.LogInformation("method {Action} - CHAMPION - V1.0 call with {name}", nameof(Delete), name);
+            var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()));
+
+            return Ok(await _manager.ChampionsMgr.DeleteItem(dtos.First()));
+
+        }
+    }
 }

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

@@ -1,211 +1,242 @@
-using ApiLol.Mapper;
-using Azure.Core;
-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.v2
-{
-    [ApiVersion("2.0")]
-    [ApiVersion("3.0")]
-    [Route("api/v{version:apiVersion}/[controller]")]
-    [ApiController]
-    public class ChampionsController : ControllerBase
-    {
-        private readonly IDataManager _manager;
-        private readonly ILogger<ChampionsController> _logger;
-        public ChampionsController(IDataManager dataManager, ILogger<ChampionsController> logger)
-        {
-            _logger = logger;
-            this._manager = dataManager;
-        }
-
-        // GET: api/<ValuesController>
-        [HttpGet]
-        public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
-        {
-            try
-            {
-                int nbTotal = await _manager.ChampionsMgr.GetNbItems();
-                if (pageRequest.count == 0)
-                {
-                    pageRequest = new PageRequest() { index = 0, count = nbTotal };
-                }
-                else if (pageRequest.count * pageRequest.index >= nbTotal)
-                {
-                    _logger.LogWarning($"too many, maximum {nbTotal}");
-                    return BadRequest($"Champion limit exceed, max {nbTotal}");
-                }
-
-                _logger.LogInformation("Executing {Action} with parameters: {Parameters}", nameof(Get), pageRequest.count);
-                IEnumerable<ChampionDto> dtos = (await _manager.ChampionsMgr.GetItems(pageRequest.index, pageRequest.count))
-                        .Select(x => x.ToDto());
-                return Ok(dtos);
-            }
-            catch (Exception error)
-            {
-                return BadRequest(error.Message);
-            }
-        }
-
-        // GET: api/<ValuesController>
-        [HttpGet, MapToApiVersion("3.0")]
-        public async Task<IActionResult> GetV3([FromQuery] PageRequest pageRequest)
-        {
-            try
-            {
-                int nbTotal = await _manager.ChampionsMgr.GetNbItems();
-                if (pageRequest.count == 0)
-                {
-                    pageRequest = new PageRequest() { index = 0, count = nbTotal };
-                }
-                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("Executing {Action} with parameters: {Parameters}", nameof(Get), pageRequest);
-                IEnumerable<ChampionDto> 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});
-            }
-            catch (Exception error)
-            {
-                return BadRequest(error.Message);
-            }
-        }
-
-        // GET api/<ValuesController>/5
-        [HttpGet("{name}")]
-        public async Task<IActionResult> Get(string name)
-        {
-            try
-            {
-                _logger.LogInformation("method {Action} call with {name}", nameof(Get), name);
-                var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()))
-                    .Select(x => x.ToDto());
-                if (dtos.IsNullOrEmpty())
-                {
-                    _logger.LogWarning($"{name} was not found");
-                    return NotFound();
-                }
-                return Ok(dtos.First());
-            }
-            catch (Exception error)
-            {
-                return BadRequest(error.Message);
-            }
-        }
-
-        // POST api/<ValuesController>
-        [HttpPost]
-        public async Task<IActionResult> Post([FromBody] ChampionDto champion)
-        {
-            try
-            {
-                _logger.LogInformation("method {Action} call with {item}", nameof(Post), champion);
-                var dtos = (await _manager.ChampionsMgr.GetItemByName(champion.Name, 0, await _manager.ChampionsMgr.GetNbItems()));
-                if (!dtos.IsNullOrEmpty())
-                {
-                    return BadRequest("Name is already exist");
-                }
-                return CreatedAtAction(nameof(Get),
-                        (await _manager.ChampionsMgr.AddItem(champion.ToModel())).ToDto());
-            }
-            catch (Exception error)
-            {
-                return BadRequest(error.Message);
-            }
-        }
-
-        // PUT api/<ValuesController>/5
-        [HttpPut("{name}")]
-        public async Task<IActionResult> Put(string name, [FromBody] ChampionDto champion)
-        {
-            try
-            {
-                _logger.LogInformation("method {Action} call with {name} and {item}", nameof(Put), name, champion);
-                var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()));
-                if (dtos.IsNullOrEmpty())
-                {
-                    return NotFound($"Name {name} not exist");
-                }
-                // Checks if the new name exists
-                if (name != champion.Name)
-                {
-                    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 Ok((await _manager.ChampionsMgr.UpdateItem(dtos.First(), champion.ToModel())).ToDto());
-            }
-            catch (Exception error)
-            {
-                return BadRequest(error.Message);
-            }
-        }
-
-        [HttpGet("/{name}/skins")]
-        public async Task<ActionResult<SkinDto>> GetChampionsSkins(string name)
-        {
-            try
-            {
-                _logger.LogInformation("method {Action} call with {name}", nameof(GetChampionsSkins), name);
-                var champions = await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems());
-                //skinsDTO
-                IEnumerable<SkinDto> res = champions.First().Skins.Select(e => e.ToDto());
-
-                return Ok(res);
-            }
-            catch (Exception error)
-            {
-                return BadRequest(error.Message);
-            }
-        }
-
-        [HttpGet("/{name}/skills")]
-        public async Task<ActionResult<SkillDto>> GetChampionsSkills(string name)
-        {
-            try
-            {
-                _logger.LogInformation("method {Action} call with {name}", nameof(GetChampionsSkills), name);
-                var champions = await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems());
-                //SkillDTO
-                IEnumerable<SkillDto> res = champions.First().Skills.Select(e => e.ToDto());
-
-                return Ok(res);
-            }
-            catch (Exception error)
-            {
-                return BadRequest(error.Message);
-            }
-        }
-
-        // DELETE api/<ValuesController>/5
-        [HttpDelete("{name}")]
-        public async Task<IActionResult> Delete(string name)
-        {
-            try
-            {
-                _logger.LogInformation("method {Action} call with {name}", nameof(Delete), name);
-                var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()));
-                if (dtos.IsNullOrEmpty())
-                {
-                    _logger.LogWarning("{name} was not found", name);
-                    return BadRequest();
-                }
-                return Ok(await _manager.ChampionsMgr.DeleteItem(dtos.First()));
-            }
-            catch (Exception error)
-            {
-                return BadRequest(error.Message);
-            }
-        }
-    }
+using ApiLol.Mapper;
+using Azure.Core;
+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.v2
+{
+    [ApiVersion("2.0")]
+    [ApiVersion("3.0")]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [ApiController]
+    public class ChampionsController : ControllerBase
+    {
+        private readonly IDataManager _manager;
+        private readonly ILogger<ChampionsController> _logger;
+        public ChampionsController(IDataManager dataManager, ILogger<ChampionsController> logger)
+        {
+            _logger = logger;
+            this._manager = dataManager;
+        }
+
+        // GET: api/<ValuesController>
+        [HttpGet]
+        public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
+        {
+            _logger.LogInformation("Executing {Action} - CHAMPION - V2.0 with parameters: {Parameters}", nameof(Get), pageRequest);
+            try
+            {
+                int nbTotal = await _manager.ChampionsMgr.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)
+                {
+                    _logger.LogWarning($"too many, maximum {nbTotal}");
+                    return BadRequest($"Champion limit exceed, max {nbTotal}");
+                }
+
+                IEnumerable<ChampionDto> dtos = (await _manager.ChampionsMgr.GetItems(pageRequest.index, pageRequest.count))
+                        .Select(x => x.ToDto());
+                return Ok(dtos);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // GET: api/<ValuesController>
+        [HttpGet, MapToApiVersion("3.0")]
+        public async Task<IActionResult> GetV3([FromQuery] PageRequest pageRequest)
+        {
+            _logger.LogInformation("Executing {Action} - CHAMPION - V3.0 with parameters: {Parameters}", nameof(Get), pageRequest);
+            try
+            {
+                int nbTotal = await _manager.ChampionsMgr.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($"Champion limit exceed, max {nbTotal}");
+                }
+
+                IEnumerable<ChampionDto> dtos;
+                if (pageRequest.name == null)
+                {
+                    dtos = (await _manager.ChampionsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
+                        .Select(x => x.ToDto());
+                }
+                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)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // GET api/<ValuesController>/5
+        [HttpGet("{name}")]
+        public async Task<IActionResult> Get(string name)
+        {
+            _logger.LogInformation("method {Action} - CHAMPION - V2.0 call with {name}", nameof(Get), name);
+            try
+            {
+                var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.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/<ValuesController>
+        [HttpPost]
+        public async Task<IActionResult> Post([FromBody] ChampionDto champion)
+        {
+            _logger.LogInformation("method {Action} - CHAMPION - V2.0 call with {item}", nameof(Post), champion);
+            try
+            {
+                if (await _manager.ChampionsMgr.GetNbItemsByName(champion.Name) == 0)
+                {
+                    return CreatedAtAction(nameof(Get),
+                        (await _manager.ChampionsMgr.AddItem(champion.ToModel())).ToDto());
+                }
+                _logger.LogWarning($"Name : {champion.Name} is already exist");
+                return BadRequest($"Name : {champion.Name} is already exist");
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // PUT api/<ValuesController>/5
+        [HttpPut("{name}")]
+        public async Task<IActionResult> Put(string name, [FromBody] ChampionDto champion)
+        {
+            _logger.LogInformation("method {Action} - CHAMPION - V2.0 call with {name} and {item}", nameof(Put), name, champion);
+            try
+            {
+                var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()));
+                if (dtos.IsNullOrEmpty())
+                {
+                    return NotFound($"Name {name} not exist");
+                }
+                // Checks if the new name exists
+                if (name != champion.Name)
+                {
+                    var dtos2 = (await _manager.ChampionsMgr.GetItemByName(champion.Name, 0, await _manager.ChampionsMgr.GetNbItems()));
+                    if (dtos2.IsNullOrEmpty() || dtos2.Count() > 0)
+                    {
+                        return BadRequest($"New Name {champion.Name} is already exist");
+                    }
+                }
+                return Ok((await _manager.ChampionsMgr.UpdateItem(dtos.First(), champion.ToModel())).ToDto());
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        [HttpGet("/{name}/skins")]
+        public async Task<ActionResult<SkinDto>> GetChampionsSkins(string name)
+        {
+            _logger.LogInformation("method {Action} - CHAMPION - V2.0 call with {name}", nameof(GetChampionsSkins), name);
+            try
+            {
+                var champions = await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems());
+                //skinsDTO
+                IEnumerable<SkinDto> res = champions.First().Skins.Select(e => e.ToDto());
+
+                return Ok(res);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        [HttpGet("/{name}/skills")]
+        public async Task<ActionResult<SkillDto>> GetChampionsSkills(string name)
+        {
+            try
+            {
+                _logger.LogInformation("method {Action} - CHAMPION - V2.0 call with {name}", nameof(GetChampionsSkills), name);
+                var champions = await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems());
+                //SkillDTO
+                IEnumerable<SkillDto> res = champions.First().Skills.Select(e => e.ToDto());
+
+                return Ok(res);
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        [HttpGet("/countChampions")]
+        public async Task<ActionResult<int>> GetCountChampions()
+        {
+            try
+            {
+                return Ok(await _manager.ChampionsMgr.GetNbItems());
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+
+        // DELETE api/<ValuesController>/5
+        [HttpDelete("{name}")]
+        public async Task<IActionResult> Delete(string name)
+        {
+            _logger.LogInformation("method {Action} - CHAMPION - V2.0 call with {name}", nameof(Delete), name);
+            try
+            {
+                var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()));
+                if (dtos.IsNullOrEmpty())
+                {
+                    _logger.LogWarning("{name} was not found", name);
+                    return BadRequest();
+                }
+                return Ok(await _manager.ChampionsMgr.DeleteItem(dtos.First()));
+            }
+            catch (Exception error)
+            {
+                _logger.LogError(error.Message);
+                return BadRequest(error.Message);
+            }
+        }
+    }
 }

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)
-            {
-                Description = rune.Description,
-            };
-        }*/
+            return new Rune(rune.Name, rune.Family.ToModel(), rune.Icon, rune.Image.Base64, 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

@@ -1,4 +1,4 @@
-using DTO;
+using DTO;
 using Model;
 
 namespace ApiLol.Mapper
@@ -7,73 +7,46 @@ namespace ApiLol.Mapper
     {
         public static ChampionClassDto ToDto(this ChampionClass championClass)
         {
-            if (championClass == ChampionClass.Unknown)
-            {
-                return ChampionClassDto.Unknown;
-            }
-            if (championClass == ChampionClass.Assassin)
-            {
-                return ChampionClassDto.Assassin;
-            }
-            if (championClass == ChampionClass.Fighter)
-            {
-                return ChampionClassDto.Fighter;
-            }
-            if (championClass == ChampionClass.Mage)
-            {
-                return ChampionClassDto.Mage;
-            }
-            if (championClass == ChampionClass.Marksman)
-            {
-                return ChampionClassDto.Marksman;
-            }
-            if (championClass == ChampionClass.Support)
-            {
-                return ChampionClassDto.Support;
-            }
-            if (championClass == ChampionClass.Tank)
-            {
-                return ChampionClassDto.Tank;
-            }
-            else
-            {
-                return ChampionClassDto.Unknown;
+            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 championClass)
         {
-            if (championClass == ChampionClassDto.Unknown)
-            {
-                return ChampionClass.Unknown;
-            }
-            if (championClass == ChampionClassDto.Assassin)
-            {
-                return ChampionClass.Assassin;
-            }
-            if (championClass == ChampionClassDto.Fighter)
-            {
-                return ChampionClass.Fighter;
-            }
-            if (championClass == ChampionClassDto.Mage)
-            {
-                return ChampionClass.Mage;
-            }
-            if (championClass == ChampionClassDto.Marksman)
-            {
-                return ChampionClass.Marksman;
-            }
-            if (championClass == ChampionClassDto.Support)
-            {
-                return ChampionClass.Support;
-            }
-            if (championClass == ChampionClassDto.Tank)
-            {
-                return ChampionClass.Tank;
-            }
-            else
-            {
-                return ChampionClass.Unknown;
+            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)
-            {
-                return SkillTypeDto.Unknown;
-            }
-            if (skillType == SkillType.Basic)
-            {
-                return SkillTypeDto.Basic;
-            }
-            if (skillType == SkillType.Passive)
-            {
-                return SkillTypeDto.Passive;
-            }
-            if (skillType == SkillType.Ultimate)
-            {
-                return SkillTypeDto.Ultimate;
-            }
-            else
-            {
-                return SkillTypeDto.Unknown;
+            switch (skillType)
+            {
+                case SkillType.Unknown:
+                    return SkillTypeDto.Unknown;
+                case SkillType.Basic:
+                    return SkillTypeDto.Basic;
+                case SkillType.Passive:
+                    return SkillTypeDto.Passive;
+                case SkillType.Ultimate:
+                    return SkillTypeDto.Ultimate;
+                default:
+                    return SkillTypeDto.Unknown;
             }
 
         }
         public static SkillType ToModel(this SkillTypeDto skillTypeDto)
         {
-            if (skillTypeDto == SkillTypeDto.Unknown)
-            {
-                return SkillType.Unknown;
-            }
-            if (skillTypeDto == SkillTypeDto.Basic)
-            {
-                return SkillType.Basic;
-            }
-            if (skillTypeDto == SkillTypeDto.Passive)
-            {
-                return SkillType.Passive;
-            }
-            if (skillTypeDto == SkillTypeDto.Ultimate)
-            {
-                return SkillType.Ultimate;
-            }
-            else
-            {
-                return SkillType.Unknown;
+            switch (skillTypeDto)
+            {
+                case SkillTypeDto.Unknown:
+                    return SkillType.Unknown;
+                case SkillTypeDto.Basic:
+                    return SkillType.Basic;
+                case SkillTypeDto.Passive:
+                    return SkillType.Passive;
+                case SkillTypeDto.Ultimate:
+                    return SkillType.Ultimate;
+                default:
+                    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/ChampionsControllerTest.cs

@@ -1,127 +1,127 @@
-using ApiLol.Controllers;
-using ApiLol.Controllers.v2;
-using DTO;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-using StubLib;
-
-namespace ApiTests
-{
-    [TestClass]
-    public class ChampionsControllerTest
-    {
-        private readonly StubData stub;
-        private readonly ChampionsController champs;
-        public ChampionsControllerTest()
-        {
-            stub = new StubData();
-            champs = new ChampionsController(stub, new NullLogger<ChampionsController>());
-        }
-
-        [TestMethod]
-        public async Task TestGetChampions()
-        {
-            //Arrange
-
-            //Act
-            var total = await stub.ChampionsMgr.GetNbItems();
-            var champion = await champs.Get(new PageRequest());
-
-            //Assert
-            var objectResult = champion as OkObjectResult;
-            Assert.IsNotNull(objectResult);
-
-            var champions = objectResult?.Value as IEnumerable<ChampionDto>;
-            Assert.IsNotNull(champions);
-
-            Assert.AreEqual(champions.Count(), total);
-
-        }
-
-        [TestMethod]
-        public async Task TestPostChampion()
-        {
-            //Arange
-            var ChampionDto = new ChampionDto
-            {
-                Name = "Sylas",
-                Bio = "Good",
-                Class = ChampionClassDto.Tank,
-                Icon = "",
-                Image = new LargeImageDto() { Base64 = "" },
-                Skins = new List<SkinDto>()
-            };
-
-            //Act
-            var championsResult = await champs.Post(ChampionDto);
-
-            //Assert
-            var objectResult = championsResult as CreatedAtActionResult;
-            Assert.IsNotNull(objectResult);
-
-            var champions = objectResult?.Value as ChampionDto;
-            Assert.IsNotNull(champions);
-
+using ApiLol.Controllers;
+using ApiLol.Controllers.v2;
+using DTO;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using StubLib;
+
+namespace ApiTests
+{
+    [TestClass]
+    public class ChampionsControllerTest
+    {
+        private readonly StubData stub;
+        private readonly ChampionsController champs;
+        public ChampionsControllerTest()
+        {
+            stub = new StubData();
+            champs = new ChampionsController(stub, new NullLogger<ChampionsController>());
         }
 
-        [TestMethod]
-        public async Task TestPutChampion()
+        [TestMethod]
+        public async Task TestGetChampions()
+        {
+            //Arrange
+
+            //Act
+            var total = await stub.ChampionsMgr.GetNbItems();
+            var champion = await champs.Get(new PageRequest());
+
+            //Assert
+            var objectResult = champion as OkObjectResult;
+            Assert.IsNotNull(objectResult);
+
+            var champions = objectResult?.Value as IEnumerable<ChampionDto>;
+            Assert.IsNotNull(champions);
+
+            Assert.AreEqual(champions.Count(), total);
+
+        }
+
+        [TestMethod]
+        public async Task TestPostChampion()
         {
             //Arange
-            var ChampionDto = new ChampionDto
-            {
-                Name = "Sylas",
-                Bio = "Good",
-                Class = ChampionClassDto.Tank,
-                Icon = "",
-                Image = new LargeImageDto() { Base64 = "" },
-                Skins = new List<SkinDto>()
+            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);
+
+            //Act
+            var championsResult = await champs.Post(ChampionDto);
+
+            //Assert
+            var objectResult = championsResult as CreatedAtActionResult;
+            Assert.IsNotNull(objectResult);
+
+            var champions = objectResult?.Value as ChampionDto;
+            Assert.IsNotNull(champions);
+
+        }
+
+        [TestMethod]
+        public async Task TestPutChampion()
+        {
+            //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;
+            var objectResult = championsResult as OkObjectResult;
             Assert.IsNotNull(objectResult);
 
-            var champions = objectResult?.Value as ChampionDto;
-            Assert.IsNotNull(champions);
-
+            var champions = objectResult?.Value as ChampionDto;
+            Assert.IsNotNull(champions);
+
             Assert.AreNotEqual(ChampionDto.Bio, champions.Bio);
-            Assert.AreEqual(ChampionDtoPut.Bio, champions.Bio);
-
+            Assert.AreEqual(ChampionDtoPut.Bio, champions.Bio);
+
         }
 
-        [TestMethod]
-        public async Task TestDeleteChampion()
+        [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);
-
+            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);
-
-        }
-
-    }
+            Assert.AreNotEqual(await stub.ChampionsMgr.GetNbItems(), total);
+
+        }
+
+    }
 }

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()