public RosterMemberCreatedEventHandler(IMapper mapper, RosterMemberRepository rosterMemberRepo, PlayerRepository playerRepo, ILoggerFactory loggerFactory)
{
_mapper = mapper;
_rosterMemberRepo = rosterMemberRepo;
_playerRepo = playerRepo;
_logger = loggerFactory.CreateLogger("RosterMember");
}
private async Task Init(IServerInfoRepository infoRepository, Guid?serverId)
{
Servers = (await infoRepository.GetActiveServerInfoAsync()).OrderBy(x => x.Name).ToList();
if (string.IsNullOrEmpty(_playerName))
{
using (var userRepo = new PlayerRepository())
{
var player = await userRepo.GetPlayerAsync(_playerGuid);
_playerName = player?.Name;
}
}
//SelectedServers = new ObservableCollection<ServerInfoDto>();
if (serverId.HasValue)
{
SelectedServers.AddRange(Servers.Where(s => s.Id == serverId.Value));
}
Reasons = await GetReasons();
BanTimes = await GetBanTimes();
RaisePropertyChanged(nameof(Reasons));
RaisePropertyChanged(nameof(BanTimes));
}
public List <Player <string> > GetPlayersForTeamId(string teamId)
{
return(PlayerRepository
.Get()
.Where(p => p.TeamId == teamId)
.ToList());
}
public TeamBusiness(IUnitOfWork _unitOfWork)
{
unitOfWork = _unitOfWork;
playerRepository = new PlayerRepository(unitOfWork);
teamRepository = new TeamRepository(unitOfWork);
playerSkillRepository = new PlayerSkillRepository(unitOfWork);
}
public Controller()
{
this.gunRepository = new GunRepository();
this.playerRepository = new PlayerRepository();
this.gangNeighbourhood = new GangNeighbourhood();
}
public void Initialize()
{
_playerRepository = new PlayerRepository();
_holeRepository = new HoleRepository();
_playerHoleStatisticsRepository = new PlayerHoleStatisticsRepository();
_transaction = new TransactionScope(TransactionScopeOption.RequiresNew);
}
private void PlayerCreateButton_Click(object sender, EventArgs e)
{
PlayerRepository repos = new PlayerRepository();
if (NewPlayerTextBox.Text != "")
{
if (freestats == 0)
{
if (!repos.IsExist(NewPlayerTextBox.Text))
{
Player pl = new Player(NewPlayerTextBox.Text, str, agi, stm);
repos.Add(pl);
SwitchScene(Scene.Menu, pl);
}
else
{
MessageBox.Show("This name is already taken");
}
}
else
{
MessageBox.Show("Use all stats");
}
}
else
{
MessageBox.Show("Input name");
}
}
public ActionResult Player(int id)
{
ViewBag.Message = "Player page.";
IModelRepository<Player> repository = new PlayerRepository();
return View(repository.Get(id));
}
public void GetByPeopleIDTest()
{
var rep = new PlayerRepository(new CSBCDbContext());
var player = rep.GetByPeopleId(2);
Assert.IsTrue(player != null);
Assert.IsTrue(player.PlayerID > 0);
}
public IEnumerable<ProPlayer> GetTeamPlayers([Control("fflTeam")]int? fantasyOwnerId)
{
if (!(fantasyOwnerId.HasValue)) return new ProPlayer[] {};
var repo = new PlayerRepository();
return repo.Get(x => x.FantasyTeamId == fantasyOwnerId);
}
public void Initialize()
{
_gameRepository = new GameRepository();
_playerRepository = new PlayerRepository();
_playerGameStatisticsRepository = new PlayerGameStatisticsRepository();
_transaction = new TransactionScope(TransactionScopeOption.RequiresNew);
}
public void UpdatePlayer()
{
var players = new List <Player>
{
new Player {
FirstName = "First 1", LastName = "Last 1"
},
new Player {
FirstName = "First 2", LastName = "Last 2"
},
new Player {
FirstName = "First 3", LastName = "Last 3"
}
};
var playerRepository = new PlayerRepository(_fixture.Context.PlayersContain(players));
var player = playerRepository.GetBy(1);
player.FirstName = "William";
player.LastName = "Chronowski";
playerRepository.Update(player);
var result = playerRepository.GetBy(1);
Assert.Equal(1, result.Id);
Assert.Equal("William", player.FirstName);
Assert.Equal("Chronowski", player.LastName);
}
public void ShouldGetPlayers()
{
var dictionary = new Dictionary <string, object>
{
{ "UserId", 1 },
{ "Name", "Arsenal" },
{ "GoalsPerGame", 3.2f },
{ "PointsPerGame", 4.2f },
{ "MatchesPlayed", 1 }
};
var helper = new Mock <IDbHelper>();
helper.Setup(x => x.ExecuteReader("up_GetTopPlayers", null)).Returns(
DataReaderTestHelper.Reader(dictionary));
var repository = new PlayerRepository(helper.Object);
//when
var resultsModels = repository.GetTopPlayers();
//then
Assert.That(resultsModels.Count, Is.EqualTo(1));
Assert.That(resultsModels.First().PointsPerGame, Is.EqualTo(4.2f));
Assert.That(resultsModels.First().GoalsPerGame, Is.EqualTo(3.2f));
Assert.That(resultsModels.First().PlayerName, Is.EqualTo("Arsenal"));
Assert.That(resultsModels.First().MatchesPlayed, Is.EqualTo(1));
Assert.That(resultsModels.First().PlayerId, Is.EqualTo(1));
}
public HttpResponseMessage ListAll()
{
try
{
List <PlayerModelGet> list = new List <PlayerModelGet>();
PlayerRepository rep = new PlayerRepository();
foreach (Player p in rep.ListAll())
{
PlayerModelGet model = new PlayerModelGet();
model.Player_ID = p.Player_ID;
model.Name = p.Name;
model.Team_ID = p.Team_ID;
model.Team_Name = p.Team.Name;
list.Add(model);
}
return(Request.CreateResponse(HttpStatusCode.OK, list));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
public UnitOfWork()
{
_context = new Model();
Players = new PlayerRepository(_context);
Rounds = new RoundsRepository(_context);
Games = new GameRepository(_context);
}
public async Task UpdateGroups_PortraitDefinitionExists_Success()
{
var settingsRepo = new PersonalSettingsRepository(MongoClient);
var portraitRepo = new PortraitRepository(MongoClient);
var playeRepo = new PlayerRepository(MongoClient);
var portraitCommandHandler = new PortraitCommandHandler(settingsRepo, playeRepo, portraitRepo);
int[] portraitIds = { 1, 2, 3, 4 };
string[] portraitGroups = { "brozne", "silver" };
var defineCommand = CreatePortraitsDefinitionCommand(portraitIds.ToList(), portraitGroups.ToList());
await portraitCommandHandler.AddPortraitDefinition(defineCommand);
int[] portraitsToUpdate = { 1, 4 };
string[] portraitGroupToUpdate = { "gold" };
var updateCommand = CreatePortraitsDefinitionCommand(portraitsToUpdate.ToList(), portraitGroupToUpdate.ToList());
await portraitCommandHandler.UpdatePortraitDefinition(updateCommand);
var portraits = await portraitCommandHandler.GetPortraitDefinitions();
var definitionsWithGold = portraits.FindAll(x => x.Groups.Count() == 1);
var definitionsWithBronzeSilver = portraits.FindAll(x => x.Groups.Count() == 2);
Assert.AreEqual(4, portraits.Count());
Assert.AreEqual(2, definitionsWithGold.Count());
Assert.AreEqual(2, definitionsWithBronzeSilver.Count());
}
public async Task PlayersFromAn1v1Match_GameModeHandler_Test()
{
var playerRepository = new PlayerRepository(MongoClient);
var handler = new PlayerGameModeStatPerGatewayHandler(playerRepository);
var ev = TestDtoHelper.CreateFakeEvent();
ev.match.season = 1;
ev.match.players[0].battleTag = "peter#123";
ev.match.players[0].won = true;
ev.match.players[1].battleTag = "wolf#456";
ev.match.players[1].won = false;
await handler.Update(ev);
var winnerStatGateWay = await playerRepository.LoadGameModeStatPerGateway("peter#123", GateWay.Europe, 1);
var loser = await playerRepository.LoadGameModeStatPerGateway("wolf#456", GateWay.Europe, 1);
Assert.AreEqual(1, winnerStatGateWay.First(x => x.GameMode == GameMode.GM_1v1).Wins);
Assert.AreEqual(1, loser.First(x => x.GameMode == GameMode.GM_1v1).Losses);
Assert.AreEqual(0, loser.First(x => x.GameMode == GameMode.GM_1v1).Wins);
}
public static void Main(string[] args)
{
IReader reader = new Reader();
IWriter writer = new Writer();
IPlayerRepository playerRepository = new PlayerRepository();
ICardRepository cardRepository = new CardRepository();
IPlayerFactory playerFactory = new PlayerFactory();
ICardFactory cardFactory = new CardFactory();
IBattleField battleField = new BattleField();
IManagerController managerController = new ManagerController(
playerRepository,
cardRepository,
playerFactory,
cardFactory,
battleField);
ICommandInterpreter commandInterpreter = new CommandInterpreter(managerController);
IEngine engine = new Engine(commandInterpreter, reader, writer);
engine.Run();
}
/// <summary>
/// Creates a new player record based on a player name.
/// </summary>
/// <param name="name">Name of the player to create</param>
/// <returns>Player record.</returns>
public static Player Create(string name)
{
// Initialize the new player.
var createDate = DateTime.Now;
var player = new Player
{
Name = name,
JoinDate = createDate,
LastLoggedInDate = createDate
};
PlayerRepository.Create(player);
var createdPlayer = PlayerRepository.GetByName(player.Name);
// Initialize the new player's Net Worth
var netWorth = new NetWorth
{
PlayerId = createdPlayer.Id,
Value = 0,
LastUpdatedDate = createDate
};
NetWorthRepository.Create(netWorth);
var createdNetWorth = NetWorthRepository.GetByPlayerId(createdPlayer.Id);
// Reputations will be initialized the first time they change.
// Build the player.
createdPlayer.NetWorth = createdNetWorth;
createdPlayer.Bounties = new List <Bounty>();
return(createdPlayer);
}
static void Main(string[] args)
{
var logger = new LoggerConfiguration()
.WriteTo.File("logs.txt", outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
.CreateLogger();
try
{
logger.Information("Bot started");
var playerRepository = new PlayerRepository(new DbContextOptionsBuilder <FootballBotDbContext>().UseSqlite("Filename=./BotDb.db").Options);
var teamSet = new TeamsController(playerRepository);
var messageController = new MessageController(playerRepository, teamSet, logger);
var scheduler = new Scheduler(messageController, teamSet, playerRepository, logger);
messageController.Run();
scheduler.Run();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception ex)
{
logger.Fatal(ex, "FATAL ERROR");
try { new MessageController(null, null, logger).SendTextMessageToBotOwnerAsync($"Ошибка приложения: {ex.Message}").Wait(); }
catch { }
throw;
}
}
void Start()
{
StatusesManager.init();
var enemySpawnpoints = new Dictionary <EnemyType, Transform[]>();
var mushroomSpawnPoints = GameObject.Find(StringConstants.SceneObjects.MashroomSpawnPoints);
var turtleSpawnPoints = GameObject.Find(StringConstants.SceneObjects.TurtleSpawnPoints);
if (mushroomSpawnPoints != null)
{
enemySpawnpoints.Add(EnemyType.Mashroom, getAllChilds(mushroomSpawnPoints.transform));
}
if (turtleSpawnPoints != null)
{
enemySpawnpoints.Add(EnemyType.Turtle, getAllChilds(turtleSpawnPoints.transform));
}
if (turtleSpawnPoints != null || mushroomSpawnPoints != null)
{
EnemyRepository.InstantiateEnemies(enemySpawnpoints);
}
playerController = PlayerRepository.InstantiatePlayer();
cameraController = Camera.main.GetComponent <CameraController>();
cameraController.player = playerController.gameObject;
}
public void AddGameOwned()
{
var player = new Player {
Id = 1, FirstName = "First 1", LastName = "Last 1"
};
var players = new List <Player> {
player
};
var game = new Game {
Id = 1, Name = "Game 1"
};
var games = new List <Game> {
game
};
var context = _fixture.Context
.PlayersContain(players)
.GamesContain(games);
var playerRepository = new PlayerRepository(context);
playerRepository.AddGameOwned(player.Id, game.Id);
var result = playerRepository.GetAllGamesBy(player.Id);
Assert.Equal(1, result.First()
.Id);
Assert.Equal("Game 1", result.First()
.Name);
}
public static void Main()
{
IReader reader = new ConsoleReader();
IWriter writer = new FileWriter();
IPlayerRepository playerRepository = new PlayerRepository();
IPlayerFactory playerFactory = new PlayerFactory();
ICardFactory cardFactory = new CardFactory();
ICardRepository cardRepository = new CardRepository();
IBattleField battleField = new BattleField();
IManagerController managerController = new ManagerController(
playerRepository,
playerFactory,
cardFactory,
cardRepository,
battleField);
IEngine engine = new Engine(
reader,
writer,
managerController);
engine.Run();
}
public async Task UpdateOverview_HandlerUpdate_FootmenFrenzy()
{
var matchFinishedEvent = TestDtoHelper.CreateFakeFootmenFrenzyEvent();
var playerRepository = new PlayerRepository(MongoClient);
var handler = new PlayerGameModeStatPerGatewayHandler(playerRepository);
await handler.Update(matchFinishedEvent);
var winners = matchFinishedEvent.match.players.Where(x => x.won);
Assert.AreEqual(3, winners.Count());
foreach (var player in winners)
{
var winnerStatGateWay = await playerRepository.LoadGameModeStatPerGateway(player.battleTag, GateWay.Europe, matchFinishedEvent.match.season);
Assert.AreEqual(1, winnerStatGateWay.First(x => x.GameMode == GameMode.GM_FOOTMEN_FRENZY).Wins);
Assert.AreEqual(0, winnerStatGateWay.First(x => x.GameMode == GameMode.GM_FOOTMEN_FRENZY).Losses);
}
var losers = matchFinishedEvent.match.players.Where(x => !x.won);
Assert.AreEqual(9, losers.Count());
foreach (var player in losers)
{
var winnerStatGateWay = await playerRepository.LoadGameModeStatPerGateway(player.battleTag, GateWay.Europe, matchFinishedEvent.match.season);
Assert.AreEqual(0, winnerStatGateWay.First(x => x.GameMode == GameMode.GM_FOOTMEN_FRENZY).Wins);
Assert.AreEqual(1, winnerStatGateWay.First(x => x.GameMode == GameMode.GM_FOOTMEN_FRENZY).Losses);
}
}
public async Task AssignOnePortrait_PlayerAlreadyHas_TooltipUpdated()
{
var personalSettingsRepository = new PersonalSettingsRepository(MongoClient);
var playerRepo = new PlayerRepository(MongoClient);
var portraitRepo = new PortraitRepository(MongoClient);
var portraitCommandHandler = new PortraitCommandHandler(personalSettingsRepository, playerRepo, portraitRepo);
int[] validPortraits = { 3 };
await portraitCommandHandler.AddPortraitDefinition(CreatePortraitsDefinitionCommand(validPortraits.ToList(), new List <string>()));
var playerTag = "cepheid#1467";
var personalSettings = new PersonalSetting(playerTag);
personalSettings.SpecialPictures.Append(new SpecialPicture(3, "initialTestDescription"));
await personalSettingsRepository.Save(personalSettings);
var portraitsCommand = new PortraitsCommand();
portraitsCommand.Portraits.Add(3);
portraitsCommand.BnetTags.Add(playerTag);
portraitsCommand.Tooltip = "testTooltip";
await portraitCommandHandler.UpsertSpecialPortraits(portraitsCommand);
var settings = await personalSettingsRepository.Load(playerTag);
Assert.AreEqual(1, settings.SpecialPictures.Count());
Assert.AreEqual(3, settings.SpecialPictures.First().PictureId);
Assert.AreEqual("testTooltip", settings.SpecialPictures.First().Description);
}
public HttpResponseMessage Add(PlayerModelAdd model)
{
if (ModelState.IsValid)
{
try
{
Player p = new Player();
p.Name = model.Name;
p.Team_ID = model.Team_ID;
PlayerRepository rep = new PlayerRepository();
rep.Insert(p);
return(Request.CreateResponse(HttpStatusCode.OK, ""));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public async Task LoadAndSave_NotDuplicatingWhenGoingUp()
{
var rankRepository = new RankRepository(MongoClient);
var playerRepository = new PlayerRepository(MongoClient);
var ranks1 = new List <Rank> {
new Rank(new List <string> {
"peter#123"
}, 1, 12, 1456, null, GateWay.Europe, GameMode.GM_1v1, 0)
};
var ranks2 = new List <Rank> {
new Rank(new List <string> {
"peter#123"
}, 1, 8, 1456, null, GateWay.Europe, GameMode.GM_1v1, 0)
};
await rankRepository.InsertRanks(ranks1);
await rankRepository.InsertRanks(ranks2);
var player = PlayerOverview.Create(new List <PlayerId> {
PlayerId.Create("peter#123")
}, GateWay.Europe, GameMode.GM_1v1, 0, null);
await playerRepository.UpsertPlayerOverview(player);
var playerLoaded = await rankRepository.LoadPlayersOfLeague(1, 0, GateWay.Europe, GameMode.GM_1v1);
Assert.AreEqual(1, playerLoaded.Count);
Assert.AreEqual(8, playerLoaded[0].RankNumber);
}
public HttpResponseMessage Edit(PlayerModelEdit model)
{
if (ModelState.IsValid)
{
try
{
Player p = new Player();
p.Player_ID = model.Player_ID;
p.Name = model.Name;
p.Team_ID = model.Team_ID;
PlayerRepository rep = new PlayerRepository();
rep.Update(p);
return(Request.CreateResponse(HttpStatusCode.OK, ""));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
else
{
List <string> erros = new List <string>();
foreach (var m in ModelState)
{
foreach (var e in m.Value.Errors)
{
erros.Add(e.ErrorMessage);
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, erros.Distinct()));
}
}
public async Task LoadPlayersOfLeague_RaceBasedMMR()
{
var rankRepository = new RankRepository(MongoClient);
var playerRepository = new PlayerRepository(MongoClient);
var ranks = new List <Rank>
{
new Rank(new List <string> {
"peter#123"
}, 1, 12, 1456, Race.HU, GateWay.Europe, GameMode.GM_1v1, 2),
new Rank(new List <string> {
"peter#123"
}, 1, 8, 1456, Race.NE, GateWay.Europe, GameMode.GM_1v1, 2)
};
await rankRepository.InsertRanks(ranks);
var player1 = PlayerOverview.Create(new List <PlayerId> {
PlayerId.Create("peter#123")
}, GateWay.Europe, GameMode.GM_1v1, 2, Race.HU);
await playerRepository.UpsertPlayerOverview(player1);
var player2 = PlayerOverview.Create(new List <PlayerId> {
PlayerId.Create("peter#123")
}, GateWay.Europe, GameMode.GM_1v1, 2, Race.NE);
await playerRepository.UpsertPlayerOverview(player2);
var playerLoaded = await rankRepository.LoadPlayersOfLeague(1, 2, GateWay.Europe, GameMode.GM_1v1);
Assert.AreEqual(2, playerLoaded.Count);
}
public ActionResult Create(PlayerModel model)
{
try
{
// TODO: Add insert logic here
PlayerRepository repository = new PlayerRepository();
model.UserId = User.Identity.GetUserId();
var player = repository.Add(model);
if (Request.Files[0].ContentLength > 0)
{
HttpPostedFileBase postedFile = Request.Files[0];
string filename = player.Id + ".jpg";
var blobHelper = new StorageHelper.BlobHelper();
var container = blobHelper.GetContainer("playerspictures");
blobHelper.UploadToContainer(postedFile, container, filename);
return RedirectToAction("Index");
}
return RedirectToAction("Index");
}
catch(Exception ex)
{
Trace.TraceError(ex.Message);
throw;
}
}
public async Task LoadAndSave()
{
var rankRepository = new RankRepository(MongoClient);
var playerRepository = new PlayerRepository(MongoClient);
var ranks = new List <Rank> {
new Rank(new List <string> {
"peter#123"
}, 1, 12, 1456, null, GateWay.America,
GameMode.GM_1v1, 0)
};
await rankRepository.InsertRanks(ranks);
var player = PlayerOverview.Create(new List <PlayerId> {
PlayerId.Create("peter#123")
}, GateWay.America, GameMode.GM_1v1, 0, null);
player.RecordWin(true, 1234);
await playerRepository.UpsertPlayerOverview(player);
await playerRepository.UpsertPlayerOverview(player);
await playerRepository.UpsertPlayerOverview(player);
var playerLoaded = await rankRepository.LoadPlayersOfLeague(1, 0, GateWay.America, GameMode.GM_1v1);
Assert.AreEqual(1, playerLoaded.Count);
Assert.AreEqual("0_peter#123@10_GM_1v1", playerLoaded[0].Players.First().Id);
Assert.AreEqual(1, playerLoaded[0].Players.First().Wins);
Assert.AreEqual(12, playerLoaded[0].RankNumber);
Assert.AreEqual(1456, playerLoaded[0].RankingPoints);
Assert.AreEqual(0, playerLoaded[0].Players.First().Losses);
}
public async Task PlayersFromAn2v2ATMatch_GameModeHandler_Test()
{
var playerRepository = new PlayerRepository(MongoClient);
var handler = new PlayerGameModeStatPerGatewayHandler(playerRepository);
var ev = TestDtoHelper.CreateFake2v2Event();
ev.match.season = 1;
ev.match.players[0].battleTag = "peter#123";
ev.match.players[0].won = true;
ev.match.players[1].battleTag = "wolf#456";
ev.match.players[1].won = true;
ev.match.players[2].battleTag = "TEAM2#123";
ev.match.players[2].won = false;
ev.match.players[3].battleTag = "TEAM2#456";
ev.match.players[3].won = false;
await handler.Update(ev);
var winners = await playerRepository.LoadGameModeStatPerGateway("1_peter#123@10_wolf#456@10_GM_2v2_AT", GateWay.America, 1);
var losers = await playerRepository.LoadGameModeStatPerGateway("1_TEAM2#123@10_TEAM2#456@10_GM_2v2_AT", GateWay.America, 1);
Assert.AreEqual(1, winners.First(x => x.GameMode == GameMode.GM_2v2_AT).Wins);
Assert.AreEqual(0, winners.First(x => x.GameMode == GameMode.GM_2v2_AT).Losses);
Assert.AreEqual(1, losers.First(x => x.GameMode == GameMode.GM_2v2_AT).Losses);
Assert.AreEqual(0, losers.First(x => x.GameMode == GameMode.GM_2v2_AT).Wins);
}
public void RemovePlayer()
{
var player1 = new Player {
FirstName = "First 1", LastName = "Last 1"
};
var player2 = new Player {
FirstName = "First 2", LastName = "Last 2"
};
var player3 = new Player {
FirstName = "First 3", LastName = "Last 3"
};
var players = new List <Player> {
player1, player2, player3
};
var playerRepository = new PlayerRepository(_fixture.Context.PlayersContain(players));
playerRepository.Remove(player2);
var result = playerRepository.GetAll()
.ToList();
Assert.Equal(2, result.Count());
Assert.Equal(new List <Player> {
player1, player3
}, result.OrderBy(r => r.Id));
}
public void RemoveGameOwned()
{
var player = new Player {
Id = 1, FirstName = "First 1", LastName = "Last 1"
};
var players = new List <Player> {
player
};
var game = new Game {
Id = 1, Name = "Game 1"
};
var games = new List <Game> {
game
};
var playerGame = new PlayerGame {
GameId = game.Id, PlayerId = player.Id
};
var playerGames = new List <PlayerGame> {
playerGame
};
var context = _fixture.Context
.PlayersContain(players)
.GamesContain(games)
.PlayerGamesContain(playerGames);
var playerRepository = new PlayerRepository(context);
playerRepository.RemoveGameOwned(player.Id, game.Id);
var result = playerRepository.GetAllGamesBy(player.Id);
Assert.False(result.Any());
}
public void ShouldGetPlayerList()
{
//given
var dictionary = new Dictionary <string, object>
{
{ "UserId", 1 },
{ "Name", "Arsenal" },
{ "Surname", "Rajyaguru" },
{ "Username", "hemdagem" },
{ "UserType", 2 }
};
var helper = new Mock <IDbHelper>();
helper.Setup(x => x.ExecuteReader("up_GetUsers", null)).Returns(
DataReaderTestHelper.Reader(dictionary));
//when
var repository = new PlayerRepository(helper.Object);
var resultsModels = repository.GetAllPlayers();
//then
Assert.That(resultsModels, Is.Not.Null);
Assert.That(resultsModels.Count, Is.EqualTo(1));
Assert.That(resultsModels.First().PlayerName, Is.EqualTo("Arsenal"));
Assert.That(resultsModels.First().PlayerId, Is.EqualTo(1));
}
public async Task PlayerMultipleWinRecords()
{
var playerRepository = new PlayerRepository(MongoClient);
var handler = new PlayerOverallStatsHandler(playerRepository);
var handler2 = new PlayerGameModeStatPerGatewayHandler(playerRepository);
var handler3 = new PlayerRaceStatPerGatewayHandler(playerRepository);
var ev = TestDtoHelper.CreateFakeEvent();
ev.match.gameMode = GameMode.GM_1v1;
ev.match.gateway = GateWay.Europe;
ev.match.season = 1;
ev.match.players[0].battleTag = "peter#123";
ev.match.players[0].battleTag = "peter#123";
ev.match.players[0].race = Race.HU;
ev.match.players[1].race = Race.OC;
for (int i = 0; i < 100; i++)
{
await handler.Update(ev);
await handler2.Update(ev);
await handler3.Update(ev);
}
var playerLoaded = await playerRepository.LoadRaceStatPerGateway("peter#123", Race.HU, GateWay.Europe, 1);
var playerLoadedStats = await playerRepository.LoadGameModeStatPerGateway("peter#123", GateWay.Europe, 1);
Assert.AreEqual(100, playerLoadedStats.Single().Wins);
Assert.AreEqual(100, playerLoaded.Wins);
}
public void SavePlayerChanges(ProPlayer updated)
{
Debug.WriteLine(updated);
var repo = new PlayerRepository();
repo.Update(updated);
GetAverageScores();
}
public PlayerRepository GetPlayerRepository()
{
if (playerRepository == null)
{
playerRepository = new PlayerRepository();
}
return playerRepository;
}
public void GetNextDraftIdTest()
{
var context = new CSBC.Core.Data.CSBCDbContext();
var player = new Player { DivisionID = 25, PeopleID = 2, CompanyID = 1, CoachID = 2, SeasonID = 2 };
var rep = new PlayerRepository(context);
var count = rep.GetNextDraftId(1, 2, 25);
Assert.IsTrue(!String.IsNullOrEmpty(count));
}
public void Initialize()
{
_gameRepository = new GameRepository();
_holeRepository = new HoleRepository();
_playerRepository = new PlayerRepository();
_shotTypeRepository = new ShotTypeRepository();
_playerRivalryStatisticsRepository = new PlayerRivalryStatisticsRepository();
_transaction = new TransactionScope(TransactionScopeOption.RequiresNew);
}
public PlayerRepository playerRepository = null; // kostyl'
#endregion Fields
#region Constructors
public MainForm()
{
InitializeComponent();
playerRepository = new PlayerRepository();
SwitchScene(Scene.Autorization);
//SwitchScene(Scene.RecordTable);
}
public static Player LastSeason(int peopleId)
{
using (var db = new CSBCDbContext())
{
var rep = new PlayerRepository(db);
var player = rep.GetLastSeasonPlayed(peopleId);
return player;
}
}
public List<SeasonPlayer> GetDivisionPlayers(int divisionId)
{
using (var db = new CSBCDbContext())
{
var rep = new PlayerRepository(db);
var players = rep.GetDivisionPlayers(divisionId);
return players.ToList();
}
}
public void GetAverageScores()
{
var repo = new PlayerRepository();
var takenPlayers = repo.Get(p => p.FantasyTeamId != null);
var agg = takenPlayers.GroupBy(p => p.FantasyOwner).Select(p => new GraphData(p.Key, p.Sum(d => d.ProjectedPoints) / 16M)).OrderByDescending(p => p.AvgPts).ToList();
avgChart.DataSource = agg;
avgChart.DataBind();
}
protected void Page_Load(object sender, EventArgs e)
{
using (var db = new CSBCDbContext())
{
var repo = new PlayerRepository(db);
Players = repo.GetDivisionPlayers(757).ToList();
ObjectDataSource1.DataBind();
}
}
public void LoadPlayerHistory(int personId)
{
using (var db = new CSBCDbContext())
{
var rep = new PlayerRepository(db);
PlayerHistoryList = rep.GetPlayerHistory(personId);
gridPlayerHistory.DataSource = PlayerHistoryList;
gridPlayerHistory.DataBind();
}
}
public PlayerPresenter(IPlayerControl ctrl)
{
view = ctrl;
usersRepository = new PlayerRepository();
usersList = new List<PlayerDTO>();
usersList = usersRepository.GetAll().ToList();
showingCount = usersList.Count;
view.DrawUsersTable(usersList);
}
protected override void Given()
{
base.Given();
var cpuPlayer = new Player {UserName = null};
cpuPlayer = Load(cpuPlayer);
cpuId = cpuPlayer.Id;
FlushSessionAndEvict(cpuPlayer);
var settingsProvider = new StubCabalSettingsProvider(new CabalSection {Server = new ServerElement {CpuPlayerId = cpuId}});
playerRepository = new PlayerRepository(NHibernateSession, settingsProvider);
}
public void DeletePlayerTest()
{
var context = new CSBCDbContext();
var player = new Player { DivisionID = 25, PeopleID = 2, CompanyID = 1, CoachID = 2, SeasonID = 2 };
var rep = new PlayerRepository(context);
var id = rep.Insert(player);
Assert.IsTrue(context.Players.Any<Player>(p => p.CompanyID == 1 && p.SeasonID == 2 && p.DivisionID == 25));
rep.Delete(player);
Assert.IsTrue(context.Players.Find(id) == null);
}
public void Can_remove_existing_player()
{
var player = new Player() { Id = 1 };
IPlayerRepository repository = new PlayerRepository();
repository.Delete(player);
using (ISession session = _sessionFactory.OpenSession())
{
var fromDb = session.Get<Player>(player.Id);
Assert.IsNull(fromDb);
}
}
public void GetPlayerDivisionTest()
{
context = new CSBCDbContext();
var repPeople = new PlayerRepository(context);
var player = context.Players.FirstOrDefault();
//var person = repPeople.GetById(2);
var repSeason = new SeasonRepository(context);
var season = repSeason.GetCurrentSeason(1);
var repDivision = new DivisionRepository(context);
var dt = repDivision.GetPlayerDivision(1, season.SeasonID, player.PeopleID);
Assert.IsTrue(dt != 0);
}
public void Can_update_existing_player()
{
IPlayerRepository repository = new PlayerRepository();
var player = new Player() { Id = 1, Name = "Hanley Ramirez", YahooId = 1 };
repository.Save(player);
// use session to try to load the product
using (ISession session = _sessionFactory.OpenSession())
{
var fromDb = session.Get<Player>(player.Id);
Assert.AreEqual(player.Name, fromDb.Name);
}
}
protected override void Given()
{
base.Given();
var settingsProvider = new StubCabalSettingsProvider(50);
GameRepository = new GameRepository(NHibernateSession);
PlayerRepository = new PlayerRepository(NHibernateSession, settingsProvider);
ServiceUnderTest = new GameService(GameRepository, PlayerRepository);
ExpectedGame = Build.Game();
ExpectedGame.Owner.UserName = OwnerName;
ExpectedGame.Start(ExpectedGame.Owner);
GameRepository.Save(ExpectedGame);
FlushSessionAndEvict(ExpectedGame);
}
static void Main(string[] args)
{
var fileToLoad = args[0];
var rdr = new System.IO.StreamReader(fileToLoad);
var repo = new PlayerRepository();
var import = new ImportHandler(repo);
while(!rdr.EndOfStream)
{
var thisLine = rdr.ReadLine();
import.AddPlayer(thisLine, args[1]);
}
rdr.Close();
rdr.Dispose();
}
public void Can_add_new_player()
{
var player = new Player { Name = "Joe Nathan" };
IPlayerRepository repository = new PlayerRepository();
repository.Save(player);
// use session to try to load the product
using (ISession session = _sessionFactory.OpenSession())
{
var fromDb = session.Get<Player>(player.Id);
// Test that the product was successfully inserted
Assert.IsNotNull(fromDb);
Assert.AreNotSame(player, fromDb);
Assert.AreEqual(player.Name, fromDb.Name);
}
}
private void LoginButton_Click(object sender, EventArgs e)
{
PlayerRepository repos = new PlayerRepository();
List<PlayerDTO> plList = new List<PlayerDTO>();
plList = repos.GetAll().ToList();
if (PlaerNameTextBox.Text != "")
{
if (repos.IsExist(PlaerNameTextBox.Text))
{
SwitchScene(Scene.Menu, repos.Get(PlaerNameTextBox.Text));
}
else
{
MessageBox.Show("Wrong Name");
}
}
else
{
MessageBox.Show("Input name");
}
}
public void GetPlayersTest()
{
var testinit = new CSBCDbInitializer();
var context = new CSBC.Core.Data.CSBCDbContext();
var house = new Player();
var rep = new PlayerRepository(context);
var players = rep.GetSeasonPlayers(testinit.CurrentSeason.SeasonID);
int no = players.Count<SeasonPlayer>();
Assert.IsTrue(players.Count<SeasonPlayer>() > 1);
var player = players.First();
Assert.IsTrue(player.PeopleID > 0);
}
public void GetPlayerByPersonAndSeasonIdTest()
{
var rep = new PlayerRepository(new CSBCDbContext());
var season = rep.GetPlayerByPersonAndSeasonId(2, 2);
Assert.IsTrue(season != null);
}
public void GetLastSeasonPlayedTest()
{
var rep = new PlayerRepository(new CSBCDbContext());
var season = rep.GetLastSeasonPlayed(2);
Assert.IsTrue(season.SeasonID > 0);
}
public void InsertPlayerTest()
{
var context = new CSBC.Core.Data.CSBCDbContext();
var player = new Player { DivisionID = 25, PeopleID = 2, CompanyID = 1, CoachID = 2, SeasonID = 2 };
var rep = new PlayerRepository(context);
var id = rep.Insert(player);
Assert.IsTrue(context.Players.Count<Player>(p=>p.CompanyID==1 && p.SeasonID ==2 && p.DivisionID == 25) > 0);
Assert.IsTrue(context.Players.Find( id.PlayerID ) != null);
}
