emre.kartal
/
LolProject
0
1
Fork 0
Code Issues Pull Requests 3 Packages Projects Releases Wiki Activity

Merge branch 'NextStep_Controllers' 🌊
continuous-integration/drone/push Build is passing Details

Browse Source
UT_EF_Manager
Emre KARTAL 2 years ago
parent 32d41969f1 a9ebafdc69
commit d71c2d9138
20 changed files with 1102 additions and 588 deletions
Show Stats Download Patch File Download Diff File

BIN
.vs/LolProject/v17/.suo
View File

Binary file not shown.

BIN
.vs/LolProject/v17/.wsuo
View File

Binary file not shown.

20
README.md
Unescape View File

@ -4,6 +4,18 @@
</div> </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" > **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> </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** [**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) 👉 [**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> </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 ? - ### 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 !). 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; ![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)
--- ---

BIN
doc/Schémas/Architecture_Global.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 75 KiB

177
src/EntityFramework_LoL/Sources/ApiLol/Controllers/RunesController.cs
Unescape View File

@ -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);
}
}
}
}

297
src/EntityFramework_LoL/Sources/ApiLol/Controllers/SkinsController.cs
Unescape View File

@ -1,76 +1,221 @@
using ApiLol.Mapper; using ApiLol.Mapper;
using DTO; using DTO;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Model; using Microsoft.IdentityModel.Tokens;
using Model;
// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
namespace ApiLol.Controllers
{ namespace ApiLol.Controllers
[Route("api/[controller]")] {
[ApiController] [Route("api/[controller]")]
public class SkinsController : ControllerBase [ApiController]
{ public class SkinsController : ControllerBase
private readonly IDataManager _manager; {
private readonly ILogger<SkinsController> _logger; private readonly IDataManager _manager;
private readonly ILogger<SkinsController> _logger;
public SkinsController(IDataManager dataManager, ILogger<SkinsController> logger)
{ public SkinsController(IDataManager dataManager, ILogger<SkinsController> logger)
_logger = logger; {
this._manager = dataManager; _logger = logger;
} this._manager = dataManager;
}
// GET: api/<SkinsController>
[HttpGet] // GET: api/<SkinsController>
public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest) [HttpGet]
{ public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
try {
{ _logger.LogInformation("Executing {Action} - SKIN with parameters: {Parameters}", nameof(Get), pageRequest);
int nbTotal = await _manager.ChampionsMgr.GetNbItems(); try
if (pageRequest.count + pageRequest.index > nbTotal) {
{ int nbTotal = await _manager.SkinsMgr.GetNbItems();
_logger.LogWarning($"too many, maximum {nbTotal}"); if (pageRequest.count == 0)
return BadRequest($"Champion limit exceed, max {nbTotal}"); {
} pageRequest = new PageRequest() { index = 0, count = nbTotal, orderingPropertyName = pageRequest.orderingPropertyName, descending = pageRequest.descending, name = pageRequest.name };
}
_logger.LogInformation($"method Get call"); else if (pageRequest.count * pageRequest.index >= nbTotal || pageRequest.count > nbTotal)
IEnumerable<SkinDtoC> dtos = (await _manager.SkinsMgr.GetItems(pageRequest.index, pageRequest.count)) {
.Select(x => x.ToDtoC()); _logger.LogWarning("too many, maximum {number}", nbTotal);
return Ok(dtos); return BadRequest($"Skin limit exceed, max {nbTotal}");
}
}
catch (Exception e) IEnumerable<SkinDtoC> dtos;
{ if (pageRequest.name == null)
return BadRequest(e.Message); {
} dtos = (await _manager.SkinsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
} .Select(x => x.ToDtoC());
}
// GET api/<SkinsController>/5 else
[HttpGet("{name}")] {
public async Task<IActionResult> Get(string name) dtos = (await _manager.SkinsMgr.GetItemsByName(pageRequest.name, pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
{ .Select(x => x.ToDtoC());
return Ok(); }
} return Ok(new { Data = dtos, index = pageRequest.index, count = pageRequest.count, total = nbTotal });
// POST api/<SkinsController> }
[HttpPost] catch (Exception error)
public async Task<IActionResult> Post([FromBody] string value) {
{ _logger.LogError(error.Message);
return Ok(); return BadRequest(error.Message);
} }
}
// PUT api/<SkinsController>/5
[HttpPut("{name}")] // GET api/<SkinsController>/5
public async Task<IActionResult> Put(int id, [FromBody] string value) [HttpGet("{name}")]
{ public async Task<IActionResult> Get(string name)
return Ok(); {
} _logger.LogInformation("method {Action} - SKIN call with {name}", nameof(Get), name);
try
// DELETE api/<SkinsController>/5 {
[HttpDelete("{name}")] var dtos = (await _manager.SkinsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()))
public async Task<IActionResult> Delete(string name) .Select(x => x.ToDtoC());
{ if (dtos.IsNullOrEmpty())
return Ok(); {
} _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);
}
}
}
}

172
src/EntityFramework_LoL/Sources/ApiLol/Controllers/v1/ChampionsController.cs
Unescape View File

@ -1,82 +1,96 @@
using ApiLol.Mapper; using ApiLol.Mapper;
using DTO; using DTO;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.IdentityModel.Tokens; using Microsoft.IdentityModel.Tokens;
using Model; using Model;
// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860 // For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
namespace ApiLol.Controllers.v1 namespace ApiLol.Controllers.v1
{ {
[ApiVersion("1.0")] [ApiVersion("1.0")]
[Route("api/v{version:apiVersion}/[controller]")] [Route("api/v{version:apiVersion}/[controller]")]
[ApiController] [ApiController]
public class ChampionsController : ControllerBase public class ChampionsController : ControllerBase
{ {
private readonly IDataManager _manager; private readonly IDataManager _manager;
private readonly ILogger<ChampionsController> _logger; private readonly ILogger<ChampionsController> _logger;
public ChampionsController(IDataManager dataManager, ILogger<ChampionsController> logger) public ChampionsController(IDataManager dataManager, ILogger<ChampionsController> logger)
{ {
_logger = logger; _logger = logger;
this._manager = dataManager; this._manager = dataManager;
} }
// GET: api/<ValuesController> // GET: api/<ValuesController>
[HttpGet] [HttpGet]
public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest) public async Task<IActionResult> Get([FromQuery] PageRequest pageRequest)
{ {
_logger.LogInformation("Executing {Action} with parameters: {Parameters}", nameof(Get), 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)) IEnumerable<ChampionDto> dtos = (await _manager.ChampionsMgr.GetItems(pageRequest.index, pageRequest.count, pageRequest.orderingPropertyName, pageRequest.descending))
.Select(x => x.ToDto()); .Select(x => x.ToDto());
return Ok(dtos); return Ok(dtos);
} }
// GET api/<ValuesController>/5 // GET api/<ValuesController>/5
[HttpGet("{name}")] [HttpGet("{name}")]
public async Task<IActionResult> Get(string name) public async Task<IActionResult> Get(string name)
{ {
_logger.LogInformation("method {Action} call with {name}", nameof(Get), 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())) var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()))
.Select(x => x.ToDto()); .Select(x => x.ToDto());
return Ok(dtos.First()); return Ok(dtos.First());
} }
// POST api/<ValuesController> // POST api/<ValuesController>
[HttpPost] [HttpPost]
public async Task<IActionResult> Post([FromBody] ChampionDto champion) public async Task<IActionResult> Post([FromBody] ChampionDto champion)
{ {
_logger.LogInformation("method {Action} call with {item}", nameof(Post), champion); _logger.LogInformation("method {Action} - CHAMPION - V1.0 call with {item}", nameof(Post), champion);
return CreatedAtAction(nameof(Get), return CreatedAtAction(nameof(Get),
(await _manager.ChampionsMgr.AddItem(champion.ToModel())).ToDto()); (await _manager.ChampionsMgr.AddItem(champion.ToModel())).ToDto());
} }
// PUT api/<ValuesController>/5 // PUT api/<ValuesController>/5
[HttpPut("{name}")] [HttpPut("{name}")]
public async Task<IActionResult> Put(string name, [FromBody] ChampionDto champion) public async Task<IActionResult> Put(string name, [FromBody] ChampionDto champion)
{ {
_logger.LogInformation("method {Action} call with {name} and {item}", nameof(Put), name, 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())); var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems()));
return Ok((await _manager.ChampionsMgr.UpdateItem(dtos.First(), champion.ToModel())).ToDto()); return Ok((await _manager.ChampionsMgr.UpdateItem(dtos.First(), champion.ToModel())).ToDto());
} }
// DELETE api/<ValuesController>/5 [HttpGet("/countChampions")]
[HttpDelete("{name}")] public async Task<ActionResult<int>> GetCountChampions()
public async Task<IActionResult> Delete(string name) {
{ try
{
_logger.LogInformation("method {Action} call with {name}", nameof(Delete), name); return Ok(await _manager.ChampionsMgr.GetNbItems());
var dtos = (await _manager.ChampionsMgr.GetItemByName(name, 0, await _manager.ChampionsMgr.GetNbItems())); }
catch (Exception error)
return Ok(await _manager.ChampionsMgr.DeleteItem(dtos.First())); {
_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()));
}
}
} }

