public async Task <IActionResult> Put(Guid id, [FromBody] GameSkaterStatisticDTO value)
        {
            if (id != value.Id)
            {
                return(this.BadRequest("Posted game goalie statistic Id does not match the request."));
            }
            IActionResult result = await Execute(_log, async() => await _gameSkaterStatisticService.Upsert(value));

            return(result);
        }
Exemple #2
0
        public async Task <GameSkaterStatisticDTO> Update(GameSkaterStatisticDTO dto)
        {
            var result = await this.Handler.Execute(_log, async() =>
            {
                GameSkaterStatistic gameSkaterStatistic = _gameSkaterStatisticFactory.CreateDomainObject(dto);
                gameSkaterStatistic.Validate();

                gameSkaterStatistic = await _gameSkaterStatisticRepository.Update(gameSkaterStatistic);
                return(_gameSkaterStatisticMapper.ToDto(gameSkaterStatistic));
            });

            return(result);
        }
        private async Task SaveGoals(IList <GamePagePoint> points, IList <TeamDTO> teams, Guid gameId)
        {
            foreach (var point in points)
            {
                var team = teams.First(t => t.ShortCode.ToUpper() == point.TeamShortCode.ToUpper());

                GameSkaterStatisticDTO statistic = new GameSkaterStatisticDTO
                {
                    GameId       = gameId,
                    Period       = point.Period,
                    ScoreType    = ScoreType.EvenStrength,
                    TeamId       = team.Id,
                    Time         = point.Time ?? TimeSpan.FromSeconds(0),
                    CreatedOnUtc = DateTime.Now
                };

                await ParsePointPlayerString(point.PointScorers, statistic);

                await _gameSkaterStatisticService.Upsert(statistic);
            }
        }
        private async Task ParsePointPlayerString(string pointScorers, GameSkaterStatisticDTO statistic)
        {
            PlayerDTO primaryAssist   = null;
            PlayerDTO secondaryAssist = null;

            var goalScorerAssistsSplit = pointScorers.Split("\r\n");
            var scorer = goalScorerAssistsSplit[0];

            var pointStart    = scorer.IndexOf("(");
            var pointEnd      = scorer.IndexOf(")");
            var charsToRemove = (pointEnd + 1) - pointStart;

            var goalScorer = await GetOrCreatePlayer(scorer.Remove(pointStart, charsToRemove).Trim());

            if (goalScorerAssistsSplit.Length > 1)
            {
                //Get assist players.
                var assists = goalScorerAssistsSplit[1].Replace("Asst :", string.Empty);

                //Check if there is a secondary assist
                if (assists.Contains("/"))
                {
                    var splitAssists = assists.Split("/");
                    primaryAssist = await GetOrCreatePlayer(splitAssists[0].Remove(splitAssists[0].IndexOf("("), 3).Trim());

                    secondaryAssist = await GetOrCreatePlayer(splitAssists[1].Remove(splitAssists[1].IndexOf("("), 3).Trim());
                }
                else
                {
                    primaryAssist = await GetOrCreatePlayer(assists.Remove(assists.IndexOf("("), 3).Trim());
                }
            }

            //Update the stats with the player information
            statistic.PlayerId = goalScorer.Id;
            statistic.PrimaryAssistPlayerId   = primaryAssist?.Id;
            statistic.SecondaryAssistPlayerId = secondaryAssist?.Id;
        }
        public async Task <IActionResult> Post([FromBody] GameSkaterStatisticDTO value)
        {
            IActionResult result = await Execute(_log, async() => await _gameSkaterStatisticService.Upsert(value));

            return(result);
        }
 public GameSkaterStatistic CreateDomainObject(GameSkaterStatisticDTO dto)
 {
     return(new GameSkaterStatistic(dto.Id, dto.GameId, dto.PlayerId, dto.TeamId, (int)dto.ScoreType, dto.PrimaryAssistPlayerId, dto.SecondaryAssistPlayerId, dto.Period, dto.Time, dto.CreatedOnUtc));
 }