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

just update Controllers 📀

Browse Source
pull/7/head
Emre KARTAL 2 years ago
parent 49a795992b
commit 7759337bcf
6 changed files with 640 additions and 432 deletions
Show Stats Download Patch File Download Diff File

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

Binary file not shown.

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

@ -1,43 +1,177 @@
using Microsoft.AspNetCore.Mvc;
// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
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
{
// GET: api/<RunesController>
[HttpGet]
public IEnumerable<string> Get()
{
private readonly IDataManager _manager;
private readonly ILogger<RunesController> _logger;
public RunesController(IDataManager dataManager, ILogger<RunesController> logger)
{
return new string[] { "value1", "value2" };
_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 string Get(string name)
{
return "value";
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 void Post([FromBody] string value)
{
}
// PUT api/<RunesController>/5
[HttpPut("{id}")]
public void Put(int id, [FromBody] string value)
{
[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("{id}")]
public void Delete(int id)
{
}
}
[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);
}
}
}
}

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

@ -1,183 +1,221 @@
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.count);
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($"Champion 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.ChampionsMgr.GetNbItems()));
if (dtos2.IsNullOrEmpty() || dtos2.Count() > 0)
{
return BadRequest($"New Name {skin.Name} is already exist");
}
}
var dtosChampion = (await _manager.ChampionsMgr.GetItemByName(skin.ChampionName, 0, await _manager.ChampionsMgr.GetNbItems()));
if (dtosChampion.IsNullOrEmpty())
{
_logger.LogWarning($"Champion Name : {skin.ChampionName} not exist");
return BadRequest($"Champion Name : {skin.ChampionName} not exist");
}
return Ok((await _manager.SkinsMgr.UpdateItem(dtos.First(), skin.ToModelC(dtosChampion.First()))).ToDtoC());
}
catch (Exception error)
{
_logger.LogError(error.Message);
return BadRequest(error.Message);
}
}
// DELETE api/<SkinsController>/5
[HttpDelete("{name}")]
public async Task<IActionResult> Delete(string name)
{
_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);
}
}
}
}
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);
}
}
}
}

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

@ -67,6 +67,20 @@ namespace ApiLol.Controllers.v1
}
[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)

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

@ -1,220 +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)
{
_logger.LogInformation("Executing {Action} - CHAMPION - V2.0 with parameters: {Parameters}", nameof(Get), pageRequest.count);
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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);
}
}
}
}

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

@ -40,9 +40,9 @@ namespace ApiTests
Assert.AreEqual(skinsResult.Count(), total);
}
}*/
[TestMethod]
/* [TestMethod]
public async Task TestPostSkin()
{
//Arange
@ -62,9 +62,9 @@ namespace ApiTests
var champions = objectResult?.Value as Ski;
Assert.IsNotNull(champions);
}
}*/
[TestMethod]
/* [TestMethod]
public async Task TestPutSkin()
{
//Arange

Write Preview
Loading…
Cancel
Save