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);
}