451
src/EntityFramework_LoL/Sources/ApiLol/Controllers/v2/ChampionsController.cs
Unescape View File

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

15
src/EntityFramework_LoL/Sources/ApiLol/Mapper/RuneMapper.cs
Unescape View File

@ -1,4 +1,5 @@
using DTO; using ApiLol.Mapper.enums;
using DTO;
using Model; using Model;
namespace ApiLol.Mapper namespace ApiLol.Mapper
@ -11,15 +12,15 @@ namespace ApiLol.Mapper
{ {
Name = rune.Name, Name = rune.Name,
Description = rune.Description, 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,
};
}*/
} }
} }

5
src/EntityFramework_LoL/Sources/ApiLol/Mapper/SkinMapper.cs
Unescape View File

@ -35,5 +35,10 @@ namespace ApiLol.Mapper
return new Skin(skinDto.Name, champ, skinDto.Price, skinDto.Icon, skinDto.Image.Base64, skinDto.Description); 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);
}
} }
} }

101
src/EntityFramework_LoL/Sources/ApiLol/Mapper/enums/ChampionClassMapper.cs
Unescape View File

@ -1,4 +1,4 @@
using DTO; using DTO;
using Model; using Model;
namespace ApiLol.Mapper namespace ApiLol.Mapper
@ -7,73 +7,46 @@ namespace ApiLol.Mapper
{ {
public static ChampionClassDto ToDto(this ChampionClass championClass) public static ChampionClassDto ToDto(this ChampionClass championClass)
{ {
if (championClass == ChampionClass.Unknown) switch (championClass)
{ {
return ChampionClassDto.Unknown; case ChampionClass.Unknown:
} return ChampionClassDto.Unknown;
if (championClass == ChampionClass.Assassin) case ChampionClass.Assassin:
{ return ChampionClassDto.Assassin;
return ChampionClassDto.Assassin; case ChampionClass.Fighter:
} return ChampionClassDto.Fighter;
if (championClass == ChampionClass.Fighter) case ChampionClass.Mage:
{ return ChampionClassDto.Mage;
return ChampionClassDto.Fighter; case ChampionClass.Marksman:
} return ChampionClassDto.Marksman;
if (championClass == ChampionClass.Mage) case ChampionClass.Support:
{ return ChampionClassDto.Support;
return ChampionClassDto.Mage; case ChampionClass.Tank:
} return ChampionClassDto.Tank;
if (championClass == ChampionClass.Marksman) default:
{ return ChampionClassDto.Unknown;
return ChampionClassDto.Marksman;
}
if (championClass == ChampionClass.Support)
{
return ChampionClassDto.Support;
}
if (championClass == ChampionClass.Tank)
{
return ChampionClassDto.Tank;
}
else
{
return ChampionClassDto.Unknown;
} }
} }
public static ChampionClass ToModel(this ChampionClassDto championClass) public static ChampionClass ToModel(this ChampionClassDto championClass)
{ {
if (championClass == ChampionClassDto.Unknown) switch (championClass)
{ {
return ChampionClass.Unknown; case ChampionClassDto.Unknown:
} return ChampionClass.Unknown;
if (championClass == ChampionClassDto.Assassin) case ChampionClassDto.Assassin:
{ return ChampionClass.Assassin;
return ChampionClass.Assassin; case ChampionClassDto.Fighter:
} return ChampionClass.Fighter;
if (championClass == ChampionClassDto.Fighter) case ChampionClassDto.Mage:
{ return ChampionClass.Mage;
return ChampionClass.Fighter; case ChampionClassDto.Marksman:
} return ChampionClass.Marksman;
if (championClass == ChampionClassDto.Mage) case ChampionClassDto.Support:
{ return ChampionClass.Support;
return ChampionClass.Mage; case ChampionClassDto.Tank:
} return ChampionClass.Tank;
if (championClass == ChampionClassDto.Marksman) default:
{ return ChampionClass.Unknown;
return ChampionClass.Marksman;
}
if (championClass == ChampionClassDto.Support)
{
return ChampionClass.Support;
}
if (championClass == ChampionClassDto.Tank)
{
return ChampionClass.Tank;
}
else
{
return ChampionClass.Unknown;
} }
} }
} }

