Пример #1
0
        public bool AddMatche(TMatche matche)
        {
            var leftCatIdNotFound  = _catMashDBContext.TCat.FirstOrDefault(x => x.CatId == matche.LeftCatId) == null;
            var rightCatIdNotFound = _catMashDBContext.TCat.FirstOrDefault(x => x.CatId == matche.RightCatId) == null;

            if (rightCatIdNotFound || leftCatIdNotFound)
            {
                throw new ElementNotFoundException();
            }

            var unknowMatcheResult = MatchResultHelper.IsValidMatchResult(matche.MatchResult);

            if (unknowMatcheResult)
            {
                throw new UnknownMatcheResultException();
            }

            try
            {
                _catMashDBContext.TMatche.Add(matche);

                return(_catMashDBContext.SaveChanges() == 1);
            }
            catch (Exception exp)
            {
                throw new DataBaseAccessException("DataBaseAccessException", exp);
            }
        }
Пример #2
0
        public TeamDetailsInfo GetTeam(int teamId)
        {
            var matches = this.GetTeamMatches(teamId);
            var players = this.GetTeamPlayers(teamId);

            var query = this.Context.MatchesLineUp
                        .Where(x => x.TeamId == teamId)
                        .Select(x => new
            {
                x.TeamId,
                x.Team.Name,
                x.YellowCard,
                x.ManOfTheMatch
            }).AsEnumerable();

            var team = query.GroupBy(x => new { x.TeamId, x.Name },
                                     (key, gr) => new TeamDetailsInfo
            {
                Id            = key.TeamId,
                Name          = key.Name,
                YellowCards   = gr.Count(y => y.YellowCard).ToString(),
                ManOfTheMatch = gr.Count(mm => mm.ManOfTheMatch).ToString(),
                BestGame      = matches.OrderByDescending(i => MatchResultHelper.Diff(i.ScoreInfo, key.TeamId))
                                .ThenByDescending(i => i.ScoreInfo.Sum(g => g.FullTimeScore)).First(),
                Losses  = matches.Count(i => MatchResultHelper.Diff(i.ScoreInfo, key.TeamId) < 0).ToString(),
                Draws   = matches.Count(i => MatchResultHelper.Diff(i.ScoreInfo, key.TeamId) == 0).ToString(),
                Wins    = matches.Count(i => MatchResultHelper.Diff(i.ScoreInfo, key.TeamId) > 0).ToString(),
                Goals   = matches.Sum(m => m.ScoreInfo.First(x => x.TeamId == teamId).FullTimeScore).ToString(),
                Players = players
            }).Single();

            return(team);
        }
Пример #3
0
        private List <PlayerMatchStats> GetPlayerMatchStats(int playerId)
        {
            var query = (from pss in (from u in this.Context.MatchesLineUp
                                      join s in this.Context.MatchesScore on u.MatchId equals s.MatchId
                                      join ps in this.Context.PlayersScore on u.Id equals ps.MatchesLineUpId into r
                                      from pss in r.DefaultIfEmpty()
                                      where u.PlayerId == playerId
                                      select new
            {
                s.MatchId,
                s.Match.Year,
                u.Player.CurrentTeamId,
                s.TeamId,
                s.HalfTimeScore,
                s.FullTimeScore,
                u.ManOfTheMatch,
                u.YellowCard,
                Goals = pss == null ? 0 : 1
            })
                         group pss by new { pss.MatchId, pss.Year, pss.CurrentTeamId, pss.TeamId, pss.HalfTimeScore, pss.FullTimeScore, pss.ManOfTheMatch, pss.YellowCard } into gr
                         select new { Pss = gr.Key, Goals = gr.Sum(x => x.Goals) }).ToList();

            var playerMatchStats = query.GroupBy(x => new { x.Pss.MatchId, x.Pss.Year, x.Pss.CurrentTeamId, x.Pss.ManOfTheMatch, x.Pss.YellowCard, x.Goals },
                                                 (key, gr) => new PlayerMatchStats
            {
                MatchId       = key.MatchId,
                MatchYear     = key.Year.ToString(),
                ManOfTheMatch = key.ManOfTheMatch,
                YellowCard    = key.YellowCard,
                MatchGoals    = gr.Sum(gg => gg.Pss.FullTimeScore),
                Goals         = key.Goals,
                MatchResult   = MatchResultHelper.Result(gr.Select(si => new ScoreInfo
                {
                    TeamId        = si.Pss.TeamId,
                    HalfTimeScore = si.Pss.HalfTimeScore,
                    FullTimeScore = si.Pss.FullTimeScore
                }).ToList(), key.CurrentTeamId)
            }).ToList();

            return(playerMatchStats);
        }