Пример #1
0
        public async Task <ActionResult <GameResource> > CreateGame([FromBody] SaveGameResource saveGameResource)
        {
            var validator        = new SaveGameResourceValidator();
            var validationResult = await validator.ValidateAsync(saveGameResource);

            if (!validationResult.IsValid)
            {
                return(BadRequest(validationResult.Errors));
            }

            var gameToCreate = _mapper.Map <SaveGameResource, Game>(saveGameResource);
            var newGame      = await _gameService.CreateGame(gameToCreate);

            var gameResource = _mapper.Map <Game, GameResource>(newGame);

            return(Ok(gameResource));
        }
Пример #2
0
        public async Task <IActionResult> Post([FromBody] SaveGameResource gameResource)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            var game = mapper.Map <SaveGameResource, Game>(gameResource);

            await gameRepository.Add(game);

            await unitOfWork.CompleteAsync();

            game = await gameRepository.Get(game.Id);

            var result = mapper.Map <Game, GameResource>(game);

            return(Ok(result));
        }
Пример #3
0
        public async Task <ActionResult <GameResource> > CreateGame([FromBody] SaveGameResource saveGameResource)
        {
            var validator        = new SaveGameResourceValidator();
            var validationResult = await validator.ValidateAsync(saveGameResource);

            if (!validationResult.IsValid)
            {
                return(BadRequest(validationResult.Errors)); // this needs refining, but for demo it is ok
            }
            var gameToCreate = _mapper.Map <SaveGameResource, Game>(saveGameResource);

            var newGame = await _gameService.CreateGame(gameToCreate);

            await _gameService.SetGameGenres(newGame, saveGameResource.GenreIds);

            var game = await _gameService.GetGameByRef(newGame.Ref);

            var musicResource = _mapper.Map <Game, GameResource>(game);

            return(Ok(musicResource));
        }
Пример #4
0
        public async Task <ActionResult <GameResource> > UpdateGame(int id, [FromBody] SaveGameResource saveGameResource)
        {
            var validator        = new SaveGameResourceValidator();
            var validationResult = await validator.ValidateAsync(saveGameResource);

            var requestIsInvalid = id == 0 || !validationResult.IsValid;

            if (requestIsInvalid)
            {
                return(BadRequest(validationResult.Errors));
            }

            var game = _mapper.Map <SaveGameResource, Game>(saveGameResource);

            await _gameService.UpdateGame(id, game);

            var updatedGame = await _gameService.GetGameById(id);

            var updatedGameResource = _mapper.Map <Game, GameResource>(updatedGame);

            return(Ok(updatedGameResource));
        }
Пример #5
0
        public async Task <IActionResult> Put(int id, [FromBody] SaveGameResource saveGameResource)
        {
            //throw new Exception();
            var gameInDb = await gameRepository.Get(id);

            if (gameInDb == null)
            {
                return(NotFound());
            }
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            mapper.Map(saveGameResource, gameInDb);

            await unitOfWork.CompleteAsync();

            await gameRepository.Get(gameInDb.Id);

            var result = mapper.Map <Game, GameResource>(gameInDb);

            return(Ok(result));
        }
Пример #6
0
        public async Task <IActionResult> StartGame([FromBody] SaveGameResource saveGameResource)
        {
            _repoLog.Add(new Log()
            {
                Level = LogLevel.Information, Description = "Starting game"
            });
            if (!ModelState.IsValid)
            {
                _repoLog.Add(new Log()
                {
                    Level = LogLevel.Warning, Description = "Invalid model state"
                });
                await _unitOfWork.CompleteAsync();

                return(BadRequest(ModelState));
            }

            if (saveGameResource.Player1.Trim().ToUpper() == saveGameResource.Player2.Trim().ToUpper())
            {
                _repoLog.Add(new Log()
                {
                    Level       = LogLevel.Warning,
                    Description = string.Format("Players can't be the same. Player 1: {0} - Player 2: {1}", saveGameResource.Player1, saveGameResource.Player2)
                });
                await _unitOfWork.CompleteAsync();

                return(BadRequest("Players can't be the same"));
            }

            var player1 = await _repoPlayer.GetEntityByFilterAsync(p => p.Name == saveGameResource.Player1);

            if (player1 == null)
            {
                player1 = new Player()
                {
                    Name = saveGameResource.Player1
                }
            }
            ;

            var player2 = await _repoPlayer.GetEntityByFilterAsync(p => p.Name == saveGameResource.Player2);

            if (player2 == null)
            {
                player2 = new Player()
                {
                    Name = saveGameResource.Player2
                }
            }
            ;

            var game = new Game()
            {
                Player1 = player1, Player2 = player2
            };

            _repoGame.Add(game);
            await _unitOfWork.CompleteAsync();

            game = await _repoGame.GetEntityByFilterAsync(g => g.Id == game.Id);

            var gameResource = _mapper.Map <Game, GameResource>(game);

            return(Ok(gameResource));
        }