public async Task NoteWhenGameIsSolvedOnUpdate()
{
var gameId = 1;
// Arrange
var updateGameRequest = new UpdateGameRequest()
{
GameId = gameId,
SudokuCells = TestObjects.GetSolvedSudokuCells(),
License = TestObjects.GetLicense(),
RequestorId = 1
};
// Act
var result = await sut.CheckGame(gameId, updateGameRequest);
var updatedGame = await context.Games
.FirstOrDefaultAsync(game => game.Id == gameId);
var game = context.Games.FirstOrDefault(g => g.Id == gameId);
// Assert
Assert.That(result.Success, Is.True);
Assert.That(result.Message, Is.EqualTo("Game Solved"));
Assert.That(result.Game, Is.TypeOf <Game>());
Assert.That(game.IsSolved(), Is.True);
}
public async Task RejectUpdateIfCellsAreInvalid()
{
// Arrange
var gameId = 1;
var updatedValue = 6;
var updateGameRequest = new UpdateGameRequest()
{
GameId = gameId,
SudokuCells = TestObjects.GetUpdateInvalidSudokuCells(updatedValue),
License = TestObjects.GetLicense(),
RequestorId = 1
};
// Act
var result = await sutUpdateFailure.UpdateGame(gameId, updateGameRequest);
var updatedGame = await context.Games
.FirstOrDefaultAsync(game => game.Id == gameId);
// Assert
Assert.That(result.Success, Is.False);
Assert.That(result.Message, Is.EqualTo("Game not Updated"));
Assert.That(result.Game, Is.TypeOf <Game>());
}
public async Task CheckGames()
{
var gameId = 1;
var updatedValue = 6;
// Arrange
var updateGameRequest = new UpdateGameRequest()
{
GameId = gameId,
SudokuCells = TestObjects.GetUpdateSudokuCells(updatedValue),
License = TestObjects.GetLicense(),
RequestorId = 1
};
// Act
var result = await sut.CheckGame(gameId, updateGameRequest);
var updatedGame = await context.Games
.FirstOrDefaultAsync(game => game.Id == gameId);
var checkValue = updatedGame.SudokuMatrix.SudokuCells
.Where(cell => cell.Id == 58)
.Select(cell => cell.DisplayedValue)
.FirstOrDefault();
// Assert
Assert.That(result.Success, Is.True);
Assert.That(result.Message, Is.EqualTo("Game not Solved"));
Assert.That(result.Game, Is.TypeOf <Game>());
Assert.That(checkValue, Is.EqualTo(updatedValue));
}
public async Task <IActionResult> UpdateGame(
int id,
[FromBody] UpdateGameRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
if (id != request.GameId)
{
return(BadRequest(ControllerMessages.IdIncorrectMessage));
}
var result =
await gamesService.UpdateGame(id, request);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task UpdateGames()
{
var gameId = 1;
var updatedValue = 6;
// Arrange
var updateGameRequest = new UpdateGameRequest()
{
GameId = gameId,
SudokuCells = TestObjects.GetUpdateSudokuCells(updatedValue),
License = TestObjects.GetLicense(),
RequestorId = 1
};
// Act
var result = await sut.UpdateGame(gameId, updateGameRequest);
var checkValue = result.Game.SudokuMatrix.SudokuCells
.OrderBy(cell => cell.Index)
.Where(cell => cell.Index == 2)
.Select(cell => cell.DisplayedValue)
.FirstOrDefault();
// Assert
Assert.That(result.Success, Is.True);
Assert.That(result.Message, Is.EqualTo("Game Updated"));
Assert.That(result.Game, Is.TypeOf <Game>());
Assert.That(checkValue, Is.EqualTo(updatedValue));
}
public HttpResponseMessage UpdateGame([FromUri] int id, [FromBody] UpdateGameRequest request)
{
try
{
var game = GamesRepository.ConsultGameById(id);
if (game == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
game.Title = request.Title;
game.Developer = request.Developer;
game.Image = request.Image;
game.Description = request.Description;
game.ReleaseDate = request.ReleaseDate;
game.Category = request.Category;
GamesRepository.UpdateGame(id, request.Title, request.Developer, request.Image, request.Description, request.ReleaseDate, request.Category);
return(Request.CreateResponse(HttpStatusCode.OK, game));
}
catch (Exception e)
{
Console.WriteLine($"An Exception has been caught: {e.Message}");
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
public async Task <UpdateGameResult> UpdateGame(UpdateGameRequest request)
{
try
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@IdGame", request.IdGame);
parameters.Add("@GameName", request.GameName);
parameters.Add("@Gameplay", request.Gameplay);
parameters.Add("@Conclusion", request.Conclusion);
parameters.Add("@Image", request.Image);
parameters.Add("@Price", request.Price);
parameters.Add("@Graphics", request.Graphics);
parameters.Add("@Levels", request.Levels);
parameters.Add("@Dificulty", request.Dificulty);
parameters.Add("@Testimonials", request.Testimonials);
parameters.Add("@IdCategory", request.IdCategory);
return(await SqlMapper.QueryFirstOrDefaultAsync <UpdateGameResult>(cnn : connect,
sql : "sp_UpdateGames",
param : parameters,
commandType : CommandType.StoredProcedure));
}
catch (Exception ex)
{
throw;
}
}
public BaseResponse Update(UpdateGameRequest request)
{
if (request == null)
{
AddNotification("Update", Message.OBJETO_X0_E_OBRIGATORIO.ToFormat("UpdateRequest"));
}
var game = _gameRepository.GetById(request.Id);
if (game == null)
{
AddNotification("Id", Message.DADOS_NAO_ENCONTRADOS);
return(null);
}
game.Update(request.Name, request.Description, request.Producer, request.Distributor, request.Genre, request.Site);
if (IsInvalid())
{
return(null);
}
_gameRepository.ToEdit(game);
return((BaseResponse)game);
}
public async Task Setup()
{
context = await TestDatabase.GetDatabaseContext();
mockGamesService = new MockGamesService(context);
mockAppsService = new MockAppsService(context);
baseRequest = new BaseRequest();
createGameRequest = new CreateGameRequest();
getMyGameRequest = new GamesRequest()
{
UserId = 1,
License = TestObjects.GetLicense(),
RequestorId = 1,
Paginator = new Paginator()
};
updateGameRequest = TestObjects.GetUpdateGameRequest();
sutSuccess = new GamesController(
mockGamesService.GamesServiceSuccessfulRequest.Object,
mockAppsService.AppsServiceSuccessfulRequest.Object);
sutFailure = new GamesController(
mockGamesService.GamesServiceFailedRequest.Object,
mockAppsService.AppsServiceSuccessfulRequest.Object);
}
public Task <GameDTO> UpdateGameAsync(ManageGameDataModel updateGameDataModel, long gameId, CancellationTokenSource cancellationTokenSource) =>
Task <GameDTO> .Run(async() => {
if (!CrossConnectivity.Current.IsConnected)
{
throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
}
GameDTO updatedGame = null;
UpdateGameRequest updateGameRequest = new UpdateGameRequest()
{
AccessToken = GlobalSettings.Instance.UserProfile.AccesToken,
Data = updateGameDataModel,
Url = string.Format(GlobalSettings.Instance.Endpoints.ScheduleEndpoints.UpdateGame, gameId)
};
try {
UpdateGameResponse updateGameResponse = await _requestProvider.PostAsync <UpdateGameRequest, UpdateGameResponse>(updateGameRequest);
if (updateGameResponse != null)
{
updatedGame = BuildGame(updateGameResponse);
}
else
{
throw new InvalidOperationException(UPDATE_GAME_COMMON_ERROR_MESSAGE);
}
}
catch (HttpRequestExceptionEx exc) {
CreateUpdateGameBadResponse createGameBadResponse = JsonConvert.DeserializeObject <CreateUpdateGameBadResponse>(exc.Message);
string output = string.Format("{0} {1} {2} {3} {4} {5} {6}",
createGameBadResponse.Errors?.FirstOrDefault(),
createGameBadResponse.LocationId?.FirstOrDefault(),
createGameBadResponse.OpponentId?.FirstOrDefault(),
createGameBadResponse.TeamId?.FirstOrDefault(),
createGameBadResponse.Type?.FirstOrDefault(),
createGameBadResponse.DurationInMinutes?.FirstOrDefault(),
createGameBadResponse.MinutesToArriveEarly?.FirstOrDefault());
output = (string.IsNullOrWhiteSpace(output) || string.IsNullOrEmpty(output)) ? UPDATE_GAME_COMMON_ERROR_MESSAGE : output.Trim();
throw new InvalidOperationException(output);
}
catch (Exception exc) {
Crashes.TrackError(exc);
throw;
}
return(updatedGame);
}, cancellationTokenSource.Token);
public async Task <HttpResponseMessage> Update(UpdateGameRequest request)
{
try
{
var response = _gameService.Update(request);
return(await ResponseAsync(response, _gameService));
}
catch (Exception ex)
{
return(await ResponseExceptionAsync(ex));
}
}
public void UpdateGameTest()
{
var raw = @"\updgame\\sesskey\0\done\1\gamedata\hello\lid\1";
var request = new UpdateGameRequest(raw);
request.Parse();
Assert.Equal((int)0, request.SessionKey);
Assert.Equal(true, request.IsDone);
Assert.Equal("hello", request.GameData);
Assert.Null(request.ConnectionID);
raw = @"\updgame\\sesskey\0\connid\1\done\1\gamedata\hello\lid\1";
request = new UpdateGameRequest(raw);
request.Parse();
Assert.Equal((int)0, request.SessionKey);
Assert.Equal(true, request.IsDone);
Assert.Equal("hello", request.GameData);
Assert.Equal((int)1, request.ConnectionID);
}
public async Task CheckGameShouldReturnMessageIfGameNotFound()
{
var gameId = 5;
// Arrange
var updateGameRequest = new UpdateGameRequest()
{
GameId = gameId,
SudokuCells = TestObjects.GetSolvedSudokuCells(),
License = TestObjects.GetLicense(),
RequestorId = 1
};
// Act
var result = await sutFailure.CheckGame(gameId, updateGameRequest);
// Assert
Assert.That(result.Success, Is.False);
Assert.That(result.Message, Is.EqualTo("Game not Found"));
Assert.That(result.Game, Is.TypeOf <Game>());
Assert.That(result.Game.Id, Is.EqualTo(0));
}
public async Task <UpdateGameResult> UpdateGame(UpdateGameRequest request)
{
return(await gameRepository.UpdateGame(request));
}
public async Task <OkObjectResult> Update(UpdateGameRequest request)
{
return(Ok(await gameService.UpdateGame(request)));
}