39
src/EntityFramework_LoL/Sources/ApiLol/Mapper/enums/RuneFamilyMapper.cs
Unescape View File

@ -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;
}
}
}
}

62
src/EntityFramework_LoL/Sources/ApiLol/Mapper/enums/SkillTypeMapper.cs
Unescape View File

@ -7,49 +7,35 @@ namespace ApiLol.Mapper
{ {
public static SkillTypeDto ToDto(this SkillType skillType) 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) 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;
} }
} }

6
src/EntityFramework_LoL/Sources/Client/ChampionHttpClient.cs
Unescape View File

@ -10,17 +10,17 @@ namespace Client
{ {
public class ChampionHttpClient public class ChampionHttpClient
{ {
private const string ApiChampions = "api/champions"; private const string UrlApiChampions = "/api/v3/champions";
private readonly HttpClient _httpClient; private readonly HttpClient _httpClient;
public ChampionHttpClient(HttpClient httpClient) public ChampionHttpClient(HttpClient httpClient)
{ {
_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) 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); return await _httpClient.GetFromJsonAsync<IEnumerable<ChampionDto>>(url);
} }
/* public async void Add(ChampionDto champion) /* public async void Add(ChampionDto champion)

1
src/EntityFramework_LoL/Sources/Client/Program.cs
Unescape View File

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

1
src/EntityFramework_LoL/Sources/DTO/PageRequest.cs
Unescape View File

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

1
src/EntityFramework_LoL/Sources/DTO/RuneDto.cs
Unescape View File

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

214
src/EntityFramework_LoL/Sources/Tests/ApiTests/ChampionsControllerTest.cs
Unescape View File

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

126
src/EntityFramework_LoL/Sources/Tests/ApiTests/SkinsControllerTest.cs
Unescape View File

@ -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);
}*/
}
}

2
src/EntityFramework_LoL/Sources/Tests/UT_EF/ChampionsTest.cs
Unescape View File

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

Write Preview
Loading…
Cancel
Save