public TrackerBusiness(long userId)
{
_userId = userId;
_usersBusiness = new UsersBusiness();
_historyList = new ListRepository(Utilities.Constans.HistoryListNamePrefix + _userId);
_leaderboardSet = new ScoresRepository(Utilities.Constans.LeaderboardListName);
}
public ResultController(ScoresRepository scoresRepository, MatchesRespository matchesRespository, TeamsRepository teamsRepository, ResultsRepository resultsRepository)
{
_scoresRepository = scoresRepository;
_matchesRespository = matchesRespository;
_teamsRepository = teamsRepository;
_resultsRepository = resultsRepository;
}
public async Task GetScores_Returns_Scores_From_Json()
{
var repo = new ScoresRepository();
var scores = await repo.GetScores();
scores.Should().NotBeEmpty();
}
public async Task GetScoreByPlayer_When_Player_Is_Unknown_Then_Return_Null()
{
var player = "Unknown";
var repo = new ScoresRepository();
var score = await repo.GetScoreByPlayer(player);
score.Should().BeNull();
}
public async Task GetScoreByPlayer_When_Player_Exists_Then_Return_Score()
{
var player = "Jonny";
var repo = new ScoresRepository();
var score = await repo.GetScoreByPlayer(player);
score.Should().NotBeNull();
score.Score.Should().Be(5);
score.Player.Should().Be(player);
}
public async Task UpdateScore_Saves_To_Json()
{
var player = "Jonny";
var score = 9000;
var repo = new ScoresRepository();
await repo.UpdateScore(new ScoreModel { Player = player, Score = score });
var scores = await repo.GetScores();
scores.Should().NotBeEmpty();
scores.Should().Contain(x => x.Player == player && x.Score == score);
}
// get /score => display all scores sorted
protected override Response GetHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
var scoreBoard = new ScoresRepository().ScoreBoard();
return(ResponseManager.OK(JsonSerializer.Serialize(scoreBoard)));
}
private void SelectSide()
{
if (GameModel.SelectSide())
{
tbRedScore.Text = GameModel.RedScore.ToString();
tbBlueScore.Text = GameModel.BlueScore.ToString();
if (GameOver())
{
canvas.Children.Clear();
DrawSquares();
DrawGrid();
var score = new Score();
if (GameModel.RedScore > GameModel.BlueScore)
{
MessageBox.Show($"{tbRedName.Text} WIN!");
score.Name = tbRedName.Text;
score.Value = GameModel.RedScore;
}
else if (GameModel.RedScore < GameModel.BlueScore)
{
MessageBox.Show($"{tbBlueName.Text} WIN!");
score.Name = tbBlueName.Text;
score.Value = GameModel.BlueScore;
}
else
{
MessageBox.Show("It's a DRAW!");
}
score.Date = DateTime.Now;
score.MaxScore = GameModel.RedScore + GameModel.BlueScore;
score.Square = !GameModel.Rombus;
if (score.Name != "Computer" || _multiplayer)
{
ScoresRepository.StoreScore(score);
}
var scoreWindow = new HighScoreWindow();
scoreWindow.Show();
this.Close();
//NewGame();
}
}
}
public JsonResult GetCurrentHandicap()
{
string message = string.Empty;
bool status = false;
try
{
int memberNumber = Convert.ToInt32(Session["MemberNumber"].ToString());
var response = new ScoresRepository().GetCurrentHandicap(memberNumber);
status = response >= 0 ? true : false;
message = response.ToString();
}
catch (Exception ex)
{
status = false; message = ex.Message.ToString();
return(Json(new { status = status, message = message }, JsonRequestBehavior.AllowGet));
}
return(Json(new { status = status, message = message }, JsonRequestBehavior.AllowGet));
}
public void CleanUp()
{
var scoresRepository = new ScoresRepository(ConnectionString);
var gamesRepository = new GamesRepository(ConnectionString);
var playersRepository = new PlayersRepository(ConnectionString);
foreach (Guid scoreId in _scoresList)
{
scoresRepository.DeleteScore(scoreId);
}
foreach (string gameName in _gamesList)
{
gamesRepository.DeleteGame(gameName);
}
foreach (string playerName in _playersList)
{
playersRepository.DeletePlayer(playerName);
}
}
protected override Response GetHandler(Request request)
{
if (request.Authorization.IsNullOrWhiteSpace())
{
return(ResponseManager.BadRequest("Authoriazion Header required"));
}
if (!Authorized(request.Authorization))
{
return(ResponseManager.Unauthorized());
}
string username = Session.GetUsername(ExtractAuthorizationToken(request.Authorization));
if (!new UsersRepository().UserExists(username))
{
return(ResponseManager.NotFound($"Username {username} does not exist"));
}
UserStats stats = new ScoresRepository().Stats(username);
return(ResponseManager.OK(JsonSerializer.Serialize(stats)));
}
public void GetScoresTest()
{
PlayersRepository playersRepository = new PlayersRepository(ConnectionString);
GamesRepository gamesRepository = new GamesRepository(ConnectionString);
ScoresRepository scoresRepository = new ScoresRepository(ConnectionString);
string playerName = GetRandomName(10);
string gameName = GetRandomName(10);
playersRepository.AddPlayer(new Player(playerName));
_playersList.Add(playerName);
gamesRepository.AddGame(new Game(gameName));
_gamesList.Add(gameName);
Guid scoreId1 = Guid.NewGuid(), scoreId2 = Guid.NewGuid();
_scoresList.Add(scoreId1);
_scoresList.Add(scoreId2);
Score score = new Score(scoreId1, playerName, gameName, scores: 5);
scoresRepository.AddScore(score);
score = new Score(scoreId2, playerName, gameName, scores: 15);
scoresRepository.AddScore(score);
List <Score> scores = scoresRepository.GetScores(new Game(gameName), new Player(playerName)).ToList();
if (scores.Find(x => x.Id == scoreId1) == null)
{
Assert.Fail($"Expected score id is {scoreId1}");
}
if (scores.Find(x => x.Id == scoreId2) == null)
{
Assert.Fail($"Expected score id is {scoreId1}");
}
}
public void AddGetScoreTest()
{
PlayersRepository playersRepository = new PlayersRepository(ConnectionString);
GamesRepository gamesRepository = new GamesRepository(ConnectionString);
ScoresRepository scoresRepository = new ScoresRepository(ConnectionString);
string playerName = GetRandomName(10);
string gameName = GetRandomName(10);
playersRepository.AddPlayer(new Player(playerName));
_playersList.Add(playerName);
gamesRepository.AddGame(new Game(gameName));
_gamesList.Add(gameName);
Guid scoreId = Guid.NewGuid();
_scoresList.Add(scoreId);
Score score = new Score(scoreId, playerName, gameName, scores: 5);
scoresRepository.AddScore(score);
Assert.AreEqual(scoreId, scoresRepository.GetScore(scoreId).Id);
}
private void UpdateScores()
{
_scores = ScoresRepository.GetScores();
ScoresListBox.ItemsSource = _scores;
}
public ScoresController(ScoresRepository scoresRepository)
{
_scoresRepository = scoresRepository;
}
private void StartBattle(Player player1, Player player2)
{
var random = new Random();
bool draw = true;
string winner = null;
string loser = null;
// at least 4 rounds, each round describe both cards
var stringBuilder = new StringBuilder(player1.Deck.GetRandomCard().Description().Length * 10);
int attackerIndex = random.Next(0, 2);
int defenderIndex = attackerIndex == 0 ? 1 : 0;
Deck[] decks = { player1.Deck, player2.Deck };
int i = 0;
for (; i < 100; i++)
{
Card attacker = decks[attackerIndex].GetRandomCard();
Card defender = decks[defenderIndex].GetRandomCard();
stringBuilder.AppendLine($"\t---round {i+1}---\t");
stringBuilder.AppendLine($"attacker: {decks[attackerIndex].Owner}, (attacking card)\n{attacker.Description()}\n vs \n\ndefender: " +
$"{decks[defenderIndex].Owner} (defending card)\n{defender.Description()}");
if (attacker.Attack(defender))
{
decks[attackerIndex].Extend(defender);
decks[defenderIndex].Remove(defender);
stringBuilder.AppendLine($"player {decks[attackerIndex].Owner} with card {attacker.Name} wins round {i+1}");
}
else
{
decks[defenderIndex].Extend(attacker);
decks[attackerIndex].Remove(attacker);
stringBuilder.AppendLine($"player {decks[defenderIndex].Owner} with card {defender.Name} wins round {i + 1}");
}
if (decks[attackerIndex].Empty || decks[defenderIndex].Empty)
{
draw = false;
break;
}
stringBuilder.AppendLine("-------------------------------------------------------------\n");
Swap(ref attackerIndex, ref defenderIndex);
}
stringBuilder.AppendLine("\n*******************************************************************\n");
stringBuilder.AppendLine("GAME OVER");
stringBuilder.AppendLine($"Played rounds: {i + 1}");
if (!draw)
{
if (!decks[attackerIndex].Empty)
{
stringBuilder.AppendLine($"{decks[attackerIndex].Owner} won the game with {decks[attackerIndex].Count} cards in the deck");
winner = decks[attackerIndex].Owner;
loser = decks[defenderIndex].Owner;
}
else
{
stringBuilder.AppendLine($"{decks[defenderIndex].Owner} won the game with {decks[defenderIndex].Count} cards in the deck");
winner = decks[defenderIndex].Owner;
loser = decks[attackerIndex].Owner;
}
}
else
{
stringBuilder.AppendLine("DRAW");
}
OnBattleEnded(new BattleEndedEventArgs(stringBuilder.ToString()));
var battlesRepo = new BattlesRepository();
battlesRepo.AddBattle(decks[attackerIndex].Owner, decks[defenderIndex].Owner, winner, stringBuilder.ToString(), i + 1);
var scoreBoard = new ScoresRepository();
scoreBoard.IncreaseBattles(decks[defenderIndex].Owner);
scoreBoard.IncreaseBattles(decks[attackerIndex].Owner);
// increase battles count for both players
if (!draw)
{
scoreBoard.WonBattle(winner);
scoreBoard.LostBattle(loser);
scoreBoard.IncreaseScore(winner, Config.POINTSPERWIN);
scoreBoard.IncreaseScore(loser, Config.POINTSPERLOSE);
}
}
/// <summary>
/// Initialize game controller
/// </summary>
/// <param name="connectionString">database connection string</param>
/// <param name="gameName">game name</param>
public GameController(string connectionString, string gameName)
{
_scoresRepository = new ScoresRepository(connectionString);
_gameName = gameName;
}
public LeaderboardBusiness()
{
_repo = new ScoresRepository(Utilities.Constans.LeaderboardListName);
}
