//! Metoda repozytorium AddGame.
/*!
* Zawiera elementy logiki dostępu do danych w celu dodania nowej gry w bazie danych.
*/
public Game AddGame(CreateGameDto game)
{
try
{
var gameExists = _dbContext.Games.SingleOrDefault(x => x.Name == game.Name && x.GamePlatformID == game.GamePlatformID);
if (gameExists != null)
{
throw new Exception(string.Format("Game with that name and game platform already exists"));
}
Game g = new Game
{
Name = game.Name,
ReleaseDate = game.ReleaseDate,
ProductionID = game.ProductionID,
GamePlatformID = game.GamePlatformID,
AgeRatingID = game.AgeRatingID,
Price = game.Price,
Description = game.Description,
Image = game.Image
};
this.Add(g);
return(g);
}
catch (Exception ex)
{
throw ex;
}
}
public Guid CreateGame(CreateGameDto request)
{
if (request.Rows < 4)
{
throw new BadRequestException("Must have at least 4 rows.");
}
if (request.Columns < 4)
{
throw new BadRequestException("Must have at least 4 columns.");
}
if (request.Players == null || request.Players.Count < 2)
{
throw new BadRequestException("Must have at least 2 players.");
}
if (request.Players.Count() != request.Players.Distinct().Count())
{
throw new BadRequestException("PlayersId's msut be unique.");
}
var rows = request.Rows;
var columns = request.Columns;
var gb = new GameBoard(rows, columns);
var gameId = Guid.NewGuid();
_uow.Games.AddGame(gameId, gb);
var info = new GameInfo(request.Players);
_uow.GameInfos.Add(gameId, info);
return(gameId);
}
public Game UpdateGame(CreateGameDto game)
{
Game g = gameRepo.UpdateGame(game);
g.GameGenres = gameGenreService.UpdateGameGenres(game.GameGenres, g.ID);
return(g);
}
public void Insert(CreateGameDto model)
{
var game = new Game(model.Name, model.Genre, model.Rating);
_unitOfWork.GameRepository.Add(game);
_unitOfWork.Commit();
}
public async Task AddGame(CreateGameDto gameDto)
{
using (unitOfWork)
{
if (await unitOfWork.GameRepository.GetSingleAsync(g =>
g.Name == gameDto.Name && g.PublisherId == gameDto.PublisherId) != null)
{
throw new ArgumentException("Game with such name of such publisher already exists");
}
if (await unitOfWork.PublisherRepository.GetSingleAsync(p => p.Id == gameDto.PublisherId) == null)
{
throw new ArgumentException("invalid publisher id");
}
var newGame = mapper.Map <Game>(gameDto);
unitOfWork.GameRepository.Create(newGame);
await AddPlatforms(gameDto.Platforms, newGame);
await AddGenres(gameDto.Genres, newGame);
await unitOfWork.CommitAsync();
}
}
public IActionResult PostGame([FromBody] CreateGameDto gameDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var game = new Game
{
Name = gameDto.Name
};
var creation = _repo.Create <Game>(game);
if (!creation.Success)
{
return(Ok(false));
}
return(Ok(true));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
//! Metoda repozytorium UpdateGame.
/*!
* Zawiera elementy logiki dostępu do danych w celu zapisania zmian do danych gry.
*/
public Game UpdateGame(CreateGameDto game)
{
try
{
var g = _dbContext.Games.SingleOrDefault(x => x.ID == game.ID);
if (g == null)
{
throw new Exception(string.Format("Cannot edit game, because game is not found."));
}
g.Name = game.Name;
g.ReleaseDate = game.ReleaseDate;
g.ProductionID = game.ProductionID;
g.GamePlatformID = game.GamePlatformID;
g.AgeRatingID = game.AgeRatingID;
g.Price = game.Price;
g.Description = game.Description;
g.Image = game.Image;
this.Update(g);
return(g);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <Game> CreateGame(CreateGameDto createGameDto)
{
var game = new Game
{
Guid = Guid.NewGuid(),
CreatedOn = DateTime.Now.ToUniversalTime(),
IsPublic = createGameDto.IsPublic
};
if (createGameDto.IterationGuid != Guid.Empty)
{
var iteration = await _workspaceService.GetIterationByGuid(createGameDto.IterationGuid);
if (iteration != null)
{
game.Iteration = iteration;
game.Iteration.UserStories = game.Iteration.UserStories == null ? new List <UserStory>() : game.Iteration.UserStories;
}
if (createGameDto.WorkspaceGuid != Guid.Empty)
{
var workspace = await _workspaceService.GetWorkspaceById(createGameDto.WorkspaceGuid);
game.IsPublic = !workspace.Configuration.IsPublic ? workspace.Configuration.IsPublic : createGameDto.IsPublic;
game.WorkspaceGuid = createGameDto.WorkspaceGuid;
}
game.ReleaseGuid = createGameDto.ReleaseGuid;
}
await _gameRepository.CreateOrUpdateGame(game);
return(game);
}
public int Create(CreateGameDto dto)
{
var gameEntity = _mapper.Map <Game>(dto);
_dbContext.Game.Add(gameEntity);
_dbContext.SaveChanges();
return(gameEntity.Id);
}
public async Task <IActionResult> CreateAsync([FromBody] CreateGameDto item)
{
Game entity = _mapper.Map <Game>(item);
_gameRepository.Create(entity);
await _gameRepository.SaveChangesAsync();
return(Ok(_mapper.Map <GetGameDto>(entity)));
}
public IActionResult CreateGame([FromBody] CreateGameDto game)
{
var newGame = new GameDto
{
Id = Guid.NewGuid(),
};
return(StatusCode(200, newGame));
}
public async Task <IActionResult> CreateGame([FromBody] CreateGameDto createGameDto)
{
var token = await HttpContext.GetTokenAsync("access_token");
if (await _logic.GameExists(createGameDto) == true)
{
return(Conflict("A game with those teams is already scheduled for that day."));
}
return(Ok(await _logic.CreateGame(createGameDto, token)));
}
public async Task <IActionResult> CreateGame([FromBody] CreateGameDto dto)
{
var game = await _games.CreateGame(dto.Name, dto.MakePublic);
if (game is null)
{
return(BadRequest());
}
return(Ok(game));
}
public async Task <IActionResult> CreateAsync([FromBody] CreateGameDto dto)
{
var createdGame = await _gameManager.CreateAsync(dto.User, dto.Name, dto.Password, dto.GameOptions);
_gamesTimers.Register(createdGame.Id, createdGame.Options.RoundTime);
await _lobbyHubContext.Clients.All.SendAsync("game_created", _mapper.Map <Game, GameSummary>(createdGame));
return(Ok(new
{
id = createdGame.Id
}));
}
public async Task <IActionResult> CreateGame([FromBody] GameCreateModel game)
{
CreateGameDto createdGame = new CreateGameDto()
{
Name = game.Name,
Description = game.Description,
PublisherId = game.PublisherId,
Genres = game.Genres,
Platforms = game.Platforms,
};
await gameService.AddGame(createdGame);
return(StatusCode((int)HttpStatusCode.Created, "Game was added"));
}
/*
*
*
* Game logic
*
*
*/
public async Task <bool> GameExists(CreateGameDto createGameDto)
{
var games = await _repo.GetGames();
foreach (Game game in games)
{
if (game.GameDate == createGameDto.GameDate &&
game.HomeTeamID == createGameDto.HomeTeamID &&
game.AwayTeamID == createGameDto.AwayTeamID)
{
return(true);
}
}
return(false);
}
public async Task <Response <GamePreviewDto> > AddGame(CreateGameDto data)
{
try
{
var gamestart = DateTime.Parse(data.GameStartTime);//testable
var model = new GameInfo()
{
AwayTeam = data.AwayTeam,
HomeTeam = data.HomeTeam,
GameStartTime = gamestart,
GameStatus = data.GameStatus,
GameOdd = new GameOdd()
{
AwayOdd = data.AwayOdd, HomeOdd = data.HomeOdd, DrawOdd = data.DrawOdd
}
};
await _bettingRepository.AddGameAsync(model);
await _unitOfWork.CompleteAsync();
return(new Response <GamePreviewDto>
{
Status = true,
Message = $"Game information successfully save",
Result = new GamePreviewDto()//testable
{
TeamDescription = $"{model.HomeTeam} - {model.AwayTeam}",
HomeOdd = model.GameOdd.HomeOdd,
AwayOdd = model.GameOdd.AwayOdd,
DrawOdd = model.GameOdd.DrawOdd,
GameStartTime = model.GameStartTime,
GameStatusDescription = Enum.GetName(typeof(Enums.GameStatus), model.GameStatus),
GameStatus = model.GameStatus,
Id = model.Id,
}
});
}
catch (Exception ex)
{
return(new Response <GamePreviewDto>
{
Status = false,
Message = "Internal error occured , please try again",
Result = default(GamePreviewDto)
});
}
}
public async Task CreatePublicGameTest()
{
var createGameDto = new CreateGameDto {
IsPublic = true
};
var returnedGame = new Game();
_gameRepository.Setup(repo => repo.CreateOrUpdateGame(It.IsAny <Game>())).ReturnsAsync(returnedGame);
returnedGame = await _gameService.CreateGame(createGameDto);
Assert.NotNull(returnedGame);
Assert.IsType <Game>(returnedGame);
Assert.True(returnedGame.IsPublic);
Assert.NotEqual(DateTime.MinValue, returnedGame.CreatedOn);
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> AddorEdit([Bind("Id,OddId,HomeTeam,AwayTeam,HomeOdd,AwayOdd,DrawOdd,GameStartTime")] CreateGameDto model)
{
if (ModelState.IsValid)
{
if (model.Id > 0 && model.OddId > 0)
{
await _bettingService.UpdateGame(model);
}
else
{
await _bettingService.AddGame(model);
}
await ChannelHelper.Trigger(model, "betting", "game_event");
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task Testing_ForEmptyData_On_SaveGame()
{
// Arrange
var mockRepo = new Mock <IBettingRepository>();
var uowRepo = new Mock <IUnitOfWork>();
mockRepo.Setup(repo => repo.AddGameAsync(It.IsAny <GameInfo>()));
uowRepo.Setup(repo => repo.CompleteAsync());
var _sut = new BettingOperationService(mockRepo.Object, uowRepo.Object);
CreateGameDto dto = new CreateGameDto();
dto.GameStartTime = DateTime.Now.ToString();
//Act
var result = await _sut.AddGame(dto);
Assert.IsType <Response <GamePreviewDto> >(result);
Assert.Same(result.Message, "Game information successfully save");
}
public async Task Testing_Invalid_DataTime_Value()
{
// Arrange
var mockRepo = new Mock <IBettingRepository>();
var uowRepo = new Mock <IUnitOfWork>();
mockRepo.Setup(repo => repo.AddGameAsync(It.IsAny <GameInfo>()));
uowRepo.Setup(repo => repo.CompleteAsync());
var _sut = new BettingOperationService(mockRepo.Object, uowRepo.Object);
CreateGameDto dto = new CreateGameDto();
dto.GameStartTime = "1";
//Act
var result = await _sut.AddGame(dto);
Assert.IsType <Response <GamePreviewDto> >(result);
Assert.Same(result.Message, "Internal error occured , please try again");
}
public void AddGame()
{
using (ApplicationContext context = new ApplicationContext())
{
CreateGameDto game = new CreateGameDto()
{
AgeRatingID = 2,
Description = "test description",
GamePlatformID = 3,
Name = "test game",
Price = 10,
ProductionID = 1,
ReleaseDate = DateTime.Now
};
GameRepository gameRepository = new GameRepository(context);
Game gameDb = gameRepository.AddGame(game);
Assert.AreEqual(gameDb.Name, gameDb.Name);
};
}
public async Task Test_Posting_Valid_AddorEdit_RedirectedtoIndex_Page()
{
//arrange
var mode = new CreateGameDto()
{
Id = 0,
OddId = 0,
AwayOdd = 3.4,
HomeOdd = 4.9,
DrawOdd = 5.0,
HomeTeam = "TEst U1",
AwayTeam = "Test U2",
GameStartTime = DateTime.Now.ToString()
};
HttpContent content = new StringContent(JsonConvert.SerializeObject(mode), Encoding.UTF8, "application/json");
//Act
var result = await _http.PostAsync("https://localhost:44374/BettingAdmin/AddorEdit", content);
var stringResult = result.Content.ReadAsStringAsync();
//Assert
Assert.StartsWith("https://localhost:44374/BettingAdmin", result.Headers.Location.OriginalString);
}
public async Task CreateGameWithinWorkspaceTest(bool configurationIsPublic, bool inputGameIsPublic, bool expectedGameIsPublic)
{
var createGameDto = new CreateGameDto
{
IsPublic = inputGameIsPublic,
WorkspaceGuid = Guid.NewGuid(),
ReleaseGuid = Guid.NewGuid(),
IterationGuid = Guid.NewGuid()
};
var returnedGame = new Game();
_gameRepository.Setup(repo => repo.CreateOrUpdateGame(It.IsAny <Game>())).ReturnsAsync(returnedGame);
_workspaceService.Setup(service => service.GetIterationByGuid(It.IsAny <Guid>())).ReturnsAsync(new Iteration());
_workspaceService.Setup(
service =>
service.GetWorkspaceById(It.IsAny <Guid>())).ReturnsAsync(
new Workspace
{
Configuration = new Configuration
{
IsPublic = configurationIsPublic
}
});
returnedGame = await _gameService.CreateGame(createGameDto);
Assert.NotNull(returnedGame);
Assert.IsType <Game>(returnedGame);
Assert.Equal(expectedGameIsPublic, returnedGame.IsPublic);
Assert.NotEqual(DateTime.MinValue, returnedGame.CreatedOn);
Assert.NotNull(returnedGame.Iteration);
Assert.NotNull(returnedGame.Iteration.UserStories);
Assert.NotEqual(Guid.Empty, returnedGame.WorkspaceGuid);
Assert.NotEqual(Guid.Empty, returnedGame.ReleaseGuid);
}
public async Task <Response <string> > UpdateGame(CreateGameDto model)
{
try
{
var gamestart = Convert.ToDateTime(model.GameStartTime);
var game = new GameInfo()
{
AwayTeam = model.AwayTeam,
HomeTeam = model.HomeTeam,
GameStartTime = gamestart,
GameStatus = model.GameStatus,
Id = model.Id,
GameOdd = new GameOdd()
{
AwayOdd = model.AwayOdd, Id = model.OddId, HomeOdd = model.HomeOdd, DrawOdd = model.DrawOdd
}
};
var response = _bettingRepository.UpdateGame(game);
await _unitOfWork.CompleteAsync();
return(new Response <string>
{
Status = true,
Message = $"Operation completed",
Result = default(string)
});
}
catch (Exception ex) {
return(new Response <string>
{
Status = false,
Message = $"{ex.Message}:Internal error occured , please try again",
Result = default(string)
});
}
}
public IActionResult Create(CreateGameDto model)
{
_gameService.Insert(model);
return(RedirectToAction(nameof(Index)));
}
public void Create([FromBody] CreateGameDto model)
{
_gameService.Insert(model);
}
public ActionResult Create([FromBody] CreateGameDto dto)
{
var id = _gameService.Create(dto);
return(Created($"/api/Game/{id}", null));
}
public IHttpActionResult Update([FromBody] CreateGameDto game)
{
gameService.UpdateGame(game);
return(Json(true));
}
/// <summary>
/// Create a new Game
/// </summary>
/// <param name="createGameDto">Game from input</param>
/// <returns>Game</returns>
public async Task <GameDto> CreateGame(CreateGameDto createGameDto, string token)
{
IEnumerable <Season> seasons = await _repo.GetSeasons();
Game newGame = new Game()
{
SeasonID = seasons.ToList().LastOrDefault().SeasonID,
HomeTeamID = createGameDto.HomeTeamID,
AwayTeamID = createGameDto.AwayTeamID,
GameDate = createGameDto.GameDate,
};
await _repo.Games.AddAsync(newGame);
// Create Calendar event for game
Team homeTeam = new Team();
Team awayTeam = new Team();
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var response = await httpClient.GetAsync($"http://20.62.247.144:80/api/Team/{newGame.HomeTeamID}");
var apiResponse = await response.Content.ReadAsStringAsync();
homeTeam = JsonConvert.DeserializeObject <Team>(apiResponse);
}
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var response = await httpClient.GetAsync($"http://20.62.247.144:80/api/Team/{newGame.AwayTeamID}");
var apiResponse = await response.Content.ReadAsStringAsync();
awayTeam = JsonConvert.DeserializeObject <Team>(apiResponse);
}
EventDto eDto = new EventDto()
{
Description = $"Game - {awayTeam.Name} @ {homeTeam.Name}",
Location = $"{homeTeam}",
StartTime = newGame.GameDate,
EndTime = newGame.GameDate.AddMinutes(60)
};
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var response = await httpClient.PostAsJsonAsync($"http://20.185.102.169:80/api/Calendar", eDto);
}
await _repo.CommitSave();
GameDto gameDto = new GameDto
{
GameID = newGame.GameID,
GameDate = newGame.GameDate,
SeasonID = newGame.SeasonID,
AwayTeam = awayTeam,
HomeTeam = homeTeam,
AwayTeamID = newGame.AwayTeamID,
HomeTeamID = newGame.HomeTeamID
};
return(gameDto);
}
