/// <summary>
/// If there is no real life data between seasons,
/// change some match dates to around now for testing purposes
/// </summary>
private static void RandomizeMatchDatesForTestingPurposes(TtcDbContext context)
{
bool endOfSeason = !context.Matches.Any(match => match.Date > DateTime.Now);
if (true || endOfSeason)
{
int currentFrenoySeason = context.CurrentFrenoySeason;
var passedMatches = context.Matches
.Where(x => x.FrenoySeason == currentFrenoySeason)
//.Where(x => x.Date < DateTime.Today)
.OrderByDescending(x => x.Date)
.Take(42);
var timeToAdd = DateTime.Today - passedMatches.First().Date;
foreach (var match in passedMatches.Take(20))
{
match.Date = match.Date.Add(timeToAdd);
}
var rnd = new Random();
foreach (var match in passedMatches.Take(20))
{
match.Date = DateTime.Today.Add(TimeSpan.FromDays(rnd.Next(1, 20))).AddHours(rnd.Next(10, 20));
match.Description = "";
match.AwayScore = null;
match.HomeScore = null;
//match.IsSyncedWithFrenoy = true;
match.WalkOver = false;
context.MatchComments.RemoveRange(match.Comments.ToArray());
context.MatchGames.RemoveRange(match.Games.ToArray());
context.MatchPlayers.RemoveRange(match.Players.ToArray());
}
}
}
public async Task <Player> UpdatePlayer(Player player)
{
using (var dbContext = new TtcDbContext())
{
var existingSpeler = await dbContext.Players.FirstOrDefaultAsync(x => x.Id == player.Id);
if (existingSpeler == null)
{
existingSpeler = new PlayerEntity();
MapPlayer(player, existingSpeler);
dbContext.Players.Add(existingSpeler);
}
else
{
MapPlayer(player, existingSpeler);
}
await dbContext.SaveChangesAsync();
player.Id = existingSpeler.Id;
}
var newPlayer = await GetPlayer(player.Id);
return(newPlayer);
}
static void Main(string[] args)
{
using (var context = new TtcDbContext())
{
try
{
// This code can be triggered from the UI!
// Admin > Spelers > Frenoy Sync button (float: right)
//var vttlPlayers = new FrenoyPlayersApi(context, Competition.Vttl);
//vttlPlayers.StopAllPlayers(true);
//vttlPlayers.SyncPlayers();
//var sportaPlayers = new FrenoyPlayersApi(context, Competition.Sporta);
//sportaPlayers.SyncPlayers();
// This code can be triggered by deploying a new migration
// --> No more at the moment with asyncy stuff see README.
var vttl = new FrenoyMatchesApi(context, Competition.Vttl);
vttl.SyncTeamsAndMatches();
var sporta = new FrenoyMatchesApi(context, Competition.Sporta);
sporta.SyncTeamsAndMatches();
//RandomizeMatchDatesForTestingPurposes(context);
context.SaveChanges();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.ReadKey();
}
}
}
public async Task <string> SetNewPassword(PasswordCredentials request)
{
using (var dbContext = new TtcDbContext())
{
PlayerEntity player;
if (request.PlayerId == SystemPlayerIdFromFrontend)
{
player = await dbContext.Players.SingleAsync(ply => ply.NaamKort == "SYSTEM");
}
else
{
player = await dbContext.Players.SingleOrDefaultAsync(x => x.Id == request.PlayerId);
}
if (player != null)
{
await dbContext.Database.ExecuteSqlCommandAsync(
$"UPDATE {PlayerEntity.TableName} SET paswoord=MD5({{1}}) WHERE id={{0}}",
player.Id,
request.NewPassword);
return(player.Email);
}
return(null);
}
}
public ICollection<Match> GetMatches()
{
if (MatchesPlaying)
{
return _matches;
}
using (var dbContext = new TtcDbContext())
{
var matchEntities = dbContext.Matches
.WithIncludes()
//.Where(x => x.Id == 802)
.Where(x => x.HomeClubId == Constants.OwnClubId || x.AwayClubId == Constants.OwnClubId)
.Where(x => x.FrenoySeason == Constants.FrenoySeason)
.ToList();
var matchIds = matchEntities.Select(x => x.Id).ToArray();
var comments = dbContext.MatchComments.Where(x => matchIds.Contains(x.MatchId)).ToArray();
foreach (var match in matchEntities)
{
match.Comments = comments.Where(x => x.MatchId == match.Id).ToArray();
}
var result = Mapper.Map<IList<MatchEntity>, IList<Match>>(matchEntities);
if (result.Any(m => m.ScoreType == MatchOutcome.BeingPlayed))
{
_matches = result;
MatchesPlaying = true;
}
return result;
}
}
public async Task <User> GetUser(int playerId)
{
using (var dbContext = new TtcDbContext())
{
return(await GetUser(dbContext, playerId));
}
}
public async Task <IEnumerable <Team> > GetForCurrentYear()
{
using (var dbContext = new TtcDbContext())
{
int currentSeason = dbContext.CurrentSeason;
var teams = await dbContext.Teams
.Include(x => x.Players)
.Include(x => x.Opponents)
.Where(x => x.Year == currentSeason)
.ToArrayAsync();
var result = Mapper.Map <IList <TeamEntity>, IList <Team> >(teams);
foreach (var team in result)
{
var key = new TeamRankingKey(team.Competition, team.Frenoy.DivisionId);
if (RankingCache.ContainsKey(key))
{
team.Ranking = RankingCache[key];
}
}
InvalidateCache();
return(result);
}
}
public async Task <byte[]> GetExcelExport()
{
using (var dbContext = new TtcDbContext())
{
int currentSeason = dbContext.CurrentSeason;
var teams = await dbContext.Teams
.Include(x => x.Players)
//.Include(x => x.Opponents)
.Where(x => x.Year == currentSeason)
.ToArrayAsync();
int currentFrenoySeason = dbContext.CurrentFrenoySeason;
var matches = await dbContext.Matches
//.Include(x => x.HomeTeam)
//.Include(x => x.AwayTeam)
.Include(x => x.Players)
.Where(x => x.HomeClubId == Constants.OwnClubId || x.AwayClubId == Constants.OwnClubId)
.Where(x => x.FrenoySeason == currentFrenoySeason)
.ToListAsync();
var players = await dbContext.Players.Where(x => x.Gestopt == null).ToArrayAsync();
var clubs = await dbContext.Clubs.ToArrayAsync();
var exceller = TeamsExcelCreator.CreateFormation(teams, matches, players, clubs);
return(exceller.Create());
}
}
public void FindInvalidPlayerRecords()
{
using (var dbContext = new TtcDbContext())
{
foreach (PlayerEntity speler in dbContext.Players)
{
if (speler.ClubIdVttl.HasValue)
{
Assert.That(speler.ClubIdVttl, Is.Not.Null);
Assert.That(speler.IndexVttl, Is.Not.Null);
Assert.That(speler.LinkKaartVttl, Is.Not.Null);
Assert.That(speler.KlassementVttl, Is.Not.Null);
Assert.That(speler.ComputerNummerVttl, Is.Not.Null);
Assert.That(speler.VolgnummerVttl, Is.Not.Null);
}
if (speler.ClubIdSporta.HasValue)
{
Assert.That(speler.ClubIdSporta, Is.Not.Null);
Assert.That(speler.IndexSporta, Is.Not.Null);
Assert.That(speler.LinkKaartSporta, Is.Not.Null);
Assert.That(speler.KlassementSporta, Is.Not.Null);
Assert.That(speler.LidNummerSporta, Is.Not.Null);
Assert.That(speler.VolgnummerSporta, Is.Not.Null);
}
}
}
}
public async Task <Match> SetMyFormation(MatchPlayer matchPlayer)
{
using (var dbContext = new TtcDbContext())
{
var existingPlayer = await dbContext.MatchPlayers
.Include(x => x.Match)
.Where(x => x.MatchId == matchPlayer.MatchId && x.PlayerId == matchPlayer.PlayerId)
.FirstOrDefaultAsync(x => x.Status != PlayerMatchStatus.Captain && x.Status != PlayerMatchStatus.Major);
if (existingPlayer != null)
{
existingPlayer.Status = matchPlayer.Status;
existingPlayer.StatusNote = matchPlayer.StatusNote;
}
else
{
var verslagSpeler = Mapper.Map <MatchPlayer, MatchPlayerEntity>(matchPlayer);
dbContext.MatchPlayers.Add(verslagSpeler);
}
await dbContext.SaveChangesAsync();
}
var newMatch = await GetMatch(matchPlayer.MatchId);
return(newMatch);
}
/// <summary>
/// Toggle Captain/Major player by any player of the team on the day of the match
/// </summary>
public async Task <Match> ToggleMatchPlayer(MatchPlayer matchPlayer)
{
Debug.Assert(matchPlayer.Status == PlayerMatchStatus.Captain || matchPlayer.Status == PlayerMatchStatus.Major);
using (var dbContext = new TtcDbContext())
{
var match = await dbContext.Matches.FindAsync(matchPlayer.MatchId);
if (match == null || match.IsSyncedWithFrenoy)
{
return(await GetMatch(matchPlayer.MatchId));
}
var existingPlayer = await dbContext.MatchPlayers
.Where(x => x.MatchId == matchPlayer.MatchId && x.PlayerId == matchPlayer.PlayerId)
.FirstOrDefaultAsync(x => x.Status == matchPlayer.Status);
match.Block = matchPlayer.Status;
if (existingPlayer != null)
{
dbContext.MatchPlayers.Remove(existingPlayer);
}
else
{
dbContext.MatchPlayers.Add(Mapper.Map <MatchPlayer, MatchPlayerEntity>(matchPlayer));
}
await dbContext.SaveChangesAsync();
}
var newMatch = await GetMatch(matchPlayer.MatchId);
return(newMatch);
}
private async Task <Match> GetMatch(TtcDbContext dbContext, int matchId)
{
var match = await dbContext.Matches
.WithIncludes()
.SingleOrDefaultAsync(x => x.Id == matchId);
if (match == null)
{
return(null);
}
var comments = await dbContext.MatchComments.Where(x => x.MatchId == matchId).ToArrayAsync();
match.Comments = comments;
var matchModel = Map(match);
if (MatchesPlaying)
{
var cachedMatch = _matches.Single(x => x.Id == matchModel.Id);
int matchIndex = _matches.IndexOf(cachedMatch);
_matches[matchIndex] = matchModel;
}
return(matchModel);
}
public IEnumerable<Team> GetForCurrentYear()
{
using (var dbContext = new TtcDbContext())
{
var teams = dbContext.Teams
.Include(x => x.Players)
.Include(x => x.Opponents)
.Where(x => x.Year == Constants.CurrentSeason)
.ToArray();
var result = Mapper.Map<IList<TeamEntity>, IList<Team>>(teams);
foreach (var team in result)
{
var key = new TeamRankingKey(team.Competition, team.Frenoy.DivisionId);
if (RankingCache.ContainsKey(key))
{
team.Ranking = RankingCache[key];
}
}
InvalidateCache();
return result;
}
}
public async Task <EmailConfig> GetEmailConfig()
{
using (var context = new TtcDbContext())
{
var sendGridApiKey = (await context.Parameters.SingleAsync(x => x.Sleutel == "SendGridApiKey")).Value;
var fromEmail = (await context.Parameters.SingleAsync(x => x.Sleutel == "FromEmail")).Value;
return(new EmailConfig(fromEmail, sendGridApiKey));
}
}
public async Task <(byte[] file, SportaMatchFileInfo fileInfo)> GetExcelExport(int matchId, bool fillInOurTeam = true)
{
using (var dbContext = new TtcDbContext())
{
var exceller = await CreateExcelCreator(matchId, dbContext);
return(exceller.Create(fillInOurTeam), exceller.FileInfo);
}
}
public async Task <Match> FrenoyMatchSync(int matchId, bool forceSync)
{
using (var dbContext = new TtcDbContext())
{
await FrenoyMatchSyncCore(dbContext, matchId, forceSync);
return(await GetMatch(dbContext, matchId));
}
}
public EmailConfig GetEmailConfig()
{
using (var context = new TtcDbContext())
{
var sendGridApiKey = context.Parameters.Single(x => x.Sleutel == "SendGridApiKey").Value;
var fromEmail = context.Parameters.Single(x => x.Sleutel == "FromEmail").Value;
return new EmailConfig(fromEmail, sendGridApiKey);
}
}
public async Task <byte[]> GetExcelExport()
{
using (var dbContext = new TtcDbContext())
{
var activePlayers = await dbContext.Players.Where(x => x.Gestopt == null).ToArrayAsync();
var exceller = new PlayersExcelCreator(activePlayers);
return(exceller.Create());
}
}
public async Task FrenoyTeamSync(int teamId)
{
using (var db = new TtcDbContext())
{
var team = await db.Teams.SingleAsync(x => x.Id == teamId);
var frenoySync = new FrenoyMatchesApi(db, Constants.NormalizeCompetition(team.Competition));
await frenoySync.SyncTeamMatches(team);
}
}
public async Task DeleteBoardMember(int playerId)
{
using (var context = new TtcDbContext())
{
var board = await context.ClubContacten.SingleAsync(x => x.SpelerId == playerId);
context.ClubContacten.Remove(board);
await context.SaveChangesAsync();
}
}
public async Task <Match> DeleteComment(int commentId)
{
using (var dbContext = new TtcDbContext())
{
var comment = await dbContext.MatchComments.SingleAsync(x => x.Id == commentId);
dbContext.MatchComments.Remove(comment);
await dbContext.SaveChangesAsync();
return(await GetMatch(dbContext, comment.MatchId));
}
}
public async Task <OtherMatch> FrenoyOtherMatchSync(int matchId)
{
using (var dbContext = new TtcDbContext())
{
await FrenoyMatchSyncCore(dbContext, matchId, false);
var match = dbContext.Matches
.WithIncludes()
.Single(x => x.Id == matchId);
return(Mapper.Map <MatchEntity, OtherMatch>(match));
}
}
public async Task <Match> GetMatch(int matchId, bool allowCache = false)
{
if (allowCache && _matches != null)
{
var ply = _matches.SingleOrDefault(x => x.Id == matchId);
return(ply ?? await GetMatch(matchId));
}
using (var dbContext = new TtcDbContext())
{
return(await GetMatch(dbContext, matchId));
}
}
public async Task FrenoySync()
{
using (var context = new TtcDbContext())
{
var vttlPlayers = new FrenoyPlayersApi(context, Competition.Vttl);
await vttlPlayers.StopAllPlayers(false);
await vttlPlayers.SyncPlayers();
var sportaPlayers = new FrenoyPlayersApi(context, Competition.Sporta);
await sportaPlayers.SyncPlayers();
}
}
public Match GetMatch(int matchId, bool allowCache = false)
{
if (allowCache && _matches != null)
{
var ply = _matches.SingleOrDefault(x => x.Id == matchId);
return ply ?? GetMatch(matchId);
}
using (var dbContext = new TtcDbContext())
{
return GetMatch(dbContext, matchId);
}
}
public async Task <Match> AddComment(MatchComment comment)
{
using (var dbContext = new TtcDbContext())
{
var entity = Mapper.Map <MatchCommentEntity>(comment);
entity.PostedOn = TtcDbContext.GetCurrentBelgianDateTime();
dbContext.MatchComments.Add(entity);
await dbContext.SaveChangesAsync();
}
var newMatch = await GetMatch(comment.MatchId);
return(newMatch);
}
public async Task <Match> UpdateReport(MatchReport report)
{
using (var dbContext = new TtcDbContext())
{
var existingMatch = await dbContext.Matches.FirstAsync(x => x.Id == report.MatchId);
existingMatch.ReportPlayerId = report.PlayerId;
existingMatch.Description = report.Text;
await dbContext.SaveChangesAsync();
}
var newMatch = await GetMatch(report.MatchId);
return(newMatch);
}
private static async Task FrenoyMatchSyncCore(TtcDbContext dbContext, int matchId, bool forceSync)
{
var match = await dbContext.Matches
.WithIncludes()
.Include(x => x.HomeTeam)
.Include(x => x.AwayTeam)
.SingleAsync(x => x.Id == matchId);
if (forceSync || (match.Date < DateTime.Now && !match.IsSyncedWithFrenoy))
{
var frenoySync = new FrenoyMatchesApi(dbContext, match.Competition, forceSync);
await frenoySync.SyncMatchDetails(match);
}
}
public async Task DeletePlayer(int playerId)
{
using (var dbContext = new TtcDbContext())
{
var player = await dbContext.Players.FindAsync(playerId);
if (player == null)
{
return;
}
dbContext.Players.Remove(player);
await dbContext.SaveChangesAsync();
}
}
public ICollection<OtherMatch> GetLastOpponentMatches(int teamId, OpposingTeam opponent)
{
using (var dbContext = new TtcDbContext())
{
var team = dbContext.Teams.Single(x => x.Id == teamId);
var frenoy = new FrenoyMatchesApi(dbContext, Constants.NormalizeCompetition(team.Competition));
var firstMatch = dbContext.Matches.Where(x => x.FrenoySeason == Constants.FrenoySeason).Min(x => x.Date);
if (DateTime.Now > firstMatch)
{
frenoy.SyncLastOpponentMatches(team, opponent);
var matchEntities = dbContext.Matches
.WithIncludes()
.Where(match => (match.AwayClubId == opponent.ClubId && match.AwayTeamCode == opponent.TeamCode) || (match.HomeClubId == opponent.ClubId && match.HomeTeamCode == opponent.TeamCode))
.Where(match => match.FrenoyDivisionId == team.FrenoyDivisionId)
.ToList();
// No comments for OpponentMatches
var result = Mapper.Map<IList<MatchEntity>, IList<OtherMatch>>(matchEntities);
return result;
}
else
{
// Pre season: Fetch last year matches instead
int? divisionId = frenoy.SyncLastYearOpponentMatches(team, opponent);
if (divisionId.HasValue)
{
var matchEntities = dbContext.Matches
.WithIncludes()
.Where(match => (match.AwayClubId == opponent.ClubId && match.AwayTeamCode == opponent.TeamCode) || (match.HomeClubId == opponent.ClubId && match.HomeTeamCode == opponent.TeamCode))
.Where(match => match.FrenoyDivisionId == divisionId.Value)
.ToList();
// No comments for OpponentMatches
// HACK: hack om vorig jaar matchen te tonen in de frontend zonder te moeten berekenen wat hun "last year division id" is
foreach (var match in matchEntities)
{
match.FrenoyDivisionId = team.FrenoyDivisionId;
}
var result = Mapper.Map<IList<MatchEntity>, IList<OtherMatch>>(matchEntities);
return result;
}
}
}
return null;
}
public SportaMatchExcelCreator(
TtcDbContext context,
MatchEntity match,
ICollection <PlayerEntity> players,
ICollection <TeamEntity> teams,
ICollection <PlayerEntity> opponentPlayers
)
{
_context = context;
_match = match;
_players = players;
_teams = teams;
_opponentPlayers = opponentPlayers;
}
public async Task <Club> UpdateClub(Club club)
{
using (var dbContext = new TtcDbContext())
{
var existingClub = await dbContext.Clubs.FirstOrDefaultAsync(x => x.Id == club.Id);
if (existingClub == null)
{
throw new Exception("Club not found");
}
MapClub(club, existingClub);
await dbContext.SaveChangesAsync();
}
return(club);
}
public void MigrateToLatestVersion()
{
using (var dbContext = new TtcDbContext())
{
var config = new DbMigrationsConfiguration()
{
MigrationsAssembly = typeof(TtcDbContext).Assembly,
ContextType = typeof(TtcDbContext),
MigrationsNamespace = "Ttc.DataAccess.Migrations"
};
var migrator = new DbMigrator(config);
migrator.Update();
//migrator.Update("0");
}
}
public async Task <IEnumerable <Club> > GetActiveClubs()
{
if (MatchService.MatchesPlaying && _clubs != null)
{
return(_clubs);
}
using (var dbContext = new TtcDbContext())
{
var activeClubs = await dbContext.Clubs
.Include(x => x.Lokalen)
.Include(x => x.Contacten)
.Where(x => x.Actief.HasValue && x.Actief == 1)
.ToListAsync();
var result = Mapper.Map <IList <ClubEntity>, IList <Club> >(activeClubs);
var managers = activeClubs.Single(x => x.Id == Constants.OwnClubId).Contacten;
var managerIds = managers.Select(x => x.SpelerId).ToArray();
var ourClub = result.Single(x => x.Id == Constants.OwnClubId);
ourClub.Managers = new List <ClubManager>();
var managerPlayers = await dbContext.Players.Where(x => managerIds.Contains(x.Id)).ToArrayAsync();
foreach (var managerPlayer in managerPlayers)
{
var managerInfo = managers.Single(x => x.SpelerId == managerPlayer.Id);
ourClub.Managers.Add(new ClubManager
{
Description = managerInfo.Omschrijving,
PlayerId = managerInfo.SpelerId,
Name = managerPlayer.Name,
Contact = new PlayerContact(managerPlayer.Id, managerPlayer.Email, managerPlayer.Gsm, managerPlayer.Adres, managerPlayer.Gemeente),
SortOrder = managerInfo.Sortering
});
}
if (MatchService.MatchesPlaying)
{
_clubs = result;
}
return(result);
}
}
public async Task <Team> GetTeam(int teamId, bool syncFrenoy)
{
using (var dbContext = new TtcDbContext())
{
var teamEntity = await dbContext.Teams
.Include(x => x.Players)
.Include(x => x.Opponents)
.SingleAsync(x => x.Id == teamId);
var team = Mapper.Map <TeamEntity, Team>(teamEntity);
if (syncFrenoy)
{
team.Ranking = await GetFrenoyRanking(dbContext, team.Competition, team.Frenoy.DivisionId);
}
return(team);
}
}
public IEnumerable<Club> GetActiveClubs()
{
if (MatchService.MatchesPlaying && _clubs != null)
{
return _clubs;
}
using (var dbContext = new TtcDbContext())
{
var activeClubs = dbContext.Clubs
.Include(x => x.Lokalen)
.Include(x => x.Contacten)
.Where(x => x.Actief.HasValue && x.Actief == 1)
.ToList();
var result = Mapper.Map<IList<ClubEntity>, IList<Club>>(activeClubs);
var managers = activeClubs.Single(x => x.Id == Constants.OwnClubId).Contacten;
var managerIds = managers.Select(x => x.SpelerId).ToArray();
var ourClub = result.Single(x => x.Id == Constants.OwnClubId);
ourClub.Managers = new List<ClubManager>();
var managerPlayers = dbContext.Players.Where(x => managerIds.Contains(x.Id));
foreach (var managerPlayer in managerPlayers)
{
var managerInfo = managers.Single(x => x.SpelerId == managerPlayer.Id);
ourClub.Managers.Add(new ClubManager
{
Description = string.IsNullOrWhiteSpace(managerInfo.Omschrijving) ? ClubManagerType.Default : (ClubManagerType)Enum.Parse(typeof(ClubManagerType), managerInfo.Omschrijving, true),
PlayerId = managerInfo.SpelerId,
Name = managerPlayer.Naam,
Contact = new PlayerContact(managerPlayer.Id, managerPlayer.Email, managerPlayer.Gsm, managerPlayer.Adres, managerPlayer.Gemeente),
SortOrder = managerInfo.Sortering
});
}
if (MatchService.MatchesPlaying)
{
_clubs = result;
}
return result;
}
}
public Team GetTeam(int teamId, bool syncFrenoy)
{
using (var dbContext = new TtcDbContext())
{
var teamEntity = dbContext.Teams
.Include(x => x.Players)
.Include(x => x.Opponents)
.Single(x => x.Id == teamId);
var team = Mapper.Map<TeamEntity, Team>(teamEntity);
if (syncFrenoy)
{
team.Ranking = GetFrenoyRanking(dbContext, team.Competition, team.Frenoy.DivisionId);
}
return team;
}
}
public Player UpdateStyle(PlayerStyle playerStyle)
{
using (var dbContext = new TtcDbContext())
{
var existingSpeler = dbContext.Players.FirstOrDefault(x => x.Id == playerStyle.PlayerId);
if (existingSpeler == null)
{
return null;
}
existingSpeler.Stijl = playerStyle.Name;
existingSpeler.BesteSlag = playerStyle.BestStroke;
dbContext.SaveChanges();
}
var newMatch = GetPlayer(playerStyle.PlayerId);
return newMatch;
}
public ICollection<Player> GetOwnClub()
{
if (MatchService.MatchesPlaying && _players != null)
{
return _players;
}
using (var dbContext = new TtcDbContext())
{
var players = dbContext.Players.ToArray();
var result = Mapper.Map<IList<PlayerEntity>, IList<Player>>(players);
if (MatchService.MatchesPlaying)
{
_players = result;
}
return result;
}
}
public Player GetPlayer(int playerId, bool allowCache = false)
{
if (allowCache && _players != null)
{
var ply = _players.SingleOrDefault(x => x.Id == playerId);
return ply ?? GetPlayer(playerId);
}
using (var dbContext = new TtcDbContext())
{
var newPlayer = Mapper.Map<PlayerEntity, Player>(dbContext.Players.SingleOrDefault(x => x.Id == playerId));
if (_players != null)
{
int cacheIndex = _players.IndexOf(_players.Single(x => x.Id == newPlayer.Id));
_players[cacheIndex] = newPlayer;
}
return newPlayer;
}
}
private ICollection<DivisionRanking> GetFrenoyRanking(TtcDbContext dbContext, Competition competition, int divisionId)
{
var key = new TeamRankingKey(competition, divisionId);
if (RankingCache.ContainsKey(key))
{
return RankingCache[key];
}
var frenoy = new FrenoyTeamsApi(dbContext, competition);
var ranking = frenoy.GetTeamRankings(divisionId);
if (!RankingCache.ContainsKey(key))
{
lock (CacheLock)
{
if (!RankingCache.ContainsKey(key))
{
RankingCache.Add(key, ranking);
}
}
}
return ranking;
}
public Guid EmailMatchesPlayer(string email, int playerId)
{
using (var dbContext = new TtcDbContext())
{
var player = dbContext.Players.SingleOrDefault(x => x.Id == playerId && x.Email.ToLower() == email.ToLower());
if (player == null)
{
throw new Exception("Email komt niet overeen voor " + playerId);
}
var passwordReset = new PlayerPasswordResetEntity(playerId);
dbContext.PlayerPasswordResets.Add(passwordReset);
dbContext.SaveChanges();
return passwordReset.Guid;
}
}
public Team ToggleTeamPlayer(TeamToggleRequest req)
{
using (var db = new TtcDbContext())
{
var team = db.Teams.Include(x => x.Players).Single(x => x.Id == req.TeamId);
var exPlayer = team.Players.SingleOrDefault(x => x.PlayerId == req.PlayerId);
if (exPlayer == null)
{
team.Players.Add(new TeamPlayerEntity
{
PlayerId = req.PlayerId,
TeamId = req.TeamId,
PlayerType = (TeamPlayerType)Enum.Parse(typeof(TeamPlayerType), req.Role)
});
}
else
{
db.Entry(exPlayer).State = EntityState.Deleted;
}
db.SaveChanges();
return GetTeam(req.TeamId, false);
}
}
public Player UpdatePlayer(Player player)
{
using (var dbContext = new TtcDbContext())
{
var existingSpeler = dbContext.Players.FirstOrDefault(x => x.Id == player.Id);
if (existingSpeler == null)
{
existingSpeler = new PlayerEntity();
MapPlayer(player, existingSpeler);
dbContext.Players.Add(existingSpeler);
}
else
{
MapPlayer(player, existingSpeler);
}
dbContext.SaveChanges();
player.Id = existingSpeler.Id;
}
var newPlayer = GetPlayer(player.Id);
return newPlayer;
}
public void SetNewPasswordFromGuid(Guid guid, int playerId, string password)
{
using (var dbContext = new TtcDbContext())
{
var now = DateTime.UtcNow;
var resetInfo = dbContext.PlayerPasswordResets.FirstOrDefault(x => x.Guid == guid && x.PlayerId == playerId && x.ExpiresOn > now);
if (resetInfo != null)
{
dbContext.Database.ExecuteSqlCommand(
$"UPDATE {PlayerEntity.TableName} SET paswoord=MD5({{1}}) WHERE id={{0}}",
playerId,
password);
}
else
{
throw new Exception($"Geen reset link gevonden {guid} voor speler {playerId}");
}
}
}
public void FrenoyTeamSync(int teamId)
{
using (var db = new TtcDbContext())
{
var team = db.Teams.Single(x => x.Id == teamId);
var frenoySync = new FrenoyMatchesApi(db, Constants.NormalizeCompetition(team.Competition));
frenoySync.SyncTeamMatches(team);
}
}
private Match GetMatch(TtcDbContext dbContext, int matchId)
{
var match = dbContext.Matches
.WithIncludes()
.SingleOrDefault(x => x.Id == matchId);
if (match == null)
return null;
var comments = dbContext.MatchComments.Where(x => x.MatchId == matchId).ToArray();
match.Comments = comments;
var matchModel = Map(match);
if (MatchesPlaying)
{
var cachedMatch = _matches.Single(x => x.Id == matchModel.Id);
int matchIndex = _matches.IndexOf(cachedMatch);
_matches[matchIndex] = matchModel;
}
return matchModel;
}
/// <summary>
/// Toggle Captain/Major player by any player of the team on the day of the match
/// </summary>
public Match ToggleMatchPlayer(MatchPlayer matchPlayer)
{
Debug.Assert(matchPlayer.Status == PlayerMatchStatus.Captain || matchPlayer.Status == PlayerMatchStatus.Major);
using (var dbContext = new TtcDbContext())
{
var match = dbContext.Matches.Find(matchPlayer.MatchId);
var existingPlayer = dbContext.MatchPlayers
.Where(x => x.MatchId == matchPlayer.MatchId && x.PlayerId == matchPlayer.PlayerId)
.FirstOrDefault(x => x.Status == matchPlayer.Status);
match.Block = matchPlayer.Status;
if (existingPlayer != null)
{
dbContext.MatchPlayers.Remove(existingPlayer);
}
else
{
dbContext.MatchPlayers.Add(Mapper.Map<MatchPlayer, MatchPlayerEntity>(matchPlayer));
}
dbContext.SaveChanges();
}
var newMatch = GetMatch(matchPlayer.MatchId);
return newMatch;
}
public User ChangePassword(PasswordCredentials userNewCredentials)
{
using (var dbContext = new TtcDbContext())
{
var pwdCheck = dbContext.Database.SqlQuery<int>(
$"SELECT COUNT(0) FROM {PlayerEntity.TableName} WHERE id={{0}} AND paswoord=MD5({{1}})",
userNewCredentials.PlayerId,
userNewCredentials.OldPassword).FirstOrDefault();
if (pwdCheck != 1)
{
return null;
}
else
{
dbContext.Database.ExecuteSqlCommand(
$"UPDATE {PlayerEntity.TableName} SET paswoord=MD5({{1}}) WHERE id={{0}}",
userNewCredentials.PlayerId,
userNewCredentials.NewPassword);
return GetUser(userNewCredentials.PlayerId);
}
}
}
public Match UpdateReport(MatchReport report)
{
using (var dbContext = new TtcDbContext())
{
var existingMatch = dbContext.Matches.First(x => x.Id == report.MatchId);
existingMatch.ReportPlayerId = report.PlayerId;
existingMatch.Description = report.Text;
dbContext.SaveChanges();
}
var newMatch = GetMatch(report.MatchId);
return newMatch;
}
/// <summary>
/// Set all players for the match to Captain/Major
/// </summary>
/// <param name="blockAlso">Also block the match to the newStatus level</param>
public Match EditMatchPlayers(int matchId, int[] playerIds, string newStatus, bool blockAlso)
{
Debug.Assert(newStatus == PlayerMatchStatus.Captain || newStatus == PlayerMatchStatus.Major);
using (var db = new TtcDbContext())
{
var match = db.Matches.Single(x => x.Id == matchId);
match.Block = blockAlso ? newStatus : null;
var existingPlayers = db.MatchPlayers
.Where(x => x.MatchId == matchId)
.Where(x => x.Status == newStatus)
.ToArray();
db.MatchPlayers.RemoveRange(existingPlayers);
for (int i = 0; i < playerIds.Length; i++)
{
var player = db.Players.Find(playerIds[i]);
var newMatchPlayer = new MatchPlayerEntity
{
Id = i * -1,
MatchId = matchId,
PlayerId = player.Id,
Name = player.NaamKort,
Status = newStatus,
Ranking = match.Competition == Competition.Vttl ? player.KlassementVttl : player.KlassementSporta,
Home = match.IsHomeMatch.Value,
Position = i
};
db.MatchPlayers.Add(newMatchPlayer);
}
db.SaveChanges();
}
var newMatch = GetMatch(matchId);
return newMatch;
}
public Match AddComment(MatchComment comment)
{
using (var dbContext = new TtcDbContext())
{
var entity = Mapper.Map<MatchCommentEntity>(comment);
entity.PostedOn = TtcDbContext.GetCurrentBelgianDateTime();
dbContext.MatchComments.Add(entity);
dbContext.SaveChanges();
}
var newMatch = GetMatch(comment.MatchId);
return newMatch;
}
public Match DeleteComment(int commentId)
{
using (var dbContext = new TtcDbContext())
{
var comment = dbContext.MatchComments.Single(x => x.Id == commentId);
dbContext.MatchComments.Remove(comment);
dbContext.SaveChanges();
return GetMatch(dbContext, comment.MatchId);
}
}
public OtherMatch FrenoyOtherMatchSync(int matchId)
{
using (var dbContext = new TtcDbContext())
{
FrenoyMatchSyncCore(dbContext, matchId);
var match = dbContext.Matches
.WithIncludes()
.Single(x => x.Id == matchId);
return Mapper.Map<MatchEntity, OtherMatch>(match);
}
}
public byte[] GetExcelExport()
{
using (var dbContext = new TtcDbContext())
{
var teams = dbContext.Teams
.Include(x => x.Players)
//.Include(x => x.Opponents)
.Where(x => x.Year == Constants.CurrentSeason)
.ToArray();
var matches = dbContext.Matches
.Include(x => x.HomeTeam)
.Include(x => x.AwayTeam)
.Include(x => x.Players)
.Where(x => x.HomeClubId == Constants.OwnClubId || x.AwayClubId == Constants.OwnClubId)
.Where(x => x.FrenoySeason == Constants.FrenoySeason)
.ToList();
var players = dbContext.Players.Where(x => x.Gestopt == null).ToArray();
var clubs = dbContext.Clubs.ToArray();
var exceller = TeamsExcelCreator.CreateFormation(teams, matches, players, clubs);
return exceller.Create();
}
}
public Match SetMyFormation(MatchPlayer matchPlayer)
{
using (var dbContext = new TtcDbContext())
{
var existingPlayer = dbContext.MatchPlayers
.Include(x => x.Match)
.Where(x => x.MatchId == matchPlayer.MatchId && x.PlayerId == matchPlayer.PlayerId)
.FirstOrDefault(x => x.Status != PlayerMatchStatus.Captain && x.Status != PlayerMatchStatus.Major);
if (existingPlayer != null)
{
existingPlayer.Status = matchPlayer.Status;
existingPlayer.StatusNote = matchPlayer.StatusNote;
}
else
{
var verslagSpeler = Mapper.Map<MatchPlayer, MatchPlayerEntity>(matchPlayer);
dbContext.MatchPlayers.Add(verslagSpeler);
}
dbContext.SaveChanges();
}
var newMatch = GetMatch(matchPlayer.MatchId);
return newMatch;
}
public string SetNewPassword(PasswordCredentials request)
{
using (var dbContext = new TtcDbContext())
{
var player = dbContext.Players.SingleOrDefault(x => x.Id == request.PlayerId);
if (player != null)
{
dbContext.Database.ExecuteSqlCommand(
$"UPDATE {PlayerEntity.TableName} SET paswoord=MD5({{1}}) WHERE id={{0}}",
request.PlayerId,
request.NewPassword);
return player.Email;
}
return null;
}
}
public Match UpdateScore(int matchId, MatchScore score)
{
using (var dbContext = new TtcDbContext())
{
var match = dbContext.Matches
.WithIncludes()
.Single(x => x.Id == matchId);
match.AwayScore = score.Out;
match.HomeScore = score.Home;
dbContext.SaveChanges();
return GetMatch(dbContext, match.Id);
}
}
public Match FrenoyMatchSync(int matchId)
{
using (var dbContext = new TtcDbContext())
{
FrenoyMatchSyncCore(dbContext, matchId);
return GetMatch(dbContext, matchId);
}
}
private static void FrenoyMatchSyncCore(TtcDbContext dbContext, int matchId)
{
var match = dbContext.Matches
.WithIncludes()
.Single(x => x.Id == matchId);
if (match.Date < DateTime.Now && !match.IsSyncedWithFrenoy)
{
var frenoySync = new FrenoyMatchesApi(dbContext, match.Competition);
frenoySync.SyncMatchDetails(match);
}
}
