private List <GameModel> GetGameModels(FcDeHoekContext context, DateTime fixtureDate)
{
var gameModels = new List <GameModel>();
var gamesToProcess = GameQueries.GetAllGamesBetweenDates(context, fixtureDate.AddDays(-3), fixtureDate.AddDays(4)).ToList();
foreach (var game in gamesToProcess)
{
gameModels.Add(new GameModel
{
AwayTeam = game.GameAwayTeam.Name,
Competition = game.GameCompetition.Description,
Forfait = game.Forfait,
GoalsAwayTeam = game.GoalsAwayTeam,
GoalsHomeTeam = game.GoalsHomeTeam,
HomeTeam = game.GameHomeTeam.Name,
IdHomeTeam = game.IdHomeTeam,
IdAwayTeam = game.IdAwayTeam,
IdCompetition = game.IdCompetition,
IdGame = game.IdGame,
IsPostPoned = game.NotPlayed,
MatchDay = game.MatchDate
});
}
return(gameModels);
}
public ActionResult Index()
{
using (var context = new FcDeHoekContext())
{
var model = new HomeModel
{
CurrentDivision = GetCurrentDivision(context),
PreviousGame = GameQueries.GetPreviousGame(context),
NextGame = GameQueries.GetNextGame(context),
NextGames = GameQueries.GetNextGames(context).ToList()
};
if (model.PreviousGame != null)
{
model.PreviousGameHomeTeam = TeamQueries.GetTeamById(context, model.PreviousGame.IdHomeTeam);
model.PreviousGameAwayTeam = TeamQueries.GetTeamById(context, model.PreviousGame.IdAwayTeam);
model.PreviousGameResult = model.PreviousGameHomeTeam.IdTeam == 1 ? eResult.GetResult(model.PreviousGame.GoalsHomeTeam, model.PreviousGame.GoalsAwayTeam) : eResult.GetResult(model.PreviousGame.GoalsAwayTeam, model.PreviousGame.GoalsHomeTeam);
}
if (model.NextGame != null)
{
model.NextGameHomeTeam = TeamQueries.GetTeamById(context, model.NextGame.IdHomeTeam);
model.NextGameAwayTeam = TeamQueries.GetTeamById(context, model.NextGame.IdAwayTeam);
}
model.AllTeams = context.Teams.ToList();
return(View(model));
}
}
private List <GameModel> GetGames(DateTime startDate, DateTime endDate)
{
using (var context = new FcDeHoekContext())
{
var gameModels = new List <GameModel>();
var games = GameQueries.GetAllGamesBetweenDates(context, startDate, endDate).OrderBy(g => g.MatchDate).ToList();
foreach (var game in games)
{
//var season = SeasonQueries.GetSeasonByDate(context, startDate);
gameModels.Add(new GameModel
{
IdGame = game.IdGame,
AwayTeam = game.GameAwayTeam.Name,
Competition = game.GameCompetition.Description,
HomeTeam = game.GameHomeTeam.Name,
MatchDay = game.MatchDate,
IdAwayTeam = game.IdAwayTeam,
IdHomeTeam = game.IdHomeTeam,
IdCompetition = game.IdCompetition,
IdSeason = game.IdSeason,
IsPostPoned = game.NotPlayed,
Forfait = game.Forfait,
IdPostPonedGame = game.IdPostPonedGame
});
}
return(gameModels);
}
}
private ScoreModel GetScores(DateTime?fixtureDate)
{
using (var context = new FcDeHoekContext())
{
if (fixtureDate == null)
{
fixtureDate = DateTime.Now.GetFirstDayOfWeek(CultureInfo.CurrentCulture);
}
var allGames = GameQueries.GetAllGamesByIdSeason(context, SeasonQueries.GetSeasonByDate(context, (DateTime)fixtureDate)?.IdSeason ?? SeasonQueries.GetCurrentSeason(context).IdSeason).OrderBy(g => g.MatchDate).ToList();
var allPlayWeeks = new List <DateTime>();
foreach (var game in allGames)
{
if (!allPlayWeeks.Contains(game.MatchDate))
{
allPlayWeeks.Add(game.MatchDate);
}
}
var model = new ScoreModel
{
AllFixtureDates = allPlayWeeks,
Games = GetGameModels(context, (DateTime)fixtureDate)
};
model.FixtureDate = model.Games.FirstOrDefault()?.MatchDay ?? DateTime.Now;
return(model);
}
}
private List <GameModel> GetGameModels(FcDeHoekContext context, List <Game> calendars, bool setIsNextGame = true)
{
var games = new List <GameModel>();
Game nextGame = null;
if (setIsNextGame)
{
nextGame = GameQueries.GetNextGame(context);
}
foreach (var calendar in calendars)
{
if (calendar.GameCompetition == null)
{
calendar.GameCompetition = context.BaseDomains.FirstOrDefault(bd => bd.IdBaseDomain == calendar.IdCompetition);
}
if (calendar.GameHomeTeam == null)
{
calendar.GameHomeTeam = TeamQueries.GetTeamById(context, calendar.IdHomeTeam);
}
if (calendar.GameAwayTeam == null)
{
calendar.GameAwayTeam = TeamQueries.GetTeamById(context, calendar.IdAwayTeam);
}
games.Add(new GameModel
{
IdGame = calendar.IdGame,
Competition = calendar.GameCompetition?.Description,
MatchDay = calendar.MatchDate.Date,
IdHomeTeam = calendar.IdHomeTeam,
HomeTeam = calendar.GameHomeTeam?.Name,
AwayTeam = calendar.GameAwayTeam?.Name,
IdAwayTeam = calendar.IdAwayTeam,
GameResult = calendar.IdHomeTeam == 1 ? eResult.GetResult(calendar.GoalsHomeTeam, calendar.GoalsAwayTeam) : eResult.GetResult(calendar.GoalsAwayTeam, calendar.GoalsHomeTeam),
Result = calendar.NotPlayed
? "Afgelast"
: !calendar.Forfait
? calendar.GoalsHomeTeam != null
? $"{calendar.GoalsHomeTeam} - {calendar.GoalsAwayTeam}"
: " - "
: calendar.GoalsHomeTeam != null
? $"{calendar.GoalsHomeTeam} - {calendar.GoalsAwayTeam} (F.F.)"
: "F.F.",
IsNextGame = calendar.IdGame == nextGame?.IdGame
});
}
return(games);
}
private Dictionary <DateTime, List <GameModel> > GetGamesPerDate(FcDeHoekContext context, List <Game> calendars)
{
var dictionary = new Dictionary <DateTime, List <GameModel> >();
var currentSeason = SeasonQueries.GetCurrentSeason(context);
var gamesDeHoek = GameQueries.GetAllGamesByIdSeasonAndIdTeam(context, currentSeason.IdSeason, 1).OrderBy(g => g.MatchDate).ToList();
foreach (var deHoekGame in gamesDeHoek)
{
var gamesForMatchDate = calendars.Where(c => c.MatchDate == deHoekGame.MatchDate).ToList();
dictionary.Add(deHoekGame.MatchDate, GetGameModels(context, gamesForMatchDate, false));
}
return(dictionary);
}
public ActionResult EditGame(int idGame)
{
using (var context = new FcDeHoekContext())
{
GameManagerModel manageModel;
if (idGame == 0)
{
manageModel = new GameManagerModel
{
Games = new List <GameModel> {
new GameModel()
},
Teams = context.Teams.ToList(),
CompetitionTypes = eCompetitionType.GetAllCompetitionTypes(),
AddAnother = false
};
}
else
{
var game = GameQueries.GetById(context, idGame);
manageModel = new GameManagerModel
{
Games = new List <GameModel> {
new GameModel
{
AwayTeam = game.GameAwayTeam.Name,
Competition = game.GameCompetition.Description,
Forfait = game.Forfait,
GoalsHomeTeam = game.GoalsHomeTeam,
GoalsAwayTeam = game.GoalsAwayTeam,
GameResult = 0,
HomeTeam = game.GameHomeTeam.Name,
IdAwayTeam = game.IdAwayTeam,
IdCompetition = game.IdCompetition,
IdGame = game.IdGame,
IdHomeTeam = game.IdHomeTeam,
MatchDay = game.MatchDate
}
},
Teams = context.Teams.ToList(),
CompetitionTypes = eCompetitionType.GetAllCompetitionTypes(),
AddAnother = false
};
}
return(View("Detail", manageModel));
}
}
public ActionResult AllGames()
{
using (var context = new FcDeHoekContext())
{
var currentSeason = SeasonQueries.GetCurrentSeason(context);
var calendars = GameQueries.GetAllGamesByIdSeason(context, currentSeason.IdSeason).OrderBy(g => g.MatchDate).ToList();
var model = new FullCalendarModel
{
SeasonDescription =
$"{currentSeason.SeasonStartYear} - {currentSeason.SeasonEndYear}",
GamesPerDate = GetGamesPerDate(context, calendars)
};
return(View(model));
}
}
public ReportController(
IAuthQueries authQueries,
ReportQueries queries,
BrandQueries brandQueries,
GameQueries gameQueries,
IPaymentQueries paymentQueries,
IEventBus eventBus)
{
_authQueries = authQueries;
_queries = queries;
_brandQueries = brandQueries;
_gameQueries = gameQueries;
_paymentQueries = paymentQueries;
_eventBus = eventBus;
}
public ActionResult Save(ScoreModel model)
{
using (var context = new FcDeHoekContext())
{
foreach (var gameModel in model.Games)
{
var game = GameQueries.GetById(context, gameModel.IdGame);
game.GoalsHomeTeam = gameModel.GoalsHomeTeam;
game.GoalsAwayTeam = gameModel.GoalsAwayTeam;
context.Games.AddOrUpdate(game);
context.SaveChanges();
}
return(RedirectToAction("EditScores", new { fixtureDate = model.FixtureDate }));
}
}
private void PostCharacterJoinedGameEvent(
RequestCache requestCache)
{
// Update the character state to match the new game
m_character_state.game_id = m_game_id;
m_character_state.game_name = GameQueries.GetGameName(requestCache.DatabaseContext, m_game_id);
// Add a note to the game event log that this new character joined the new game
GameEventQueries.AddEvent(
requestCache.DatabaseContext,
m_game_id,
new GameEvent_CharacterJoinedGame()
{
character_state = m_character_state
});
}
private void LookupGameIRCDetails(
RequestCache requestCache)
{
// $SECURITY
// Sending the IRC key unencrypted like this is not secure.
// We should be encrypting it with the client's public key RSA-style.
// Also we should re-generate this key any time some one removes their character from the game.
// Anytime a character joins the game we should assume that they can snoop on the IRC channel.
GameQueries.GetGameIRCDetails(
requestCache.DatabaseContext,
m_game_id,
out m_irc_enabled,
out m_irc_server,
out m_irc_port,
out m_irc_encryption_key,
out m_irc_encryption_enabled);
}
// GET: FcDeHoekGame
public ActionResult FcDeHoekGameDetail(int?idGame)
{
using (var context = new FcDeHoekContext())
{
Game game = null;
if (idGame == null)
{
game = GameQueries.GetPreviousGame(context);
}
else
{
game = GameQueries.GetById(context, (int)idGame);
}
var fcDeHoekGame = GetGameModel(context, game);
return(View("FcDeHoekGameDetail", fcDeHoekGame));
}
}
private List <FcDeHoekGame> GetAllFcDeHoekGames(FcDeHoekContext context, DateTime matchDate)
{
var gameModelList = new List <FcDeHoekGame>();
var season = SeasonQueries.GetSeasonByDate(context, matchDate) ?? SeasonQueries.GetCurrentSeason(context);
var games = GameQueries.GetAllGamesByIdSeasonAndIdTeam(context, season.IdSeason, 1).ToList();
foreach (var game in games)
{
gameModelList.Add(new FcDeHoekGame
{
IdGame = game.IdGame,
MatchDate = game.MatchDate,
GameFixture = $"{game.GameHomeTeam.Name} - {game.GameAwayTeam.Name}"
});
}
return(gameModelList);
}
public ActionResult Save(GameManagerModel model)
{
using (var context = new FcDeHoekContext())
{
var game = GameQueries.GetById(context, model.Games[0].IdGame);
if (game == null)
{
game = new Game();
}
foreach (var gameModel in model.Games)
{
game.GoalsAwayTeam = gameModel.GoalsAwayTeam;
game.GoalsHomeTeam = gameModel.GoalsHomeTeam;
game.Forfait = gameModel.Forfait;
game.IdCompetition = gameModel.IdCompetition;
game.IdAwayTeam = gameModel.IdAwayTeam;
game.IdHomeTeam = gameModel.IdHomeTeam;
game.IdPostPonedGame = gameModel.IdPostPonedGame;
game.IdSeason = SeasonQueries.GetSeasonByDate(context, gameModel.MatchDay)?.IdSeason ?? SeasonQueries.GetCurrentSeason(context).IdSeason;
game.MatchDate = gameModel.MatchDay;
game.NotPlayed = gameModel.IsPostPoned;
context.Games.AddOrUpdate(game);
context.SaveChanges();
}
if (model.AddAnother)
{
if (model.Games.Count > 1)
{
return(RedirectToAction("AddMultipleGames", "GameManager", new { idGame = 0 }));
}
else
{
return(RedirectToAction("EditGame", "GameManager", new { idGame = 0 }));
}
}
return(RedirectToAction("Index", "GameManager"));
}
}
private List <RecordsTempData> GetCurrentData(FcDeHoekContext context, List <RecordsTempData> historicData, int idSeason = -1)
{
var allPlayers = PersonQueries.GetPlayers(context).ToList();
foreach (var player in allPlayers)
{
var stats = PersonStatisticsQueries.GetByIdPerson(context, player.IdPerson).ToList();
if (stats.Any())
{
var tempData = new RecordsTempData
{
IdPlayer = player.IdPerson,
Player = $"{player.Name} {player.FirstName}"
};
foreach (var stat in stats)
{
var game = GameQueries.GetById(context, stat.IdGame);
if (game != null && game.IdCompetition == eCompetitionType.League && (game.IdSeason == idSeason || idSeason == -1))
{
if ((stat.Goals != null && stat.Goals != 0) || stat.Assists != 0)
{
var playersHistoricData =
historicData.FirstOrDefault(hd => hd.IdPlayer == player.IdPerson);
if (playersHistoricData != null)
{
playersHistoricData.Assists += stat.Assists;
playersHistoricData.Goals += stat.Goals ?? 0;
}
else
{
tempData.Assists += stat.Assists;
tempData.Goals += stat.Goals ?? 0;
historicData.Add(tempData);
}
}
}
}
}
}
return(historicData);
}
protected bool VerifyGameExists(
RequestCache requestCache,
int current_game_id,
out string result_code)
{
bool success;
if (GameQueries.VerifyGameExists(requestCache.DatabaseContext, current_game_id))
{
result_code = SuccessMessages.GENERAL_SUCCESS;
success = true;
}
else
{
result_code = ErrorMessages.INVALID_GAME;
success = false;
}
return(success);
}
protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
result_code = SuccessMessages.GENERAL_SUCCESS;
// Get the list of games without character names
gameList = GameQueries.GetGameList(requestCache.DatabaseContext);
// For each game, get the character list
foreach (GameResponseEntry entry in gameList)
{
entry.character_names =
GameQueries.GetCharacterNamesInGame(
requestCache.DatabaseContext,
entry.game_id);
}
return(true);
}
protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
bool success = false;
result_code = SuccessMessages.GENERAL_SUCCESS;
if (GameQueries.VerifyAccountOwnsGame(requestCache.DatabaseContext, m_account_id, m_game_id))
{
GameQueries.DeleteGame(requestCache.DatabaseContext, m_game_id);
WorldCache.ClearWorld(requestCache.SessionCache, m_game_id);
success = true;
}
else
{
result_code = ErrorMessages.NOT_GAME_OWNER;
}
return(success);
}
protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
bool success = false;
result_code = SuccessMessages.GENERAL_SUCCESS;
m_new_game_id =
GameQueries.CreateGame(
requestCache.DatabaseContext,
m_account_id,
m_game_name,
m_dungeon_size,
m_dungeon_difficulty,
m_irc_enabled,
m_irc_server,
m_irc_port,
m_irc_encryption_enabled);
if (m_new_game_id >= 0)
{
success =
WorldCache.BuildWorld(
requestCache.DatabaseContext,
requestCache.SessionCache,
m_new_game_id,
out result_code);
if (!success)
{
GameQueries.DeleteGame(requestCache.DatabaseContext, m_new_game_id);
}
}
return(success);
}
private List <RankModel> BuildLeagueRanking()
{
using (var context = new FcDeHoekContext())
{
var model = new List <RankModel>();
var allGames = GameQueries.GetAllGamesByIdSeasonAndIdCompetition(context,
SeasonQueries.GetCurrentSeason(context).IdSeason, eCompetitionType.League).ToList();
var allPlayedGames = allGames.Where(g => g.GoalsHomeTeam != null && g.GoalsAwayTeam != null).ToList();
var teams = new List <string>();
teams.AddRange(allGames.Select(g => g.GameHomeTeam.Name).Distinct().ToList());
teams.AddRange(allGames.Select(g => g.GameAwayTeam.Name).Distinct().ToList());
teams = teams.Distinct().ToList();
if (teams.Count < allPlayedGames.Count && allPlayedGames.Count == 0)
{
return(CreateZeroRanking(teams));
}
foreach (var team in teams)
{
var ranking = new RankModel {
Team = team
};
var homeGames = allPlayedGames.Where(g => g.GameHomeTeam.Name == team).ToList();
foreach (var homeGame in homeGames)
{
ranking.GoalsScored += homeGame.GoalsHomeTeam ?? 0;
ranking.GoalsConceded += homeGame.GoalsAwayTeam ?? 0;
if (homeGame.GoalsHomeTeam > homeGame.GoalsAwayTeam)
{
ranking.GamesWon += 1;
}
else if (homeGame.GoalsHomeTeam == homeGame.GoalsAwayTeam)
{
ranking.GamesDrawn += 1;
}
else
{
ranking.GamesLost += 1;
}
ranking.GamesPlayed++;
}
var awayGames = allPlayedGames.Where(g => g.GameAwayTeam.Name == team).ToList();
foreach (var awayGame in awayGames)
{
ranking.GoalsScored += awayGame.GoalsAwayTeam ?? 0;
ranking.GoalsConceded += awayGame.GoalsHomeTeam ?? 0;
if (awayGame.GoalsAwayTeam > awayGame.GoalsHomeTeam)
{
ranking.GamesWon += 1;
}
else if (awayGame.GoalsHomeTeam == awayGame.GoalsAwayTeam)
{
ranking.GamesDrawn += 1;
}
else
{
ranking.GamesLost += 1;
}
ranking.GamesPlayed++;
}
model.Add(ranking);
}
foreach (var ranking in model)
{
ranking.Points = (ranking.GamesWon * 3) + ranking.GamesDrawn;
}
return(model.OrderByDescending(m => m.Points).ThenByDescending(m => m.GamesWon).ThenByDescending(m => (m.GoalsScored - m.GoalsConceded)).ThenByDescending(m => m.GoalsScored).ToList());
}
}
private void LeaveGame(
RequestCache requestCache)
{
GameQueries.UnBindCharacterFromGame(requestCache.DatabaseContext, m_character_id);
}
private void JoinGame(
RequestCache requestCache)
{
GameQueries.BindCharacterToGame(requestCache.DatabaseContext, m_character_id, m_game_id);
}
private StatisticsModel GetPlayerStats(FcDeHoekContext context, int idPerson)
{
var stats = new StatisticsModel
{
FriendlyGamesPlayed = 0,
GoalsInFriendly = 0,
AssistsInFriendly = 0,
LeagueGamesPlayed = 0,
GoalsInLeague = 0,
AssistsInLeague = 0,
CupGamesPlayed = 0,
GoalsInCup = 0,
AssistsInCup = 0,
};
var allPlayerStats = PersonStatisticsQueries.GetByIdPerson(context, idPerson).ToList();
var season = SeasonQueries.GetCurrentSeason(context);
var leagueGameIds = GameQueries.GetAllGamesByIdSeasonAndIdCompetition(context, season.IdSeason, eCompetitionType.League).Select(lg => lg.IdGame).ToList();
var friendlyGameIds = GameQueries.GetAllGamesByIdSeasonAndIdCompetition(context, season.IdSeason, eCompetitionType.Friendly).Select(lf => lf.IdGame).ToList();
var cupGameIds = GameQueries.GetAllGamesByIdSeasonAndIdCompetition(context, season.IdSeason, eCompetitionType.Cup).Select(lc => lc.IdGame).ToList();
foreach (var playerStat in allPlayerStats)
{
if (leagueGameIds.Contains(playerStat.IdGame))
{
if (playerStat.Played ?? false)
{
stats.LeagueGamesPlayed++;
}
stats.GoalsInLeague += playerStat.Goals ?? 0;
stats.AssistsInLeague += playerStat.Assists;
}
if (friendlyGameIds.Contains(playerStat.IdGame))
{
if (playerStat.Played ?? false)
{
stats.FriendlyGamesPlayed++;
}
stats.GoalsInFriendly += playerStat.Goals ?? 0;
stats.AssistsInFriendly += playerStat.Assists;
}
if (cupGameIds.Contains(playerStat.IdGame))
{
if (playerStat.Played ?? false)
{
stats.CupGamesPlayed++;
}
stats.GoalsInCup += playerStat.Goals ?? 0;
stats.AssistsInCup += playerStat.Assists;
}
}
stats.TotalGamesPlayed = stats.FriendlyGamesPlayed + stats.LeagueGamesPlayed + stats.CupGamesPlayed;
stats.TotalGoalsScored = stats.GoalsInFriendly + stats.GoalsInLeague + stats.GoalsInCup;
stats.TotalAssists = stats.AssistsInFriendly + stats.AssistsInLeague + stats.AssistsInCup;
return(stats);
}
public Game GetById(int id)
{
return(_context.Game.FirstOrDefault(GameQueries.ExpById(id)));
}
