/// <summary>
/// data layer will determine add vs update
/// </summary>
/// <param name="gameInningTeam"></param>
public void Save(GameInningTeamDto gameInningTeam)
{
if (ExistsInDb(gameInningTeam))
{
Update(gameInningTeam);
}
else
{
AddNew(gameInningTeam);
}
}
public void GameNextInningTeamTest()
{
Guid teamOneId = SeedTeam();
Guid teamTwoId = SeedTeamTwo();
var teamOne = Team.GetTeam(teamOneId);
var teamTwo = Team.GetTeam(teamTwoId);
Assert.IsNotNull(teamOne);
Assert.IsNotNull(teamTwo);
Guid gameId = SeedGame();
Guid gtOneId = SeedGameTeam(gameId, teamOne.TeamId, battingSequence: 0);
Guid gtTwoId = SeedGameTeam(gameId, teamTwo.TeamId, battingSequence: 1);
GameInningDto gameInningDto = new GameInningDto()
{
InningNumber = 1,
GameId = gameId,
GameInningId = Guid.NewGuid()
};
GameInning.AddNew(gameInningDto);
Guid?nextTeamId = GameInningTeam.GetNextAtBatTeamId(gameId);
Assert.AreEqual(nextTeamId, teamOne.TeamId);
GameInningTeamDto dto = new GameInningTeamDto()
{
GameInningTeamId = Guid.NewGuid(),
GameTeamId = gtOneId,
GameInningId = gameInningDto.GameInningId,
Outs = 0,
Score = 0
};
GameInningTeam.AddNew(dto);
nextTeamId = GameInningTeam.GetNextAtBatTeamId(gameId);
Assert.AreEqual(nextTeamId, teamTwo.TeamId);
gameInningDto.InningNumber = 2;
gameInningDto.GameInningId = Guid.NewGuid();
GameInning.AddNew(gameInningDto);
nextTeamId = GameInningTeam.GetNextAtBatTeamId(gameId);
Assert.AreEqual(teamOne.TeamId, nextTeamId);
DeleteSeededGame(gameId);
DeleteSeededTeam(teamOneId);
DeleteSeededTeam(teamTwoId);
}
public bool ExistsInDb(GameInningTeamDto gameInningTeam)
{
Connection.BeginTransaction();
var rows = Connection.Query <int>(@"SELECT COUNT(1) as 'Count' FROM GameInningTeam
WHERE GameTeamId = @GameTeamId AND GameInningId = @GameInningId",
new { gameInningTeam.GameTeamId, gameInningTeam.GameInningId });
Connection.Commit();
return(rows.First() > 0);
}
public void SaveEventType(EventType eventType)
{
if (CurrentGameInning != null && CurrentGameInningTeam != null && CurrentGameInningTeamBatter != null)
{
//update the event for the current batter
var currentBatter = GameInningTeamBatter.GetCurrentGameInningTeamBatter(GameId);
if (currentBatter != null)
{
GameInningTeamBatterDto gameInningTeamBatter = new GameInningTeamBatterDto()
{
GameInningTeamBatterId = currentBatter.GameInningTeamBatterId,
GameInningTeamId = currentBatter.GameInningTeamId,
EventType = (int)eventType,
PlayerId = currentBatter.PlayerId,
Sequence = currentBatter.Sequence,
RBIs = currentBatter.RBIs
};
GameInningTeamBatter.Update(gameInningTeamBatter);
//update outs, runs, and baserunners
var halfInningActions = HalfInning.GetHalfInningActions(CurrentGameInningTeam.GameInningTeamId);
Outs = halfInningActions.TotalOuts;
Runs = halfInningActions.TotalRuns;
IsRunnerOnFirst = halfInningActions.IsRunnerOnFirst;
IsRunnerOnSecond = halfInningActions.IsRunnerOnSecond;
IsRunnerOnThird = halfInningActions.IsRunnerOnThird;
AdvanceToNextHalfInning = halfInningActions.AdvanceToNextHalfInning;
//update total runs
var currentInningTeam = GameInningTeam.GetCurrentGameInningTeam(GameId);
if (currentInningTeam != null)
{
GameInningTeamDto gameInningTeam = new GameInningTeamDto()
{
GameTeamId = currentInningTeam.GameTeamId,
GameInningTeamId = currentInningTeam.GameInningTeamId,
GameInningId = currentInningTeam.GameInningId,
IsRunnerOnFirst = IsRunnerOnFirst,
IsRunnerOnSecond = IsRunnerOnSecond,
IsRunnerOnThird = IsRunnerOnThird,
Outs = Outs,
Score = Runs
};
GameInningTeam.Update(gameInningTeam);
}
}
AdvanceToNextInningTeamBatter();
}
}
public void InvalidGameTeamIdTest()
{
GameInningTeamDto dto = new GameInningTeamDto()
{
GameInningId = Guid.NewGuid(),
Score = TEST_SCORE,
Outs = TEST_OUTS,
IsRunnerOnFirst = TEST_IS_RUNNER_ON_FIRST,
IsRunnerOnSecond = TEST_IS_RUNNER_ON_SECOND,
IsRunnerOnThird = TEST_IS_RUNNER_ON_THIRD
};
var result = GameInningTeam.AddNew(dto);
Assert.IsFalse(result.IsSuccess);
}
private void UpdateGameInningTeam(GameInningTeamDto gameInningTeam)
{
string updateQuery = @"UPDATE GameInningTeam
SET GameInningTeamId = @GameInningTeamId,
Score = @Score,
Outs = @Outs,
IsRunnerOnFirst = @IsRunnerOnFirst,
IsRunnerOnSecond = @IsRunnerOnSecond,
IsRunnerOnThird = @IsRunnerOnThird,
DeleteDate = @DeleteDate
WHERE GameTeamId = @GameTeamId AND GameInningId = @GameInningId";
Connection.BeginTransaction();
Connection.Execute(updateQuery, gameInningTeam);
Connection.Commit();
}
public GameInningTeamDto LoadByCompositeKey(Guid gameTeamId, Guid gameInningId)
{
GameInningTeamDto gameInningTeam = null;
Connection.BeginTransaction();
var result = Connection.Query <GameInningTeamDto>(
SELECT_QUERY + " WHERE GameTeamId = @GameTeamId " +
"AND GameInningId = @GameInningId",
new { GameTeamId = gameTeamId.ToString(), GameInningId = gameInningId.ToString() });
gameInningTeam = result.FirstOrDefault();
Connection.Commit();
return(gameInningTeam);
}
public Guid SeedGameInningTeam()
{
Guid gameInningTeamId = Guid.NewGuid();
Guid seedGameInningId = SeedGameInning();
Guid seedGameTeamId = SeedGameTeam();
GameInningTeamDto dto = new GameInningTeamDto()
{
GameInningTeamId = gameInningTeamId,
GameInningId = seedGameInningId,
GameTeamId = seedGameTeamId,
Outs = 0,
Score = 0
};
GameInningTeam.AddNew(dto);
return(gameInningTeamId);
}
private void InsertGameInningTeam(GameInningTeamDto gameInningTeam)
{
string insertQuery = @"INSERT INTO GameInningTeam
(GameInningTeamId, GameInningId, GameTeamId, Score,
Outs, IsRunnerOnFirst, IsRunnerOnSecond, IsRunnerOnThird, DeleteDate)
VALUES(
@GameInningTeamId,
@GameInningId,
@GameTeamId,
@Score,
@Outs,
@IsRunnerOnFirst,
@IsRunnerOnSecond,
@IsRunnerOnThird,
@DeleteDate)";
Connection.BeginTransaction();
Connection.Execute(insertQuery, gameInningTeam);
Connection.Commit();
}
void AdvanceToNextInningTeam(bool isBeginingOfGame = false)
{
ClearBoard();
if (CurrentGameInning != null)
{
Guid?nextAtBatTeamId = GameInningTeam.GetNextAtBatTeamId(GameId);
if (nextAtBatTeamId.HasValue)
{
var atBatGameTeam = GameTeams.FirstOrDefault(y => y.TeamId == nextAtBatTeamId.Value);
bool shouldAdvanceInning = GameTeams.IndexOf(atBatGameTeam) == 0 && isBeginingOfGame == false;
if (shouldAdvanceInning == false)
{
GameInningTeamDto gameInningTeam = new GameInningTeamDto()
{
GameTeamId = atBatGameTeam.GameTeamId,
GameInningId = CurrentGameInning.GameInningId,
IsRunnerOnFirst = false,
IsRunnerOnThird = false,
IsRunnerOnSecond = false,
Outs = 0,
Score = 0
};
GameInningTeam.AddNew(gameInningTeam);
FillCurrentAtBatTeam();
AdvanceToNextInningTeamBatter();
}
else
{
if (IsGameOver() == true)
{
GameComplete();
}
else
{
AdvanceToNextInning();
}
}
}
}
}
public void GameInningTeamBatterCurrentBatterTest()
{
//seed teams
Guid teamOneId = SeedTeam();
Guid teamTwoId = SeedTeamTwo();
//seed players
Guid playerOneId = SeedPlayer();
Guid playerTwoId = SeedPlayerTwo();
Guid playerThreeId = SeedPlayerThree();
Guid playerFourId = SeedPlayerFour();
//seed game
Guid gameId = SeedGame();
Guid gameTeamOneId = SeedGameTeam(gameId, teamOneId, battingSequence: 0);
Guid gameTeamTwoId = SeedGameTeam(gameId, teamTwoId, battingSequence: 1);
GameInningDto gameInningDto = new GameInningDto()
{
InningNumber = 1,
GameId = gameId,
GameInningId = Guid.NewGuid()
};
GameInning.AddNew(gameInningDto);
GameInningTeamDto gameInningTeamDto = new GameInningTeamDto()
{
GameTeamId = gameTeamOneId,
GameInningId = gameInningDto.GameInningId,
GameInningTeamId = Guid.NewGuid()
};
GameInningTeam.AddNew(gameInningTeamDto);
GameInningTeamBatterDto gameInningTeamBatterDto = new GameInningTeamBatterDto()
{
GameInningTeamId = gameInningTeamDto.GameInningTeamId,
PlayerId = playerOneId,
EventType = (int)EventType.Out,
GameInningTeamBatterId = Guid.NewGuid(),
Sequence = 0
};
GameInningTeamBatter.AddNew(gameInningTeamBatterDto);
var currentBatter = GameInningTeamBatter.GetCurrentGameInningTeamBatter(gameId);
Assert.IsNotNull(currentBatter);
Assert.AreEqual(playerOneId, currentBatter.PlayerId);
GameInningTeamBatterDto gameInningTeamBatter2Dto = new GameInningTeamBatterDto()
{
GameInningTeamId = gameInningTeamDto.GameInningTeamId,
PlayerId = playerTwoId,
EventType = (int)EventType.Single,
GameInningTeamBatterId = Guid.NewGuid(),
Sequence = 1
};
GameInningTeamBatter.AddNew(gameInningTeamBatter2Dto);
currentBatter = GameInningTeamBatter.GetCurrentGameInningTeamBatter(gameId);
Assert.IsNotNull(currentBatter);
Assert.AreEqual(currentBatter.PlayerId, playerTwoId);
//cleanup test data
DeleteSeededTeam(teamOneId);
DeleteSeededTeam(teamTwoId);
DeleteSeededGame(gameId);
DeleteSeededPlayer(playerOneId);
DeleteSeededPlayer(playerTwoId);
DeleteSeededPlayer(playerThreeId);
DeleteSeededPlayer(playerFourId);
}
public void NextGameInningTeamBatterTest()
{
//seed teams
Guid teamOneId = SeedTeam();
Guid teamTwoId = SeedTeamTwo();
//seed players
Guid playerOneId = SeedPlayer();
Guid playerTwoId = SeedPlayerTwo();
Guid playerThreeId = SeedPlayerThree();
Guid playerFourId = SeedPlayerFour();
//seed team lineups
List <Guid> teamOneLineup = new List <Guid> {
playerOneId, playerTwoId, playerThreeId, playerFourId
};
SeedTeamPlayerLineup(teamOneId, teamOneLineup);
List <Guid> teamTwoLineup = new List <Guid> {
playerFourId, playerThreeId, playerTwoId, playerOneId
};
SeedTeamPlayerLineup(teamTwoId, teamTwoLineup);
//seed game
Guid gameId = SeedGame();
Guid gameTeamOneId = SeedGameTeam(gameId, teamOneId, battingSequence: 0);
Guid gameTeamTwoId = SeedGameTeam(gameId, teamTwoId, battingSequence: 1);
GameInningDto gameInningDto = new GameInningDto()
{
InningNumber = 1,
GameId = gameId,
GameInningId = Guid.NewGuid()
};
GameInning.AddNew(gameInningDto);
GameInningTeamDto gameInningTeamDto = new GameInningTeamDto()
{
GameTeamId = gameTeamOneId,
GameInningId = gameInningDto.GameInningId,
GameInningTeamId = Guid.NewGuid()
};
GameInningTeam.AddNew(gameInningTeamDto);
//see if the first player in the linup is selected
Guid?nextBatterId = GameInningTeamBatter.GetNextGameBatterPlayerId(gameId, teamOneId);
Assert.AreEqual(nextBatterId, playerOneId);
GameInningTeamBatterDto gameInningTeamBatterDto = new GameInningTeamBatterDto()
{
GameInningTeamId = gameInningTeamDto.GameInningTeamId,
PlayerId = playerOneId,
EventType = (int)EventType.Out,
GameInningTeamBatterId = Guid.NewGuid(),
Sequence = 0
};
GameInningTeamBatter.AddNew(gameInningTeamBatterDto);
//see if the second player in the lineup is selected
nextBatterId = GameInningTeamBatter.GetNextGameBatterPlayerId(gameId, teamOneId);
Assert.AreEqual(nextBatterId, playerTwoId);
GameInningTeamBatterDto gameInningTeamBatter2Dto = new GameInningTeamBatterDto()
{
GameInningTeamId = gameInningTeamDto.GameInningTeamId,
PlayerId = playerTwoId,
EventType = (int)EventType.Single,
GameInningTeamBatterId = Guid.NewGuid(),
Sequence = 1
};
GameInningTeamBatter.AddNew(gameInningTeamBatter2Dto);
//see if the thrid batter is selected
nextBatterId = GameInningTeamBatter.GetNextGameBatterPlayerId(gameId, teamOneId);
Assert.AreEqual(nextBatterId, playerThreeId);
GameInningTeamBatterDto gameInningTeamBatter3Dto = new GameInningTeamBatterDto()
{
GameInningTeamId = gameInningTeamDto.GameInningTeamId,
PlayerId = playerThreeId,
EventType = (int)EventType.Single,
GameInningTeamBatterId = Guid.NewGuid(),
Sequence = 2
};
GameInningTeamBatter.AddNew(gameInningTeamBatter3Dto);
//see if fourth batter is selected
nextBatterId = GameInningTeamBatter.GetNextGameBatterPlayerId(gameId, teamOneId);
Assert.AreEqual(nextBatterId, playerFourId);
GameInningTeamBatterDto gameInningTeamBatter4Dto = new GameInningTeamBatterDto()
{
GameInningTeamId = gameInningTeamDto.GameInningTeamId,
PlayerId = playerFourId,
EventType = (int)EventType.Single,
GameInningTeamBatterId = Guid.NewGuid(),
Sequence = 3
};
GameInningTeamBatter.AddNew(gameInningTeamBatter4Dto);
//see if first batter is up again
nextBatterId = GameInningTeamBatter.GetNextGameBatterPlayerId(gameId, teamOneId);
Assert.AreEqual(nextBatterId, playerOneId);
//cleanup test data
DeleteSeededTeam(teamOneId);
DeleteSeededTeam(teamTwoId);
DeleteSeededTeamPlayerLineup(teamOneId);
DeleteSeededTeamPlayerLineup(teamTwoId);
DeleteSeededGame(gameId);
DeleteSeededPlayer(playerOneId);
DeleteSeededPlayer(playerTwoId);
DeleteSeededPlayer(playerThreeId);
DeleteSeededPlayer(playerFourId);
}
public void Update(GameInningTeamDto gameInningTeam)
{
UpdateGameInningTeam(gameInningTeam);
}
public void AddNew(GameInningTeamDto gameInningTeam)
{
InsertGameInningTeam(gameInningTeam);
}
public void AddUpdateGameInningTeamTest()
{
Guid seedGameInningId = SeedGameInning();
Guid seedGameTeamId = SeedGameTeam();
GameInningTeamDto dto = new GameInningTeamDto()
{
GameInningId = seedGameInningId,
GameTeamId = seedGameTeamId,
Score = TEST_SCORE,
Outs = TEST_OUTS,
IsRunnerOnFirst = TEST_IS_RUNNER_ON_FIRST,
IsRunnerOnSecond = TEST_IS_RUNNER_ON_SECOND,
IsRunnerOnThird = TEST_IS_RUNNER_ON_THIRD
};
var addResult = GameInningTeam.AddNew(dto);
Assert.IsTrue(addResult.IsSuccess);
var item = GameInningTeam.GetGameInningTeam(seedGameTeamId, seedGameInningId);
Assert.IsNotNull(item);
Assert.AreEqual(seedGameInningId, item.GameInningId);
Assert.AreEqual(seedGameTeamId, item.GameTeamId);
Assert.AreEqual(TEST_SCORE, item.Score);
Assert.AreEqual(TEST_OUTS, item.Outs);
Assert.AreEqual(TEST_IS_RUNNER_ON_FIRST, item.IsRunnerOnFirst);
Assert.AreEqual(TEST_IS_RUNNER_ON_SECOND, item.IsRunnerOnSecond);
Assert.AreEqual(TEST_IS_RUNNER_ON_THIRD, item.IsRunnerOnThird);
dto.GameInningTeamId = item.GameInningTeamId;
dto.Score = TEST_SCORE_2;
dto.Outs = TEST_OUTS_2;
dto.IsRunnerOnFirst = TEST_IS_RUNNER_ON_FIRST_2;
dto.IsRunnerOnSecond = TEST_IS_RUNNER_ON_SECOND_2;
dto.IsRunnerOnThird = TEST_IS_RUNNER_ON_THIRD_2;
var updateResult = GameInningTeam.Update(dto);
Assert.IsTrue(updateResult.IsSuccess);
var inningTeams = GameInningTeam.GetInningTeams(seedGameInningId);
Assert.IsTrue(inningTeams.Count >= 1);
var teamInnings = GameInningTeam.GetTeamInnings(seedGameTeamId);
Assert.IsTrue(teamInnings.Count >= 1);
item = inningTeams.FirstOrDefault(x => x.GameTeamId == seedGameTeamId);
Assert.IsNotNull(item);
Assert.AreEqual(seedGameInningId, item.GameInningId);
Assert.AreEqual(seedGameTeamId, item.GameTeamId);
Assert.AreEqual(TEST_SCORE_2, item.Score);
Assert.AreEqual(TEST_OUTS_2, item.Outs);
Assert.AreEqual(TEST_IS_RUNNER_ON_FIRST_2, item.IsRunnerOnFirst);
Assert.AreEqual(TEST_IS_RUNNER_ON_SECOND_2, item.IsRunnerOnSecond);
Assert.AreEqual(TEST_IS_RUNNER_ON_THIRD_2, item.IsRunnerOnThird);
var removeResult = GameInningTeam.Remove(seedGameInningId, seedGameTeamId);
Assert.IsTrue(removeResult.IsSuccess);
item = GameInningTeam.GetGameInningTeam(seedGameTeamId, seedGameInningId);
Assert.IsNull(item);
DeleteSeededGameInning(seedGameInningId);
DeleteSeededGameTeam(seedGameTeamId);
}
