public async Task ImportLeague_WhenLeagueCodeDoesNotExistsOnFootballApi_ShouldReturnNullWithoutImport()
        {
            var leagueCode = "CL";

            Competition mockResult = null;

            var competitionsRepository = new Mock <ICompetitionsRepository>();

            competitionsRepository.Setup(x => x.GetByCode(leagueCode)).Returns(mockResult);

            var unitOfWork = new Mock <IUnitOfWork>();

            unitOfWork.SetupGet(x => x.Competitions).Returns(competitionsRepository.Object);

            FootballDataCompetitionResponse readerResponse = null;
            var reader = new Mock <IFootballDataApiReader>();

            reader.Setup(x => x.GetLeague(leagueCode)).ReturnsAsync(readerResponse);

            var service = LeagueServiceFactory.Create(unitOfWork.Object, reader.Object);

            var result = await service.ImportLeague(leagueCode);

            competitionsRepository.Verify(x => x.GetByCode(leagueCode));

            Assert.Null(result);
        }
Exemple #2
0
        public async Task <Competition> ImportLeague(string leagueCode)
        {
            if (unitOfWork.Competitions.GetByCode(leagueCode) != null)
            {
                throw new InvalidOperationException("League already imported");
            }

            FootballDataCompetitionResponse response = await Reader.GetLeague(leagueCode);

            if (response == null)
            {
                return(null);
            }

            Competition competition = mapper.Map <Competition>(response.Competition);

            logger.LogDebug(competition.ToString());

            var competitionTeams = mapper.Map <IEnumerable <Team> >(response.Teams);

            logger.LogDebug($"Competition teams:{competitionTeams.Count()}");

            var alreadyImported = new List <Team>();
            var toImport        = new List <Team>();

            foreach (var team in competitionTeams)
            {
                Team alreadyImportedteam = unitOfWork.Teams.GetByExternalId(team.ExternalId);
                if (alreadyImportedteam != null)
                {
                    alreadyImported.Add(alreadyImportedteam);
                    continue;
                }

                var dtoPlayers = await Reader.GetTeamPlayers(team.ExternalId);

                var players = mapper.Map <IEnumerable <Player> >(dtoPlayers);

                logger.LogDebug($"players on team({team.Name}):{players.Count()}");
                unitOfWork.Players.AddRange(players);

                team.Players = players.ToList();

                logger.LogDebug(team.ToString());
                unitOfWork.Teams.Add(team);
                toImport.Add(team);
            }

            unitOfWork.Competitions.Add(competition);

            unitOfWork.Complete();

            competition.CompetitionTeams = toImport
                                           .Select(ct => new CompetitionTeams()
            {
                TeamId        = ct.Id,
                Team          = ct,
                CompetitionId = competition.Id,
                Competition   = competition
            }).ToList();

            competition.CompetitionTeams.AddRange(
                alreadyImported
                .Select(ct => new CompetitionTeams()
            {
                TeamId        = ct.Id,
                Team          = ct,
                CompetitionId = competition.Id,
                Competition   = competition
            }));

            unitOfWork.Competitions.Update(competition);

            unitOfWork.Complete();

            return(competition);
        }