public IActionResult Post(int userId, [FromBody] CreateGameDTO createGameDTO) { Game game = _mapper.Map <Game>(createGameDTO); var user = _userRepository.GetUser(userId); if (user == null) { return(NotFound()); } game.User = user; var valid = _gameValidator.Validate(game); if (!valid.IsValid) { return(BadRequest()); } _gameRepository.CreateGame(game); if (_gameRepository.SaveGame() > 0) { return(Ok()); } return(BadRequest()); }
public async Task <IActionResult> Edit(int id, [FromForm] UpdateGameDataAnnotations dto, IFormFile Path) { if (!ModelState.IsValid) { TempData["error"] = "Please fill all blank boxes."; return(RedirectToAction(nameof(Edit), new { id })); } try { var newDto = new CreateGameDTO { AgeLabel = dto.AgeLabel, DeveloperId = dto.DeveloperId, Engine = dto.Engine, GameMode = dto.GameMode, Name = dto.Name, PublisherId = dto.PublisherId, ReleaseDate = dto.ReleaseDate, UserId = dto.UserId, Path = Path }; await _gameService.Update(id, newDto); return(RedirectToAction(nameof(Index))); } catch (EntityNotFoundException e) { TempData["error"] = e.Message; return(RedirectToAction(nameof(Index))); } catch (Exception e) { TempData["error"] = "Server error, please try later."; return(RedirectToAction(nameof(Edit), new { id })); } }
public async Task Post_GivenGame_WhenInvalid_ThenBadRequestResponse() { // Arrange var newGame = new CreateGameDTO { Name = string.Empty, AcquisicionDate = null, Kind = "99", Observation = "UM jogo muito legal" }; var myContent = JsonConvert.SerializeObject(newGame); var buffer = Encoding.UTF8.GetBytes(myContent); var byteContent = new ByteArrayContent(buffer); byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var token = await GetToken(); _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token); // Act var response = await _client.PostAsync("/gtracker/game", byteContent); // Assert response.StatusCode.Should().Be(HttpStatusCode.BadRequest); }
public async Task CreateGame() { var createGameDto = new CreateGameDTO() { Name = "new game", Players = this.fixture.team.Members.Select(m => new PlayerDTO(m.Name) { PlayerId = m.PlayerId }).ToList() }; var content = RequestBodyFromObject(createGameDto); var response = await fixture.Client.PostAsync("/api/game", content); response.EnsureSuccessStatusCode(); var result = await DeserializeResponse <GameDTO>(response); this.fixture.gameId = result.Data.GameId; result.Data.Name.Should().Be("new game"); result.Data.Players.Should().HaveCount(4, "the created game has 4 players"); result.Data.Players.Should(). Contain(p => this.fixture.team.Members.Select(m => m.PlayerId).Contains(p.PlayerId), "All the players should have ids that belong to the team members"); result.Data.Players.Where(p => p.IsMaestro == true).Should().HaveCount(0, "no player should be maestro because this is this tema's first game"); result.Data.TeamId.Should().Be(fixture.team.TeamId); }
public async Task <ActionResult> Create([FromForm] CreateGameDTODataAnnotations dto, IFormFile Path) { try { //var (Server, FilePath) = await _fileService.Upload(Path); var dtoNew = new CreateGameDTO { AgeLabel = dto.AgeLabel, DeveloperId = dto.DeveloperId, Engine = dto.Engine, GameMode = dto.GameMode, Name = dto.Name, PublisherId = dto.PublisherId, ReleaseDate = dto.ReleaseDate, UserId = dto.UserId, Path = Path }; await _gameService.Create(dtoNew); return(RedirectToAction(nameof(Index))); } catch (Exception e) { TempData["error"] = e.Message; return(RedirectToAction(nameof(Index))); } }
public async Task <ActionResult> Create([FromForm] CreateGameDTO dto) { var validator = new GameFluentValidator(_context); var errors = await validator.ValidateAsync(dto); if (!errors.IsValid) { var mapped = errors.Errors.Select(x => new { Name = x.PropertyName, Error = x.ErrorMessage }).ToArray(); TempData["error"] = "Please fill all blank boxes."; //mapped.ToString(); return(RedirectToAction(nameof(Create))); } try { // TODO: Add insert logic here await _gameService.Create(dto); return(RedirectToAction(nameof(Index))); } catch (Exception e) { TempData["error"] = "Exception"; return(RedirectToAction(nameof(Index))); } }
public async Task <ActionResult <Game> > Create([FromBody] CreateGameDTO gameDTO) { Game game = _mapper.Map <Game>(gameDTO); await _gameRepository.CreateAsync(game); return(CreatedAtAction(nameof(Create), new { game.Id }, game)); }
public void Save(CreateGameDTO model) { if (model != null) { var game = _mapper.Map <CreateGameCommand>(model); _bus.SendCommand(game); } }
public async Task <ActionResult> Post([FromBody] CreateGameDTO game) { try { await _gameService.Post(game); return(Accepted()); } catch (Exception e) { return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message)); } }
public async Task <ActionResult <ResponseDTO <GameDTO> > > AddGame(CreateGameDTO gameRequest) { if (context.TeamId != null) { gameRequest.TeamId = context.TeamId; } else { gameRequest.Players.ForEach(p => p.PlayerId = null); } var game = await gameService.StartGameAsync(gameRequest); return(Ok(game)); }
public IActionResult CreateGame([FromBody] CreateGameDTO dto) { if (string.IsNullOrEmpty(dto.GameName)) { return(BadRequest()); } var game = new Game { Name = dto.GameName }; _context.Games.Add(game); _context.SaveChanges(); return(Ok(game)); }
public IActionResult CreateGame([FromBody] CreateGameDTO createGameDTO) { if (!ModelState.IsValid) { return(BadRequest("Invalid parameters")); } if (_gameEngine.TryCreateGame(createGameDTO.HostUsername, createGameDTO.PublicGameId, out Game game)) { return(Ok(game)); } else { return(Conflict("Game already active with the same id")); } }
public async Task <GameDTO> StartGameAsync(CreateGameDTO gameRequest) { var game = new Game() { TeamId = gameRequest.TeamId, Name = gameRequest.Name, GameId = Guid.NewGuid(), Date = DateTime.Now, GamePlayer = new List <GamePlayer>() }; if (game.TeamId != null) { var teamPlayers = await dbContext.TeamPlayer .AsNoTracking() .Where(tp => tp.TeamId == game.TeamId) .ToListAsync(); foreach (var player in gameRequest.Players) { if (player.PlayerId.HasValue && !teamPlayers.Select(tp => tp.PlayerId).Contains(player.PlayerId.Value)) { throw new OperationUnauthorizedException("Specified player not in team!"); } } } var gamePlayers = gameRequest.Players .Select(p => new GamePlayer(p.Name) { GameId = game.GameId, PlayerId = p.PlayerId ?? Guid.NewGuid() }) .ToList(); RandomizePlayerPosition(gamePlayers); foreach (var player in gamePlayers) { game.GamePlayer.Add(player); } dbContext.Game.Add(game); await dbContext.SaveChangesAsync(); return(await this.GetAsync(game.GameId));; }
public ActionResult Post([FromBody] CreateGameDTO createGameDTO) { try { _gameService.Save(createGameDTO); return(Ok()); } catch (Exception e) { string errors = e.Message; return(ValidationProblem(new ValidationProblemDetails() { Type = "Model Validation Error", Detail = errors })); } }
public async Task Create(CreateGameDTO dto) { string path = await _fileService.Upload(dto.Path); // VALIDATION FILE List <GamePlatform> gamePlatforms = new List <GamePlatform>(); List <GameGenre> gameGenres = new List <GameGenre>(); foreach (int platform in dto.Platforms) { gamePlatforms.Add(new GamePlatform { PlatformId = platform }); } foreach (int genre in dto.Genres) { gameGenres.Add(new GameGenre { GenreId = genre }); } var game = new Domain.Game { Name = dto.Name, Engine = dto.Engine, DeveloperId = dto.DeveloperId, PublisherId = dto.PublisherId, ReleaseDate = dto.ReleaseDate, UserId = dto.UserId, GameMode = dto.GameMode, AgeLabel = dto.AgeLabel, GamePlatforms = gamePlatforms, GameGenres = gameGenres, Path = path }; await _context.Games.AddAsync(game); await _context.SaveChangesAsync(); }
public async Task <IActionResult> Post([FromForm] CreateGameDTO dto) { var validator = new GameFluentValidator(_context); var errors = await validator.ValidateAsync(dto); if (!errors.IsValid) { return(UnprocessableEntity(ValidationFormatter.Format(errors))); } try { await _gamesService.Create(dto); return(StatusCode(201)); } catch (Exception e) { var s = 2; return(StatusCode(500, e)); } }
public async Task <IActionResult> Put(int id, [FromForm] CreateGameDTO dto) { var validator = new GameUpdateFluentValidator(_context, id); var errors = await validator.ValidateAsync(dto); if (!errors.IsValid) { return(UnprocessableEntity(ValidationFormatter.Format(errors))); } try { await _gamesService.Update(id, dto); return(NoContent()); } catch (EntityNotFoundException e) { return(NotFound(new { message = e.Message })); } catch (Exception) { return(StatusCode(500, new { message = "Server error, please try later." })); } }
public async Task Create(CreateGameDTO dto) { var(Server, FilePath) = await _fileService.Upload(dto.Path); var game = new Domain.Game { Name = dto.Name, Engine = dto.Engine, DeveloperId = dto.DeveloperId, PublisherId = dto.PublisherId, ReleaseDate = dto.ReleaseDate, UserId = dto.UserId, GameMode = dto.GameMode, AgeLabel = dto.AgeLabel, Path = Server, FullPath = FilePath }; await _context.Games.AddAsync(game); await _context.SaveChangesAsync(); //var game = new Domain.Game //{ // Name = dto.Name, // Engine = dto.Engine, // DeveloperId = dto.DeveloperId, // PublisherId = dto.PublisherId, // ReleaseDate = dto.ReleaseDate, // UserId = dto.UserId, // GameMode = dto.GameMode, // AgeLabel = dto.AgeLabel, // Path = dto.Path, // FullPath = dto.FilePath //}; //await _context.Games.AddAsync(game); // await _context.SaveChangesAsync(); }
public async Task <IActionResult> Post([FromForm] CreateGameDTO dto) { var validator = new GameFluentValidator(_context); var errors = await validator.ValidateAsync(dto); if (!errors.IsValid) { return(UnprocessableEntity(ValidationFormatter.Format(errors))); } try { var user = Int32.Parse(HttpContext.User.FindFirst("id").Value); dto.UserId = user; await _gamesService.Create(dto); return(StatusCode(201)); } catch (Exception e) { return(StatusCode(500, e)); } }
public async Task Post_GivenGame_WhenNoToken_ThenUnauhorizedResponse() { // Arrange var newGame = new CreateGameDTO { Name = "FIFA", AcquisicionDate = DateTime.Now.AddDays(-30), Kind = "1", Observation = "UM jogo muito legal" }; var myContent = JsonConvert.SerializeObject(newGame); var buffer = Encoding.UTF8.GetBytes(myContent); var byteContent = new ByteArrayContent(buffer); byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); // Act var response = await _client.PostAsync("/gtracker/game", byteContent); // Assert response.StatusCode.Should().Be(HttpStatusCode.Unauthorized); }
public async Task Update(int id, CreateGameDTO dto) { var game = await _context.Games.FirstOrDefaultAsync(g => g.Id == id); if (game == null) { throw new EntityNotFoundException("Game"); } // Check if user sent picture, if send that means he is changing cover image if (dto.Path != null) { var(Server, FilePath) = await _fileService.Upload(dto.Path); //Remove previous image in case if user uploaded new image await _fileService.Remove(game.FullPath); game.Path = Server; game.FullPath = FilePath; } if (game.Name != dto.Name) { game.Name = dto.Name; } if (game.Engine != dto.Engine) { game.Engine = dto.Engine; } if (game.DeveloperId != dto.DeveloperId) { game.DeveloperId = dto.DeveloperId; } if (game.PublisherId != dto.PublisherId) { game.PublisherId = dto.PublisherId; } if (game.AgeLabel != dto.AgeLabel) { game.AgeLabel = dto.AgeLabel; } if (game.ReleaseDate != dto.ReleaseDate) { game.ReleaseDate = dto.ReleaseDate; } if (dto.UserId == null) { game.UserId = game.UserId; } if (game.GameMode != dto.GameMode) { game.GameMode = dto.GameMode; } if (game.DeveloperId != dto.DeveloperId) { game.DeveloperId = dto.DeveloperId; } _context.Entry(game).State = EntityState.Modified; await _context.SaveChangesAsync(); }
public Game(CreateGameDTO dto) { this.GameId = new Guid(dto.GameId); this.MapName = dto.MapName; switch (dto.MapShape.ToLower()) { case "square": this.MapShape = MapShape.Square; break; case "hexa": this.MapShape = MapShape.Square; break; default: throw new Exception("Invalid or not supported map shape"); } this.MapWidth = dto.MapWidth; dto.Tiles.ForEach(x => { this.Tiles.Add(new Tile(x)); }); dto.Players.ForEach(x => { this.Players.Add(new Player(x) { Game = this }); x.Entities.ForEach(obj => { switch (obj.Type.ToLower()) { case "orcwarrior": { this.GameObjects.Add(new OrcWarrior(obj) { Player = this.Players.SingleOrDefault(p => p.Id == new Guid(x.Id)) }); break; } case "knightwarrior": { this.GameObjects.Add(new KnightWarrior(obj) { Player = this.Players.SingleOrDefault(p => p.Id == new Guid(x.Id)) }); break; } default: throw new Exception("Invalid entity type"); } }); }); this.CurrentPlayer = this.Players.First(); dto.GameObjects.ForEach(x => { switch (x.Type.ToLower()) { case "orcwarrior": { this.GameObjects.Add(new OrcWarrior(x)); break; } case "knightwarrior": { this.GameObjects.Add(new KnightWarrior(x)); break; } default: throw new Exception("Invalid entity type"); } }); //setting neighbours for (int i = 0; i < dto.Tiles.Count; i++) { this.Tiles[i].Game = this; dto.Tiles[i].Neighbours.ForEach(x => { this.Tiles[i].Neighbours.Add(this.Tiles.SingleOrDefault(y => y.Id == new Guid(x))); }); } //setting position for gameobjects dto.GameObjects.ForEach(x => { this.GameObjects.ForEach(y => { y.Game = this; if (y.Id == new Guid(x.Id)) { y.Position = this.Tiles.SingleOrDefault(t => t.Id == new Guid(x.Position)); } }); }); dto.Players.ForEach(x => { x.Entities.ForEach(e => { this.GameObjects.ForEach(g => { g.Game = this; if (g.Id == new Guid(e.Id)) { g.Position = this.Tiles.SingleOrDefault(t => t.Id == new Guid(e.Position)); } }); }); }); }
public async Task Update(int id, CreateGameDTO dto) { }
public async Task Post(CreateGameDTO game) { var registerCommand = _Mapper.Map <RegisterNewGameCommand>(game); await _Bus.SendCommand(registerCommand); }