public async Task <IActionResult> Editor(int id, string sortOrder, string currentFilter, int?pageNumber)
{
var editor = await _context.Editors
.FirstOrDefaultAsync(m => m.Id == id);
if (editor == null)
{
return(NotFound());
}
ViewBag.EditorName = editor.Name;
ViewBag.EditorDesc = editor.Description;
IQueryable <Game> games = _gameService.GetGamesByEditor(id);
games = _gameService.GetGamesValidate(games);
GamesIndexData gamesAllData = await SortGames(currentFilter, sortOrder, currentFilter, pageNumber, games);
bool isAuthenticated = User.Identity.IsAuthenticated;
if (isAuthenticated)
{
LudothequeUser user = await UserServices.GetUserAsync(userManager, User.Identity.Name);
gamesAllData = _gameAllDataService.GamesPoss(gamesAllData, user.Id);
}
else
{
gamesAllData = _gameAllDataService.NoGamesPoss(gamesAllData);
}
return(View(gamesAllData));
}
public List <Game> GetGamesPages(GamesIndexData games, int pageNumber, int pageSize)
{
var PageIndex = pageNumber;
var count = games.Games.Count();
var items = games.Games.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList();
var TotalPages = (int)Math.Ceiling(count / (double)pageSize);
return(items);
}
/// <summary>
/// Method to fill posseded games with all false
/// </summary>
/// <param name="gamesAllData">games to fill</param>
/// <returns></returns>
internal GamesIndexData NoGamesPoss(GamesIndexData gamesAllData)
{
List <(Game, bool)> ls = new List <(Game, bool)>();
foreach (Game g in gamesAllData.Games)
{
ls.Add((g, false));
}
gamesAllData.GamesPoss = ls;
return(gamesAllData);
}
/// <summary>
/// Fill posseded games of gamesAllData for user
/// </summary>
/// <param name="gamesAllData"></param>
/// <param name="userId"></param>
/// <returns></returns>
public GamesIndexData GamesPoss(GamesIndexData gamesAllData, string userId)
{
List <(Game, bool)> ls = new List <(Game, bool)>();
foreach (Game g in gamesAllData.Games)
{
bool FindGame = userId != null && _context.GamesUser.SingleOrDefault(s => s.GameId == g.Id && s.LudothequeUserId.Equals(userId)) != null;
if (FindGame)
{
ls.Add((g, true));
}
else
{
ls.Add((g, false));
}
}
gamesAllData.GamesPoss = ls;
return(gamesAllData);
}
/// <summary>
/// Method to create games with theme, mechanisms and materials supports
/// </summary>
/// <returns></returns>
public async Task <GamesIndexData> GetGamesAndCategories(IQueryable <Game> games = null)
{
if (games == null)
{
games = _context.Games;
}
var viewModel = new GamesIndexData();
viewModel.Games = await games
.Include(i => i.MechanismsGames)
.ThenInclude(i => i.Mechanism)
.Include(i => i.ThemesGames)
.ThenInclude(i => i.Theme)
.Include(i => i.MaterialSupportsGames)
.ThenInclude(i => i.MaterialSupport)
.AsNoTracking()
.OrderBy(i => i.Name)
.ToListAsync();
return(viewModel);
}
/// <summary>
/// Controller for list of games no validate
/// </summary>
/// <param name="searchString"></param>
/// <param name="sortOrder"></param>
/// <param name="currentFilter"></param>
/// <param name="pageNumber"></param>
/// <returns></returns>
public async Task <IActionResult> ProposedGames(string searchString, string sortOrder, string currentFilter, int?pageNumber)
{
IQueryable <Game> games;
if (!String.IsNullOrEmpty(searchString))
{
games = _gameService.GetGamesByName(searchString);
pageNumber = 1;
}
else
{
games = _gameService.GetGames();
searchString = currentFilter;
}
games = _gameService.GetGamesNoValidate(games);
GamesIndexData gamesAllData = await _gameAllDataService.GetGamesAndCategories(games);
gamesAllData = _gameAllDataService.GamesPoss(gamesAllData, null);
ViewBag.MyGames = "Neither";
return(View(gamesAllData));
}
/// <summary>
/// Sort Games with all data
/// </summary>
/// <param name="games"></param>
/// <param name="pageNumber"></param>
/// <param name="sortOrder"></param>
/// <returns></returns>
public async Task <GamesIndexData> SortGamesIndex(IQueryable <Game> games, int?pageNumber, string sortOrder)
{
GamesIndexData gamesAllData = new GamesIndexData();
games = _gameServices.SortGames(games, sortOrder);
int pageSize = 3;
PaginatedList <Game> pl =
await PaginatedList <Game> .CreateAsync(games, pageNumber ?? 1, pageSize);
var gamesTmp = from g in games
where pl.Contains(g)
select g;
gamesAllData = await GetGamesAndCategories(gamesTmp);
gamesAllData = _gameServices.SortGames(gamesAllData, sortOrder);
gamesAllData.PageIndex = pl.PageIndex;
gamesAllData.TotalPages = pl.TotalPages;
return(gamesAllData);
}
public async Task <IActionResult> Index(string searchString, string sortOrder, string currentFilter, int?pageNumber)
{
//Todo : Si ecran trop petit afficher des colonnes en moins
//Todo : limiter le nombre de catégories montrées a 3
//Todo : Probleme si critères vide sort ne trie pas bien
IQueryable <Game> games;
if (!String.IsNullOrEmpty(searchString))
{
games = _gameService.GetGamesByName(searchString);
pageNumber = 1;
}
else
{
games = _gameService.GetGames();
searchString = currentFilter;
}
games = _gameService.GetGamesValidate(games);
GamesIndexData gamesAllData = await SortGames(searchString, sortOrder, currentFilter, pageNumber, games);
bool isAuthenticated = User.Identity.IsAuthenticated;
if (isAuthenticated)
{
LudothequeUser user = await UserServices.GetUserAsync(userManager, User.Identity.Name);
gamesAllData = _gameAllDataService.GamesPoss(gamesAllData, user.Id);
}
else
{
gamesAllData = _gameAllDataService.NoGamesPoss(gamesAllData);
}
return(View(gamesAllData));
}
internal GamesIndexData SortGames(GamesIndexData gamesAllData, string sortOrder)
{
var games = gamesAllData.Games;
games = sortOrder switch
{
"name_desc" => games.OrderByDescending(s => s.Name),
"Date" => games.OrderBy(s => s.ReleaseDate),
"date_desc" => games.OrderByDescending(s => s.ReleaseDate),
"Price" => games.OrderBy(s => s.Price),
"price_desc" => games.OrderByDescending(s => s.Price),
"Min" => games.OrderBy(s => s.MinPlayer),
"min_desc" => games.OrderByDescending(s => s.MinPlayer),
"Max" => games.OrderBy(s => s.MaxPlayer),
"max_desc" => games.OrderByDescending(s => s.MaxPlayer),
"Age" => games.OrderBy(s => s.MinimumAge),
"age_desc" => games.OrderByDescending(s => s.MinimumAge),
"Time" => games.OrderBy(s => s.GameTime),
"time_desc" => games.OrderByDescending(s => s.GameTime),
_ => games.OrderBy(s => s.Name),
};
gamesAllData.Games = games;
return(gamesAllData);
}
public async Task <IActionResult> Index(string searchString, string sortOrder, string currentFilter, int?pageNumber)
{
LudothequeUser user = await UserServices.GetUserAsync(userManager, User.Identity.Name);
IQueryable <Game> games;
games = _gameService.GetGamesByUser(user.Id);
if (!String.IsNullOrEmpty(searchString))
{
games = _gameService.GetGamesByName(searchString, games);
pageNumber = 1;
}
else
{
searchString = currentFilter;
}
games = _gameService.GetGamesValidate(games);
GamesIndexData gamesAllData = await SortGames(searchString, sortOrder, currentFilter, pageNumber, games);
gamesAllData = _gameAllDataService.GamesPoss(gamesAllData, user.Id);
ViewBag.MyGames = "true";
return(View(gamesAllData));
}
public static async Task <PaginatedList <Game> > CreateAsync(GamesIndexData gamesAllData, int pageIndex, int pageSize)
{
var source = gamesAllData.Games.AsQueryable().AsNoTracking();
return(await PaginatedList <Game> .CreateAsync(source, pageIndex, pageSize));
}
/// <summary>
/// Just for transform five games of GamesIndexData as Queryable for SortGames
/// </summary>
/// <param name="games"></param>
/// <param name="sortOrder"></param>
/// <returns></returns>
public GamesIndexData SortGamesIndexData(GamesIndexData games, string sortOrder)
{
games.Games = _gameServices.SortGames(games.Games.AsQueryable(), sortOrder);
return(games);
}
/// <summary>
/// Get all games that contain the searchString in name
/// </summary>
/// <param name="searchString">Param wanted by user</param>
/// <param name="gamesList">If we want do this research on a precise lsit of games</param>
/// <returns></returns>
public async Task <GamesIndexData> GetGamesByName(string searchString, GamesIndexData gamesList = null)
{
var games = _gameServices.GetGamesByName(searchString);;
return(await GetGamesAndCategories(games));
}
