private static MatchOutcome GetScoreType(MatchEntity match)
        {
            var now = DateTime.Now;
            var yesterday = now.Subtract(TimeSpan.FromDays(1));
            if ((match.Date.Date == now.Date && now.Hour >= match.Date.Hour - 10) || (match.Date.Date == yesterday.Date && now.Hour < match.Date.Hour - 10))
            {
                return MatchOutcome.BeingPlayed;
            }
            if (match.Date.Date >= DateTime.Now.Date)
            {
                return MatchOutcome.NotYetPlayed;
            }

            if (match.WalkOver)
            {
                return MatchOutcome.WalkOver;
            }
            if (!match.HomeScore.HasValue || !match.AwayScore.HasValue)
            {
                return MatchOutcome.NotYetPlayed;
            }
            if (match.HomeScore.Value == match.AwayScore.Value)
            {
                return MatchOutcome.Draw;
            }

            if (match.IsHomeMatch.HasValue && match.IsHomeMatch.Value)
            {
                return match.HomeScore.Value < match.AwayScore.Value ? MatchOutcome.Lost : MatchOutcome.Won;
            }
            else
            {
                return match.HomeScore.Value < match.AwayScore.Value ? MatchOutcome.Won : MatchOutcome.Lost;
            }
        }
 public void SyncMatchDetails(MatchEntity matchEntity)
 {
     if (ShouldAttemptMatchSync(matchEntity.Id))
     {
         GetMatchesResponse matches = _frenoy.GetMatches(new GetMatchesRequest
         {
             DivisionId = matchEntity.FrenoyDivisionId.ToString(),
             WithDetailsSpecified = true,
             WithDetails = true,
             MatchId = matchEntity.FrenoyMatchId
         });
         Debug.Assert(matches.MatchCount == "1");
         SyncMatchDetails(matchEntity, matches.TeamMatchesEntries[0]);
     }
 }
 public TeamMatchExcelModel(MatchEntity match, ClubEntity[] clubs)
 {
     Match = match;
     Home = GetTeamDesc(match.HomeClubId, match.HomeTeamCode, clubs);
     Out = GetTeamDesc(match.AwayClubId, match.AwayTeamCode, clubs);
     PlayerDecisions = new Dictionary<string, string>();
     CaptainDecisions = new List<string>();
 }
        private static void AddMatchGames(IndividualMatchResultEntryType frenoyIndividual, int id, MatchEntity matchEntity)
        {
            MatchGameEntity matchResult;
            int homeUniqueIndex, awayUniqueIndex;
            if (!int.TryParse(frenoyIndividual.HomePlayerUniqueIndex, out homeUniqueIndex) || !int.TryParse(frenoyIndividual.AwayPlayerUniqueIndex, out awayUniqueIndex))
            {
                // Sporta doubles match:
                matchResult = new MatchGameEntity
                {
                    Id = id,
                    MatchId = matchEntity.Id,
                    MatchNumber = int.Parse(frenoyIndividual.Position),
                    WalkOver = WalkOver.None
                };
            }
            else
            {
                // Sporta/Vttl singles match
                matchResult = new MatchGameEntity
                {
                    Id = id,
                    MatchId = matchEntity.Id,
                    MatchNumber = int.Parse(frenoyIndividual.Position),
                    HomePlayerUniqueIndex = homeUniqueIndex,
                    AwayPlayerUniqueIndex = awayUniqueIndex,
                    WalkOver = WalkOver.None
                };
            }

            if (frenoyIndividual.IsHomeForfeited || frenoyIndividual.IsAwayForfeited)
            {
                matchResult.WalkOver = frenoyIndividual.IsHomeForfeited ? WalkOver.Home : WalkOver.Out;
            }
            else
            {
                matchResult.HomePlayerSets = int.Parse(frenoyIndividual.HomeSetCount);
                matchResult.AwayPlayerSets = int.Parse(frenoyIndividual.AwaySetCount);
            }
            matchEntity.Games.Add(matchResult);
        }
        private void AddMatchPlayers(TeamMatchPlayerEntryType[] players, MatchEntity match, bool thuisSpeler)
        {
            foreach (var frenoyVerslagSpeler in players)
            {
                MatchPlayerEntity matchPlayerEntity = new MatchPlayerEntity
                {
                    MatchId = match.Id,
                    Ranking = frenoyVerslagSpeler.Ranking,
                    Home = thuisSpeler,
                    Name = GetSpelerNaam(frenoyVerslagSpeler),
                    Position = int.Parse(frenoyVerslagSpeler.Position),
                    UniqueIndex = int.Parse(frenoyVerslagSpeler.UniqueIndex),
                    Status = PlayerMatchStatus.Major
                };
                if (frenoyVerslagSpeler.VictoryCount != null)
                {
                    matchPlayerEntity.Won = int.Parse(frenoyVerslagSpeler.VictoryCount);
                }
                else
                {
                    Debug.Assert(frenoyVerslagSpeler.IsForfeited, "Either a VictoryCount or IsForfeited");
                }

                PlayerEntity dbPlayer = null;
                if (match.IsHomeMatch.HasValue && ((match.IsHomeMatch.Value && thuisSpeler) || (!match.IsHomeMatch.Value && !thuisSpeler)))
                {
                    if (_isVttl)
                    {
                        dbPlayer = _db.Players.SingleOrDefault(x => x.ComputerNummerVttl.HasValue && x.ComputerNummerVttl.Value.ToString() == frenoyVerslagSpeler.UniqueIndex);
                    }
                    else
                    {
                        dbPlayer = _db.Players.SingleOrDefault(x => x.LidNummerSporta.HasValue && x.LidNummerSporta.Value.ToString() == frenoyVerslagSpeler.UniqueIndex);
                    }
                }
                if (dbPlayer != null)
                {
                    matchPlayerEntity.PlayerId = dbPlayer.Id;
                    if (!string.IsNullOrWhiteSpace(dbPlayer.NaamKort))
                    {
                        matchPlayerEntity.Name = dbPlayer.NaamKort;
                    }
                }

                match.Players.Add(matchPlayerEntity);
            }
        }
        private void RemoveExistingMatchPlayersAndGames(MatchEntity matchEntity)
        {
            var oldMatchPlayers = _db.MatchPlayers.Where(x => x.MatchId == matchEntity.Id).ToArray();
            _db.MatchPlayers.RemoveRange(oldMatchPlayers);

            var oldMatchGames = _db.MatchGames.Where(x => x.MatchId == matchEntity.Id).ToArray();
            _db.MatchGames.RemoveRange(oldMatchGames);
        }
 private static void AssertMatchPlayers(MatchEntity matchEntity)
 {
     var testPlayer = matchEntity.Players.Count(x => x.PlayerId != 0) == 0 || matchEntity.Players.Count > 8;
     if (testPlayer && (matchEntity.AwayTeamId.HasValue || matchEntity.HomeTeamId.HasValue))
     {
         Debug.Assert(false, "player problem");
     }
 }
 private static void AddMatchGames(TeamMatchEntryType frenoyMatch, MatchEntity matchEntity)
 {
     if (frenoyMatch.MatchDetails.IndividualMatchResults != null)
     {
         int id = 0;
         foreach (var frenoyIndividual in frenoyMatch.MatchDetails.IndividualMatchResults)
         {
             id--;
             AddMatchGames(frenoyIndividual, id, matchEntity);
         }
     }
 }
        private void SyncMatchDetails(MatchEntity matchEntity, TeamMatchEntryType frenoyMatch)
        {
            if (!matchEntity.IsSyncedWithFrenoy)
            {
                if (frenoyMatch.Score != null)
                {
                    string score = frenoyMatch.Score.ToLowerInvariant();
                    bool isForfeit = score.Contains("ff") || score.Contains("af") || score.Contains("gu");
                    if (!isForfeit)
                    {
                        // Uitslag
                        matchEntity.HomeScore = int.Parse(frenoyMatch.Score.Substring(0, frenoyMatch.Score.IndexOf("-")));
                        matchEntity.AwayScore = int.Parse(frenoyMatch.Score.Substring(frenoyMatch.Score.IndexOf("-") + 1));
                        matchEntity.WalkOver = false;
                    }
                    else
                    {
                        matchEntity.WalkOver = true;
                    }
                }

                if (frenoyMatch.MatchDetails != null && frenoyMatch.MatchDetails.DetailsCreated)
                {
                    AddMatchPlayers(frenoyMatch.MatchDetails.HomePlayers.Players, matchEntity, true);
                    AddMatchPlayers(frenoyMatch.MatchDetails.AwayPlayers.Players, matchEntity, false);
                    //AssertMatchPlayers(matchEntity);

                    AddMatchGames(frenoyMatch, matchEntity);

                    RemoveExistingMatchPlayersAndGames(matchEntity);
                }

                if (frenoyMatch.Score != null && frenoyMatch.MatchDetails != null && frenoyMatch.MatchDetails.DetailsCreated)
                {
                    matchEntity.IsSyncedWithFrenoy = true;
                }

                CommitChanges();
            }
        }
        private void MapMatch(MatchEntity entity, int? teamId, int frenoyDivisionId, TeamMatchEntryType frenoyMatch, int frenoySeason = Constants.FrenoySeason)
        {
            entity.FrenoyMatchId = frenoyMatch.MatchId;
            entity.Date = frenoyMatch.Date + new TimeSpan(frenoyMatch.Time.Hour, frenoyMatch.Time.Minute, 0);
            entity.HomeClubId = GetClubId(frenoyMatch.HomeClub);
            entity.HomeTeamCode = ExtractTeamCodeFromFrenoyName(frenoyMatch.HomeTeam);
            entity.AwayClubId = GetClubId(frenoyMatch.AwayClub);
            entity.AwayTeamCode = ExtractTeamCodeFromFrenoyName(frenoyMatch.AwayTeam);
            entity.Week = int.Parse(frenoyMatch.WeekName);
            entity.FrenoySeason = frenoySeason;
            entity.FrenoyDivisionId = frenoyDivisionId;
            entity.Competition = _settings.Competition;

            //TODO: we zaten hier for the derby problem
            // do not pass teamId here but find out what the Team is based on HomeClubId and HomeTeamCode
            if (teamId.HasValue)
            {
                if (entity.HomeClubId == Constants.OwnClubId)
                {
                    entity.HomeTeamId = teamId;
                }
                else if (entity.AwayClubId == Constants.OwnClubId)
                {
                    entity.AwayTeamId = teamId;
                }
            }
        }
        private void SyncMatches(int? teamId, int frenoyDivisionId, GetMatchesResponse matches, bool alsoSyncMatchDetails = true, int frenoySeason = Constants.FrenoySeason)
        {
            foreach (TeamMatchEntryType frenoyMatch in matches.TeamMatchesEntries.Where(x => !x.HomeTeam.Trim().StartsWith("Vrij") && !x.AwayTeam.Trim().StartsWith("Vrij")))
            {
                Debug.Assert(frenoyMatch.DateSpecified, "Probably need to filter this one out?");
                Debug.Assert(frenoyMatch.TimeSpecified);

                // Kalender entries
                MatchEntity matchEntity = _db.Matches.SingleOrDefault(x => x.FrenoyMatchId == frenoyMatch.MatchId && x.FrenoySeason == frenoySeason);
                if (matchEntity == null)
                {
                    matchEntity = new MatchEntity();
                    MapMatch(matchEntity, teamId, frenoyDivisionId, frenoyMatch, frenoySeason);
                    _db.Matches.Add(matchEntity);
                    CommitChanges();
                }
                else
                {
                    MapMatch(matchEntity, teamId, frenoyDivisionId, frenoyMatch, frenoySeason);
                    CommitChanges();
                }

                if (alsoSyncMatchDetails)
                {
                    SyncMatchDetails(matchEntity, frenoyMatch);
                }
            }
        }
Exemplo n.º 12
0
 private Match Map(MatchEntity matchEntity)
 {
     return Mapper.Map<MatchEntity, Match>(matchEntity);
 }