public async Task EditGameAsync(Guid UserId, GameDto new_game, IEnumerable <PropertyDto> new_genres, List <IFormFile> Medias, List <IFormFile> CoverArt, string rootdir)
{
var game = await dbContext.Games
.Include(x => x.Medias)
.FirstOrDefaultAsync(x => x.Id == new_game.Id);
game.GameName = new_game.GameName;
game.Price = new_game.Price;
game.Release = DateTime.Parse(new_game.Release + " 0:00");
var genres_to_delete = await dbContext.GameProperties.Where(x => x.GameId == new_game.Id && x.Property.type == 0).ToListAsync();
dbContext.GameProperties.RemoveRange(genres_to_delete);
foreach (var g in new_genres)
{
System.Diagnostics.Debug.WriteLine("A genre:" + g.name);
dbContext.GameProperties.Add(new GameProperty
{
GameId = game.Id,
PropertyId = g.Id
}
);
}
await SaveMediasAsync(game, Medias, CoverArt, rootdir);
await dbContext.SaveChangesAsync();
}
public GameDto CreateNewGame(GameDto gameDto)
{
var game = Mapper.Map <Game>(gameDto);
foreach (var genreInDto in gameDto.Genres)
{
var genreResult = _unitOfWork.GenreRepository
.GetByPropertyValue(g => g.Name == genreInDto)
.FirstOrDefault();
if (genreResult != null)
{
game.Genres.Add(genreResult);
}
}
foreach (var platformTypeInDto in gameDto.PlatformTypes)
{
var platformTypeResult = _unitOfWork.PlatformTypeRepository
.GetByPropertyValue(g => g.Type == platformTypeInDto)
.FirstOrDefault();
if (platformTypeResult != null)
{
game.PlatformTypes.Add(platformTypeResult);
}
}
_unitOfWork.GameRepository.Insert(game);
_unitOfWork.Commit();
gameDto = Mapper.Map <GameDto>(gameDto);
return(gameDto);
}
public void test1()
{
GameDto g1 = new GameDto("012345678", "Player1");
GameDto g2 = new GameDto("012345678", "Player1");
Assert.AreEqual <GameDto>(g1, g2);
}
private PlayerDto RunGame(GameDto game)
{
if (game.Players.Count != NUMBER_PLAYERS)
{
throw new Exception(ERROR_MESSAGE_NUMBER_PLAYERS_INCORRECT);
}
var player1 = game.Players[0];
var player2 = game.Players[1];
if (player1.Move.EqualsIgnoreCase(player2.Move))
{
return(player1);
}
switch (char.ToUpperInvariant(player1.Move))
{
case GameConstants.Rock:
return(player2.Move.EqualsIgnoreCase(GameConstants.Scissor) ? player1 : player2);
case GameConstants.Paper:
return(player2.Move.EqualsIgnoreCase(GameConstants.Rock) ? player1 : player2);
case GameConstants.Scissor:
return(player2.Move.EqualsIgnoreCase(GameConstants.Paper) ? player1 : player2);
default:
throw new Exception(message: ERROR_MESSAGE_STRATEGY_ERROR);
}
}
private async Task OnNextStep(
string roomId,
int currentRoundNumber,
string currentHiddenWord,
GameDto gameDto,
GameEntity gameEntity)
{
if (currentRoundNumber < gameEntity.RoundNumber)
{
await SendNotificationAfterEndOfRound(roomId, currentHiddenWord, currentRoundNumber + 1);
}
if (gameEntity.GameState == GameState.Finished)
{
var pointsWinner = gameEntity.Players.Max(p => p.Score);
var winner = gameEntity.Players.First(p => p.Score == pointsWinner);
userRepository.IncreaseWinsCount(winner);
foreach (var player in gameEntity.Players)
{
userRepository.UpdateStatistics(player);
}
gameEntity.Start();
gameDto = mapper.Map <GameDto>(gameEntity);
roomRepository.UpdateGame(int.Parse(roomId), gameDto);
var victoryNotification = MessageFactory.CreateVictoryNotification(winner.Name);
await Clients.Group(roomId).SendAsync(RoomHubEvents.GameOver, victoryNotification);
}
else
{
await Clients.Group(roomId).SendAsync(RoomHubEvents.RoundInfo,
gameEntity.ExplainingPlayerName, gameEntity.GetSecondsLeft());
}
}
public void Given_a_game_When_CreateGame_is_called_Then_creation_is_done_with_success()
{
//Arrange
var gameDto = new GameDto()
{
GameInformation = new GameInformationDto()
{
Id = Guid.NewGuid().ToString(),
NomPlayer1 = "Player1",
NomPlayer2 = "Player2"
},
Grid = new TokenDto[, ] {
{ TokenDto.X, TokenDto.X, TokenDto.O },
{ TokenDto._, TokenDto.O, TokenDto._ },
{ TokenDto.X, TokenDto._, TokenDto._ }
},
MoveCounter = 5
};
//Act
var response = _client.Post <GameDto>(UrlGame.CreateGameWithGrid, gameDto);
// Assert
Assert.True(response.Success, $"Erreur retournée par l'API : {response.Error}");
Assert.Equal <GameDto>(gameDto, response.Value);
}
public async Task PatchGameAsync(string vendorUserName, int id, GameDto game)
{
var gameInDB = _context.Games.Include("Vendor").Single(game => game.ID == id);
if (gameInDB.Vendor.Username != vendorUserName)
{
throw new WrongVendorException();
}
gameInDB.Name = game.Name;
gameInDB.Price = game.Price;
_context.Entry(gameInDB).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GameExists(id))
{
throw new ItemNotFoundException();
}
else
{
throw;
}
}
}
private void GameOver(object sender, GameDto gameDto)
{
Context.CurrentGame.Sharks = new List <SharkDto>();
Context.CurrentGame.Message = gameDto.Message;
Context.CurrentGame.IsStarted = gameDto.IsStarted;
InvokeAsync(StateHasChanged);
}
public virtual void Create(GameDto item)
{
try
{
if (item == null)
{
throw new ValidationException("Invalid id", "id");
}
if (!this.IsUniqueKey(item.Key))
{
throw new ValidationException("Key is not unique", "Key");
}
this.unitOfWork.Games.Create(Mapper.Map<Game>(item));
this.unitOfWork.Save();
}
catch (ValidationException exception)
{
this.logger.Debug(exception.Message);
throw;
}
catch (Exception exception)
{
this.logger.Error(exception.Message);
this.logger.Trace(exception.StackTrace);
throw;
}
}
public IHttpActionResult CreateGame(GameDto gameDto)
{
dynamic Response = new ExpandoObject();
try
{
if (!ModelState.IsValid)
{
Response.Status = ConstantValues.ResponseStatus.ERROR;
Response.Message = ConstantValues.ErrorMessage.BAD_REQUEST;
return(Content(HttpStatusCode.BadRequest, Response));
}
var game = Mapper.Map <GameDto, Game>(gameDto);
_context.Games.Add(game);
_context.SaveChanges();
gameDto.id = game.id;
Response.Status = ConstantValues.ResponseStatus.OK;
Response.Game = gameDto;
return(Created(new Uri(Request.RequestUri + "/" + game.id), Response));
}
catch (Exception e)
{
Response.Status = ConstantValues.ResponseStatus.ERROR;
Response.Message = ConstantValues.ErrorMessage.INTERNAL_SERVER_ERROR;
return(Content(HttpStatusCode.InternalServerError, Response));
}
}
public Result <int> CreateGame(List <ShipDto> ships, string connectionId)
{
var enemyShips = new ShipGenerator().GenerateShips();
var model = new GameDto
{
ConnectionId = connectionId,
UserArea = new AreaDto
{
Ships = ships
},
ComputerArea = new AreaDto
{
Ships = enemyShips
}
};
try
{
var dbModel = _mapper.Map <GameDb>(model);
_context.Games.Add(dbModel);
_context.SaveChanges();
return(Result.Success(dbModel.Id));
}
catch (DbUpdateException ex)
{
return(Result.Failure <int>(ex.Message));
}
}
public void Render(GameDto gameDto)
{
System.Console.WriteLine("Grid :");
System.Console.WriteLine();
System.Console.WriteLine(String.Format(" {0} {1} {2}\n {3} {4} {5}\n {6} {7} {8}\n\n",
gameDto.Grid[0],
gameDto.Grid[1],
gameDto.Grid[2],
gameDto.Grid[3],
gameDto.Grid[4],
gameDto.Grid[5],
gameDto.Grid[6],
gameDto.Grid[7],
gameDto.Grid[8]));
System.Console.WriteLine(String.Format("{0}, this your turn", gameDto.CurrentPlayerCode));
System.Console.Write("Select and press enter :");
string text = Console.ReadLine();
int userSelection;
if (Int32.TryParse(text, out userSelection))
{
uiCommandChannel.SubmitUICommand <PlayCommand>(
new PlayCommand(gameDto.CurrentPlayerCode, userSelection % 3, userSelection / 3));
}
}
private void GameChanged(object sender, GameDto game)
{
Context.CurrentGame.IsStarted = game.IsStarted;
Context.CurrentGame.Message = game.Message;
Context.CurrentGame.IsEasy = game.IsEasy;
Context.CurrentGame.Score = game.Score;
}
public ActionResult AddGameToBasket(string gameKey)
{
GameDto game = _gameService.GetGameByKey(gameKey);
if (game.Deleted)
{
throw new GameDeletedException();
}
var basket = Session[Basket] as List <Purchase>;
if (basket == null)
{
basket = new List <Purchase>();
Session[Basket] = basket;
}
const short gamesQuantity = 1;
if (basket.Count(p => p.GameId == game.Id) == 0)
{
var purchase = new Purchase(game.Id, game.LanguagesNames["ru"], game.Price, gamesQuantity);
basket.Add(purchase);
}
else
{
basket.Single(p => p.GameId == game.Id).Quantity += gamesQuantity;
}
CreateOrUpdateCurrentOrder(basket);
return(RedirectToAction("GetCurrentOrderDetails"));
}
public async Task <IActionResult> Details([FromRoute] Guid id)
{
GameDto gameDto = await gameService.GetGameByIdAsync(id);
bool isOwned;
bool isMyDevelopment;
try
{
var UserId = Guid.Parse(User.Claims.Where(c => c.Type == ClaimTypes.NameIdentifier).First().Value);
isOwned = gameService.IsOwnedGame(UserId, id);
isMyDevelopment = gameDto.UserId == UserId;
}
catch (Exception e)
{
isOwned = false;
isMyDevelopment = false;
}
return(Ok(new
{
game = gameDto,
isOwned = isOwned,
isMyDevelopment = isMyDevelopment
}));
}
public async Task <IActionResult> GetGame([FromRoute] int gameId)
{
Game game = repo.GetGame(gameId);
WAUser gameAuthor = await repo.GetGameAuthor(game);
var genre = repo.GetGenreById(game.GenreId);
var gameDto = new GameDto()
{
Descr = game.Descr,
Name = game.Name,
Id = game.Id,
Genre = genre.Descr,
Author = new UserDto()
{
Username = gameAuthor.UserName
}
};
if (gameDto != null)
{
return(StatusCode(200, responses.GameFoundResponse(gameDto)));
}
else
{
return(StatusCode(500, ErrorResponse.ServerError));
}
}
public ActionResult CreateGame(GameDto gameDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
//var movie = new Movie
//{
// Name = movieDto.Name,
// GenreId = movieDto.GenreId,
// DateAdded = DateTime.Now,
// ReleaseDate = movieDto.ReleaseDate,
// NumberInStock = movieDto.NumberInStock
//};
var game = new Game();
game = _mapper.Map(gameDto, game);
gameDto.Id = game.Id;
_context.Games.Add(game);
_context.SaveChanges();
return(Ok(gameDto));
}
private void UpdateWindow(GameDto game)
{
var bombs = game.Board.Bombs;
var flags = game.Board.Fields.Where(x => x.State == FieldState.Flag).Count();
BombsTextBlock.Text = (bombs - flags).ToString();
RestartButton.Source = _assets.GameStates[game.GameState];
if (Game.GameState == GameState.New && game.GameState == GameState.InProgress)
{
_timer.Start();
}
Game.GameState = game.GameState;
if (Game.GameState == GameState.Won || Game.GameState == GameState.Lost)
{
_timer.Stop();
}
if (Game.GameState == GameState.Won)
{
MessageBox.Show($"Game won in {Math.Round(game.RoundTime.TotalSeconds, 3)} s.");
}
}
public IActionResult UpdateGame([FromRoute] int gameId, [FromBody] GameDto gameDto)
{
(IActionResult result, bool isOwner) = EnsureAuthorOwnsGame(gameDto, gameId);
if (!isOwner)
{
return(result);
}
try
{
if (gameId == 0)
{
return(StatusCode(400, ErrorResponse.CustomErrorCode(400, "You're not updating a game.")));
}
repo.UpdateGame(gameDto, gameId);
var updatedGameDto = new GameDto
{
Id = gameId,
Author = gameDto.Author,
Descr = gameDto.Descr,
Genre = gameDto.Genre,
Name = gameDto.Name
};
var successResponse = responses.UpdateResponse(updatedGameDto);
return(StatusCode(200, successResponse));
}
catch (Exception e)
{
return(StatusCode(500, ErrorResponse.ServerError));
}
}
private GameDto CreateLinksForGame(GameDto game)
{
game.Links.Add(new LinkDto(_urlHelper.Link("GetGameForReview",
new { id = game.Id }),
"self",
"GET"));
game.Links.Add(
new LinkDto(_urlHelper.Link("DeleteGame",
new { id = game.Id }),
"delete_game",
"DELETE"));
game.Links.Add(
new LinkDto(_urlHelper.Link("UpdateGame",
new { id = game.Id }),
"update_game",
"PUT"));
game.Links.Add(
new LinkDto(_urlHelper.Link("PartiallyUpdateGame",
new { id = game.Id }),
"partially_update_game",
"PATCH"));
return(game);
}
public GameDto GenerateNewTurn(GameDto Game)
{
var tempPlayers = new List <PlayerDto>();
foreach (var Turn in Game.Turn)
{
foreach (var Player in Turn.Players)
{
tempPlayers.Add(Player);
}
}
Game.Turn.Clear();
for (int i = 0; i < tempPlayers.ToArray().Length; i++)
{
if (i % 2 == 0)
{
var List = new List <PlayerDto>();
List.Add(tempPlayers[i]);
List.Add(tempPlayers[i + 1]);
Game.Turn.Add(GameRepository.AddTurn(List));
}
}
return(Game);
}
public async Task <IActionResult> GetGame([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var game = await _repo.GetByIdAsync <Game>(id);
if (!game.Success)
{
return(NotFound());
}
var gameDto = new GameDto
{
Id = game.Data.Id,
Name = game.Data.Name
};
return(Ok(gameDto));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public JsonResult CreateGameWithGrid([FromBody] GameDto vm)
{
// Map to the Entity
var game = Mapper.Map <Game>(vm);
var result = _repository.GetGameById(game.GameInfo.Id);
if (result.Success)
{
_logger.LogError($"La partie ne peut pas être créée car son identifiant '{game.GameInfo.Id}' est déjà utilisé");
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json("Une erreur s'est produite lors de la sauvegarde du nouveau jeu"));
}
//Create
var createResult = _repository.AddGame(game)
.OnSuccess(() => _repository.SaveAll());
if (createResult.Failure)
{
_logger.LogError($"Échec de la sauvegarde du nouveau jeu : {createResult.Error}");
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json($"Échec de la sauvegarde du nouveau jeu : {createResult.Error}"));
}
Response.StatusCode = (int)HttpStatusCode.OK;
return(Json(Mapper.Map <GameDto>(game)));
}
//pobranie pojedynczej gry
public async Task <ResultDto <GameDto> > GetGame(int id)
{
var result = new ResultDto <GameDto>()
{
Error = null
};
//probuje uzyskac wskazana gre
var game = await _repo.GetSingleEntity(x => x.Id == id);
if (game == null)
{
result.Error = "Nie odnaleziono gry";
return(result);
}
//wyciagniecie listy poradnikow do podanej gry w celu ich podliczenia
var guides = await _guideRepo.GetAllBy(x => x.GameId == id);
//tworze obiekt z gra i zwracam go
var gameToSend = new GameDto()
{
Id = game.Id,
Description = game.Description,
Name = game.Name,
Image = game.Image,
Rating = game.Rating,
GuidesCount = guides.Count
};
result.SuccessResult = gameToSend;
return(result);
}
public async Task AddAsync_AddsGame_WhenGameAdded()
{
//ARRANGE
var specificGameName = Guid.NewGuid().ToString();
var count = await fixture.Context.Games.CountAsync();
var imageCount = await fixture.Context.Images.CountAsync();
var gameDto = new GameDto
{
Name = specificGameName,
GameLogo = new ImageDto
{
File = new byte[0]
}
};
//ACT
var result = await service.AddAsync(gameDto);
//ASSERT
var game = await fixture.Context.Games.SingleOrDefaultAsync(g => g.Name == specificGameName);
Assert.Equal(count + 1, await fixture.Context.Games.CountAsync());
Assert.Equal(imageCount + 1, await fixture.Context.Images.CountAsync());
Assert.NotNull(game);
Assert.NotNull(game.GameLogo);
Assert.Equal(game.Id, result);
}
public ConfigureGameForm(GameDto game, CarouselClient client)
{
InitializeComponent();
this._CarouselClient = client;
this._Game = game;
this._Game.Load();
this.ExePathLabel.Text = this._Game.ExePath;
_BindingSource = new BindingSource();
_BindingSource.DataSource = this._Game.LocalFiles;
this.GameFileDataTable.DataSource = _BindingSource;
if (this.GameFileDataTable.RowCount >= 1)
{
for (int i = GameFileDataTable.ColumnCount - 1; i >= 0; i--)
{
if (i == GameFileDataTable.ColumnCount - 1)
{
GameFileDataTable.Columns[i].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
}
else
{
GameFileDataTable.Columns[i].AutoSizeMode = DataGridViewAutoSizeColumnMode.DisplayedCells;
}
}
}
}
public async Task <int> AddAsync(GameDto game)
{
var newGame = new Game
{
Name = game.Name,
Status = game.Status,
HasSite = game.HasSite,
GameKey = game.GameKey,
LinkEntryTypes = game.LinkEntryTypes,
StringEntryTypes = game.StringEntryTypes,
TagEntryTypes = game.TagEntryTypes,
ValueEntryTypes = game.ValueEntryTypes
};
if (game.GameLogo != null && game.GameLogo.File != null)
{
newGame.GameLogo = new Image {
File = game.GameLogo.File
}
}
;
Context.Games.Add(newGame);
await Context.SaveChangesAsync();
return(newGame.Id);
}
public ActionResult UpdateGame(string gameKey)
{
GameDto game = _gameService.GetGameByKey(gameKey);
if (game.Deleted)
{
throw new GameDeletedException();
}
IEnumerable <PlatformTypeDto> platformTypes = _platformTypeService.GetAllPlatformTypes();
var platformTypesMultiselect = new MultiSelectList(platformTypes, "Id", "Type");
IEnumerable <PublisherDto> publishers = _publisherService.GetAllPublishers();
var publishersMultiselect = new MultiSelectList(publishers, "Id", "CompanyName");
IEnumerable <GenreDto> genres = _genreService.GetAllGenres();
var genresMultiselect = new MultiSelectList(genres, "Id", "Name");
var model = game.ToUpdateViewModel();
model.AllPlatformTypes = platformTypesMultiselect;
model.AllGenres = genresMultiselect;
model.AllPublishers = publishersMultiselect;
return(View(model));
}
public async Task EditPost_Returns404_WhenCharacterDoesntExist()
{
//Arrange
var model = new CharacterEditViewModel
{
Id = 0,
Name = "Test"
};
var game = new GameDto()
{
Name = "test"
};
mockGameService.Setup(s => s.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(game);
mockCharacterService.Setup(s => s.GetByIdAsync(It.IsAny <int>())).ReturnsAsync((CharacterDto)null);
//Act
var result = await controller.Edit(model);
//Assert
var statusCodeResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(404, statusCodeResult.StatusCode);
}
public HttpStatusCodeResult ChangeGameQuantity(ChangeGameQuantityViewModel model)
{
var basket = Session[Basket] as List <Purchase>;
if (basket == null)
{
basket = new List <Purchase>();
GameDto game = _gameService.Get(model.Id);
basket.Add(new Purchase(game.Id, game.LanguagesNames["ru"], game.Price, model.Quantity));
Session[Basket] = basket;
}
else
{
Purchase purchase = basket.Single(p => p.GameId == model.Id);
if (model.Quantity == 0)
{
basket.Remove(purchase);
}
else
{
purchase.Quantity = model.Quantity;
}
}
CreateOrUpdateCurrentOrder(basket);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public async Task <IActionResult> NewGame()
{
// todo: match making queue/service
var oppenentId = 2;
User whiteUser = await _userRepo.GetUser(this.GetCurrentUserId());
User blackUser = await _userRepo.GetUser(oppenentId);
Game newGame = new Game(whiteUser, blackUser);
newGame.StatusCode = GameStatus.Inprogress;
newGame.Initialize();
_gameRepo.Add(newGame);
foreach (Piece piece in newGame.Pieces)
{
_gameRepo.Add(piece);
}
var result = await _gameRepo.SaveAll();
GameDto gameDto = _mapper.Map <GameDto>(newGame);
return(Created("/game/" + gameDto.Id + "/play", gameDto));
// return CreatedAtAction("GetGame", gameDto);
// return CreatedAtRoute( );
// Ok(gameDto);
}
public void Add_Game_With_Existing_Key()
{
//Arrange
var game = new GameDto { Key = "LoL", Name = "New", Description = "Awesome" };
//Act
this.gameAppService.Create(game);
}
public void Add_Game_With_Correct_Argument()
{
//Arrenge
var game = new GameDto
{
Key = "StarCraft2",
Name = "StarCraft2",
Description = "Awesome",
PlatformTypes = new List<PlatformTypeDto>() { new PlatformTypeDto() { Id = 1 } },
Genres = new List<GenreDto> { new GenreDto() { Id = 2 } }
};
//Act
this.gameAppService.Create(game);
//Assert
this.gameRepositoryMock.Verify(x => x.Create(It.IsAny<Game>()), Times.Once);
this.unitOfWorkMock.Verify(x => x.Save(), Times.Once);
}
public void Add_Game_With_Wrong_Genre()
{
//Arrenge
var game = new GameDto
{
Id = 1,
Key = "New",
Name = "New",
Description = "Awesome",
Genres = new List<GenreDto> { new GenreDto() { Id = 4 } }
};
//Act
this.gameAppService.Create(game);
}
public virtual void Update(GameDto item)
{
try
{
if (item == null)
{
throw new ValidationException("Item can not be null", "Key");
}
this.unitOfWork.Games.Update(Mapper.Map<Game>(item));
this.unitOfWork.Save();
}
catch (ValidationException exception)
{
this.logger.Debug(exception.Message);
throw;
}
catch (Exception exception)
{
this.logger.Error(exception.Message);
this.logger.Trace(exception.StackTrace);
throw;
}
}
public void Edit_Game_With_Existing_Key()
{
//Arrange
var game = new GameDto { Id = 1, Key = "LoL", Name = "StarCraft", Description = "Awesome" };
//Act
this.gameAppService.Update(game);
}
public void Edit_Game_With_Wrong_PlatforType()
{
//Arrenge
var game = new GameDto
{
Id = 1,
Key = "StarCraft",
Name = "StarCraft",
Description = "Awesome",
PlatformTypes = new List<PlatformTypeDto>() { new PlatformTypeDto() {Id = 6, Type = "Wrong"}}
};
//Act
this.gameAppService.Update(game);
}
public void Add_Game_With_Wrong_PlatformType()
{
//Arrenge
var game = new GameDto
{
Key = "New",
Name = "New",
Description = "Awesome",
PlatformTypes = new List<PlatformTypeDto>() { new PlatformTypeDto() { Id = 4 } }
};
//Act
this.gameAppService.Create(game);
}
public void Edit_Game_With_Wrong_Genre()
{
//Arrenge
var game = new GameDto
{
Id = 1,
Key = "StarCraft",
Name = "StarCraft",
Description = "Awesome",
Genres = new List<GenreDto> { new GenreDto() {Id = -1, Name = "Wrong"} }
};
//Act
this.gameAppService.Update(game);
}
