public async Task <GameUpdateViewModel> GetGameUpdateDataAsync(int id)
{
var game = await gameDbService.GetUpdateDataAsync(id);
if (game == null)
{
return(null);
}
//var platformList = await platformDbService.GetAllAsync();
//var genreList = await genreDbService.GetAllAsync();
//var languageList = await languageDbService.GetAllAsync();
//var mediaTypeList = await mediaTypeDbService.GetAllAsync();
//var seriesList = await seriesDbService.GetAllAsync();
//var modeList = await modeDbService.GetAllAsync();
//var developerList = await developerDbService.GetAllAsync();
//var publisherList = await publisherDbService.GetAllAsync();
//return GameMapper.ToUpdateViewModel(game, platformList, genreList, languageList, mediaTypeList, seriesList, modeList, developerList, publisherList);
GameUpdateViewModel vm = GameMapper.ToUpdateViewModel(game);
await FillSelectLists(vm);
return(vm);
}
public void MapGameToGameViewModel(bool hasCategories, bool hasElectedCategories, bool hasPlayedDates)
{
var game = new Game
{
Id = 2,
Name = "Game 1"
};
var categories = hasCategories ? new List <SelectListItem> {
new SelectListItem {
Value = "1", Text = "Category 1"
}
} : null;
var electedCategories = hasElectedCategories ? new List <CategoryViewModel> {
new CategoryViewModel {
Id = 1, Description = "Category 1"
}
} : null;
var playedDates = hasPlayedDates ? new List <PlayedDateViewModel> {
new PlayedDateViewModel {
Id = 1, FormattedPlayedDate = "1/1/2016"
}
} : null;
var mapper = new GameMapper();
var viewModel = mapper.Map(game, categories, electedCategories, playedDates);
Assert.NotNull(viewModel);
Assert.Equal(hasCategories ? 1 : 0, viewModel.Categories.Count());
Assert.Equal(hasElectedCategories ? 1 : 0, viewModel.ElectedCategories.Count());
Assert.Equal(hasPlayedDates ? 1 : 0, viewModel.PlayedDates.Count());
}
//Method that posts the information for UpdateGame
public ActionResult UpdateGame(GamesPO form)
{
//Declaring local variables
ActionResult oResponse = RedirectToAction("Index", "Game");
//Checking if Model state is Valid
if (ModelState.IsValid)
{
try
{
//Mapping in a dataAccess call
GamesDO dataObject = GameMapper.MapPoToDo(form);
dataAccess.UpdateGames(dataObject);
}
catch (Exception ex)
{
oResponse = View(form);
}
}
else
{
oResponse = View(form);
}
return(oResponse);
}
public ActionResult CreateGame(GamesPO form)
{
//Declaring local variables
ActionResult oResponse = RedirectToAction("Index", "Game");
//Checking if Model state is Valid
if (ModelState.IsValid)
{
try
{
//Mapping in a dataAccess call
GamesDO dataObject = GameMapper.MapPoToDo(form);
dataAccess.CreateNewGame(dataObject);
TempData["Message"] = $"{form.GameName} was created successfully";
}
catch (Exception ex)
{
oResponse = View(form);
}
}
else
{
oResponse = View(form);
}
return(oResponse);
}
//
// GET: /Game/
public GameController(IGameService gameService)
{
//IGameService gameService = new GameService(new GameRepository(), new TeamRepository());
_gameService = gameService;
_gameMapper = new GameMapper();
}
public override void Serialize(Stream stream)
{
using (var w = stream.ToBinaryWriter(true))
{
w.WriteEnum(GameMapper.GetOpCode(GetType()));
Serializer.Serialize(w, this);
}
}
public async Task <bool> UpdateResultsInDuplicateEntryAsync(GameUpdateViewModel vm)
{
var updatedGame = GameMapper.ToGame(vm);
bool resultsInDuplicateGame = await gameDbService.CommandResultsInDuplicateEntryAsync(updatedGame);
return(resultsInDuplicateGame);
}
public async Task <GameIndexViewModel> GetGameIndexAsync(int hoarderID)
{
var games = await gameDbService.GetAllAsync(hoarderID);
var vm = GameMapper.ToIndexViewModel(games);
return(vm);
}
public GameController(GameMapper GameMapper, GameService GameService, CollectionMapper CollectionMapper, CollectionService CollectionService, BoardGameRepository DatabaseContext)
{
_gameMapper = GameMapper;
_gameService = GameService;
_collectionMapper = CollectionMapper;
_collectionService = CollectionService;
_boardGameRepository = DatabaseContext;
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
UserMapper.MapRelations(modelBuilder);
GameMapper.MapRelations(modelBuilder);
GameMapper.MapPropConfig(modelBuilder);
GameResultMapper.MapRelations(modelBuilder);
ChatMessageMapper.MapRelations(modelBuilder);
}
public async Task <GameDetailsViewModel> GetGameDetailsAsync(int id)
{
var game = await gameDbService.GetDetailsAsync(id);
if (game == null)
{
return(null);
}
var vm = GameMapper.ToDetailsViewModel(game);
return(vm);
}
public ProudMessage GetMessage(ISession session, ushort opCode, BinaryReader r)
{
if (Enum.IsDefined(typeof(GameOpCode), opCode))
{
return(GameMapper.GetMessage((GameOpCode)opCode, r));
}
if (Enum.IsDefined(typeof(GameRuleOpCode), opCode))
{
return(GameRuleMapper.GetMessage((GameRuleOpCode)opCode, r));
}
throw new NetsphereBadOpCodeException(opCode);
}
public void RemoveAPlayer()
{
const string player1 = "player1";
AddingTwoPlayers();
Assert.AreEqual(1, DictionaryForPlayer1.Count);
Assert.AreEqual(1, DictionaryForPlayer2.Count);
GameMapper.Remove(player1);
Assert.AreEqual(0, DictionaryForPlayer1.Count);
Assert.AreEqual(0, DictionaryForPlayer2.Count);
}
public void MapGameToSelectListItem()
{
var game = new Game
{
Id = 2,
Name = "Game Name",
Description = "This is a game"
};
var mapper = new GameMapper();
var item = mapper.SelectMap(game);
Assert.Equal(game.Id.ToString(), item.Value);
Assert.Equal(game.Name, item.Text);
}
public void MapGameToGameViewModel()
{
var game = new Game
{
Id = 2,
Name = "Game Name",
Description = "This is a game"
};
var mapper = new GameMapper();
var viewModel = mapper.Map(game);
Assert.Equal(game.Id, viewModel.Id);
Assert.Equal(game.Name, viewModel.Name);
Assert.Equal(game.Description, viewModel.Description);
}
//Method that gets the information for UpdateGame
public ActionResult UpdateGame(Int64 gameId)
{
GamesPO displayObject = new GamesPO();
try
{
//Mapping in a dataAccess call
GamesDO game = dataAccess.ViewGameAtID(gameId);
displayObject = GameMapper.MapDoToPo(game);
}
catch (Exception ex)
{
}
return(View(displayObject));
}
public ActionResult Game(GameModel game)
{
if (ModelState.IsValid)
{
if (game.StartTime == DateTime.MinValue || game.EndTime == DateTime.MinValue)
{
ViewBag.Message = "DateTime Cannot be the Beggining of time";
return(View(game));
}
else if (game.StartTime > game.EndTime)
{
ViewBag.Message = "Game Start Time cannot be greater than end time";
return(View(game));
}
else if (game.EndTime < game.StartTime)
{
ViewBag.Message = "Game End Time cannot be less than start time";
return(View(game));
}
//Create Map
GameMapper mapGame = new GameMapper();
Game addGame = mapGame.MapGame(game);
if (addGame.HomeTeam == addGame.AwayTeam)
{
ViewBag.Message = "Home Team Cannot Be the Same as Away Team?";
return(View(game));
}
else
{
gameBLL.CreateGame(addGame);
}
//check insert added
List <Game> checkGame = gameBLL.GetGames();
if (checkGame.Exists(m => m.StartTime == addGame.StartTime))
{
ViewBag.Message = "Game Created!";
}
else
{
ViewBag.Message = "Game Failed!";
}
}
return(View(game));
}
public IActionResult GetGame()
{
try
{
var gamesList = _context.Game
.Include(game => game.Developer)
.Include(game => game.Image)
.Include(game => game.Video)
.Include(game => game.Rating)
.Include(game => game.Comment);
var gameDtoList = gamesList.Select(model => GameMapper.ConvertModelToDto(model)).ToList();
return(Ok(gameDtoList));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public GameMapperTest()
{
GameMapper = new GameMapper();
const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance;
FieldInfo fieldForPlayer1 = typeof(GameMapper).GetField("_opponentOfPlayer1", flags);
FieldInfo fieldForPlayer2 = typeof(GameMapper).GetField("_opponentOfPlayer2", flags);
Assert.IsNotNull(fieldForPlayer1);
Assert.IsNotNull(fieldForPlayer2);
DictionaryForPlayer1 = fieldForPlayer1.GetValue(GameMapper) as Dictionary <string, string>;
DictionaryForPlayer2 = fieldForPlayer2.GetValue(GameMapper) as Dictionary <string, string>;
Assert.IsNotNull(DictionaryForPlayer1);
Assert.IsNotNull(DictionaryForPlayer2);
}
public ActionResult Index()
{
List <GamesPO> mappedItem = new List <GamesPO>();
try
{
//Mapping in a dataAccess call
List <GamesDO> dataObject = dataAccess.ViewAllGames();
mappedItem = GameMapper.MapDoToPo(dataObject);
}
catch (Exception ex)
{
if (ex.Data.Contains("Message"))
{
TempData["Message"] = "No Games Found";
}
}
return(View(mappedItem));
}
public override async Task <Game> GetById(long gameId)
{
var sqlQuery = @"SELECT * FROM Game
INNER JOIN PlayerInGame ON Game.Id = PlayerInGame.GameId
INNER JOIN Player ON PlayerInGame.PlayerId = Player.Id
WHERE Game.Id = @gameId" ;
var gameDictionary = new Dictionary <long, Game>();
var gameMapper = new GameMapper();
using (var db = new SqlConnection(_connectionString))
{
Game currentGame = (await db.QueryAsync(
sqlQuery,
gameMapper.GetMap(gameDictionary),
param: new { gameId }
)).FirstOrDefault();
return(currentGame);
}
}
private void Arrange()
{
_gameMapper = new GameMapper();
_games = new List <Game>();
_games.Add(new Game
{
Id = 23,
DisplayName = "nems",
IsDeleted = false,
ReferenceName = "nemees"
});
_games.Add(new Game
{
Id = 673745,
DisplayName = "qwqeqwe",
IsDeleted = true,
ReferenceName = "qwwq"
});
}
public async Task <GameCreateViewModel> GetGameCreateDataAsync()
{
var platformList = await platformDbService.GetAllAsync();
var genreList = await genreDbService.GetAllAsync();
var languageList = await languageDbService.GetAllAsync();
var mediaTypeList = await mediaTypeDbService.GetAllAsync();
var seriesList = await seriesDbService.GetAllAsync();
var modeList = await modeDbService.GetAllAsync();
var developerList = await developerDbService.GetAllAsync();
var publisherList = await publisherDbService.GetAllAsync();
return(GameMapper.ToCreateViewModel(platformList, genreList, languageList, mediaTypeList, seriesList, modeList, developerList, publisherList));
}
public void AddingTwoPlayers()
{
const string player1 = "player1";
const string player2 = "player2";
string value;
GameMapper.Add(player1, player2);
Assert.AreEqual(1, DictionaryForPlayer1.Count);
Assert.AreEqual(1, DictionaryForPlayer2.Count);
Assert.IsTrue(DictionaryForPlayer1.ContainsKey(player1));
Assert.IsTrue(DictionaryForPlayer2.ContainsKey(player2));
Assert.IsTrue(DictionaryForPlayer1.TryGetValue(player1, out value));
Assert.AreEqual(player2, value);
Assert.IsTrue(DictionaryForPlayer2.TryGetValue(player2, out value));
Assert.AreEqual(player1, value);
}
public IActionResult GetUserGames([FromBody] UserGame userGame)
{
if (userGame == null)
{
return(BadRequest());
}
try
{
var gamesList = _context.Game
.Include(game => game.Developer)
.Include(game => game.Image)
.Include(game => game.Video)
.Include(game => game.Rating)
.Include(game => game.Comment);
var purchases = _context.Purchase
.Include(p => p.PurchaseItens)
.Where(p => p.UserId == userGame.UserId);
var ownedGames = new List <int>();
foreach (var purchase in purchases)
{
foreach (var item in purchase.PurchaseItens)
{
if (!ownedGames.Contains(item.GameId))
{
ownedGames.Add(item.GameId);
}
}
}
var gameDtoList = gamesList
.Where(g => ownedGames.Contains(g.Id))
.Select(model => GameMapper.ConvertModelToDto(model))
.ToList();
return(Ok(gameDtoList));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public static void AddGraphics(GameClient game, GraphicsDeviceManager graphics, SpriteBatch spriteBatch)
{
Systems.graphics = graphics;
Systems.spriteBatch = spriteBatch;
Systems.screen = new ScreenSys(game);
Systems.mapper = new GameMapper(game, spriteBatch);
Systems.mapper.PostLoad();
Systems.camera = new Camera(Systems.scene);
// Add Textures
Systems.tex2dBlack = new Texture2D(Systems.graphics.GraphicsDevice, 1, 1);
Systems.tex2dBlack.SetData(new[] { Color.Black });
Systems.tex2dWhite = new Texture2D(Systems.graphics.GraphicsDevice, 1, 1);
Systems.tex2dWhite.SetData(new[] { Color.White });
Systems.tex2dDarkRed = new Texture2D(Systems.graphics.GraphicsDevice, 1, 1);
Systems.tex2dDarkRed.SetData(new[] { Color.DarkRed });
Systems.tex2dDarkGreen = new Texture2D(Systems.graphics.GraphicsDevice, 1, 1);
Systems.tex2dDarkGreen.SetData(new[] { Color.DarkGreen });
}
public async Task <IActionResult> PostGame([FromBody] GameUploadDto gameDto)
{
if (gameDto == null)
{
return(BadRequest());
}
try
{
var game = GameMapper.ConvertDtoToModel(gameDto);
_context.Game.Add(game);
await _context.SaveChangesAsync();
SaveGameTrailer(game.Id, gameDto.TrailerUrl);
return(Ok(game.Id));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public IActionResult GetGameWithFilters([FromBody] GameFilterDto filterDto)
{
if (filterDto == null)
{
return(BadRequest());
}
try
{
var gamesList = _context.Game
.Include(game => game.Developer)
.Include(game => game.Image)
.Include(game => game.Video)
.Include(game => game.Rating)
.Include(game => game.Comment);
var gameDtoList = gamesList.Select(model => GameMapper.ConvertModelToDto(model)).ToList();
if (filterDto.Name.Length > 0)
{
gameDtoList = gameDtoList.Where(game => game.Name.ToLower().Contains(filterDto.Name.ToLower())).ToList();
}
if (filterDto.Price > 0)
{
gameDtoList = gameDtoList.Where(game => game.Price <= filterDto.Price).ToList();
}
if (filterDto.Genre.Length <= 0)
{
return(Ok(gameDtoList));
}
{
var genre = GameMapper.ConvertGenderFieldToEnum(filterDto.Genre);
gameDtoList = gameDtoList.Where(game => game.Genre.Contains(genre)).ToList();
}
return(Ok(gameDtoList));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public void MapNullToGameViewModel(bool hasCategories, bool hasElectedCategories, bool hasPlayedDates)
{
var categories = hasCategories ? new List <SelectListItem> {
new SelectListItem {
Value = "1", Text = "Category 1"
}
} : null;
var electedCategories = hasElectedCategories ? new List <CategoryViewModel> {
new CategoryViewModel {
Id = 1, Description = "Category 1"
}
} : null;
var playedDates = hasPlayedDates ? new List <PlayedDateViewModel> {
new PlayedDateViewModel {
Id = 1, FormattedPlayedDate = "1/1/2016"
}
} : null;
var mapper = new GameMapper();
var viewModel = mapper.Map(null, categories, electedCategories, playedDates);
Assert.NotNull(viewModel);
}
//Method that creates a Cart
public ActionResult Cart()
{
List <GamesPO> displayGames = new List <GamesPO>();
try
{
List <GamesBO> businessObjects = new List <GamesBO>();
List <int> cart = (List <int>)Session["Cart"];
foreach (int gameId in cart)
{
GamesDO games = dataAccess.ViewGameAtID(gameId);
displayGames.Add(GameMapper.MapDoToPo(games));
businessObjects.Add(GamesBOMapper.MapDoToBo(games));
}
decimal totalSum = businessLayer.CalculationSum(businessObjects);
ViewBag.Total = totalSum;
}
catch (Exception ex)
{
}
return(View(displayGames));
}
private async Task <GameViewItem> GetGameViewItem(long gameId)
{
var gameMapper = new GameMapper();
Game game = await _gameRepository.GetById(gameId);
List <long> playerIds = game.PlayersInGame.Select(playerInGame => playerInGame.PlayerId).ToList();
List <PlayerInGame> playersInGame = await _playerInGameRepository.GetPlayersInGameByPlayerIds(playerIds);
List <long> deck = await GetDeckInGame(gameId);
GameViewItem gameViewItem = gameMapper.GetView(game, playersInGame, deck);
if (gameViewItem.Human.Points <= Constant.MinPointsValueToPlay)
{
await _playerRepository.UpdatePlayersPoints(new List <long> {
gameViewItem.Human.Id
}, Constant.DefaultPointsValue);
gameViewItem.Human.Points = Constant.DefaultPointsValue;
}
return(gameViewItem);
}
