Example #1
0
        public async Task Execute(SynchronizePlayerMatchesContext context, int matchId)
        {
            using (_logger.OperationStarted(nameof(SyncMatch), new { matchId }))
            {
                var clientMatch = await _footballDataApiClient.GetMatchById(matchId);

                try
                {
                    Match match = new Match(
                        clientMatch.Id,
                        context.PlayerId,
                        clientMatch.Date,
                        clientMatch.HomeTeam,
                        clientMatch.AwayTeam,
                        clientMatch.HomeTeamScore,
                        clientMatch.AwayTeamScore,
                        clientMatch.Winner);

                    match.AssignCompetitionWinner(clientMatch.CompetitionWinner);

                    _matchRepository.Insert(match);

                    _logger.OperationSucceeded();
                }
                catch (Exception e)
                {
                    _logger.OperationFailed(e);

                    _executionErrorRepository.Insert(new ExecutionError(ReferenceType.Match, clientMatch.Id,
                                                                        e.Message));
                }
            }
        }
Example #2
0
        public void Execute(SynchronizePlayerMatchesContext context)
        {
            var syncedMatches    = _matchRepository.GetByPlayerId(context.PlayerId);
            var syncedMatchesIds = syncedMatches.Select(m => m.ApiId);

            var failedMatches    = _executionErrorRepository.GetByReferenceType(ReferenceType.Match);
            var failedMatchesIds = failedMatches.Select(e => e.ReferenceId);

            var matchesToSync = context.Player.Matches
                                .Where(m => !syncedMatchesIds.Contains(m.ApiId))
                                .Where(m => !failedMatchesIds.Contains(m.ApiId))
                                .OrderBy(m => m.Date)
                                .Take(SyncCallsLimit)
                                .Select(m => m.ApiId)
                                .ToList();

            if (matchesToSync.Count == 0)
            {
                Random random = new Random();

                matchesToSync = failedMatchesIds
                                .OrderBy(x => random.Next())
                                .Take(SyncCallsLimit)
                                .ToList();
            }

            context.MatchesToSync = matchesToSync;
        }
Example #3
0
        public async Task Execute(SynchronizePlayerMatchesContext context)
        {
            var clientPlayer = await _footballDataApiClient.GetPlayerById(context.PlayerId);

            //add player teams (web scrap?)

            Player player = new Player(
                clientPlayer.Id,
                clientPlayer.Name,
                clientPlayer.DateOfBirth,
                clientPlayer.Nationality,
                clientPlayer.Position,
                clientPlayer.Matches.Select(m => new Match(
                                                m.Id,
                                                context.PlayerId,
                                                m.Date,
                                                m.HomeTeam,
                                                m.AwayTeam,
                                                m.HomeTeamScore,
                                                m.AwayTeamScore,
                                                m.Winner))
                .ToList());

            var dbPlayer = _playerRepository.GetById(player.ApiId);

            if (dbPlayer == null)
            {
                _playerRepository.Insert(player);
            }
            else
            {
                // _playerRepository.Update(player);
            }

            context.Player = player;


            Console.WriteLine($"Sync player [{player.ApiId}] - SUCCESS");
        }