public async Task <IActionResult> GetPlayers([FromQuery] PlayerQuery query)
{
var updates = await _playerUpdateStore.GetAllPlayers();
if (query.Forbidden != null)
{
updates = updates.Where(p => p.IsForbidden == query.Forbidden.Value);
}
if (query.Incinerated != null)
{
updates = updates.Where(p => p.Data.GetProperty("deceased").GetBoolean() == query.Incinerated.Value);
}
if (query.Format == ResponseFormat.Csv)
{
await using var sw = new StringWriter();
await using (var w = new CsvWriter(sw, CultureInfo.InvariantCulture))
{
w.Configuration.TypeConverterCache.AddConverter <bool>(new LowercaseBooleanConverter());
await w.WriteRecordsAsync(updates.Select(x => new CsvPlayer(x)));
}
return(Ok(sw.ToString()));
}
return(Ok(new ApiResponse <ApiPlayer>
{
Data = updates.Select(u => new ApiPlayer(u))
}));
}
public static PlayerQuery LoadPlayer(ulong steamId)
{
PlayerQuery query = new PlayerQuery();
MySqlCommand cmd = Connection.CreateCommand();
cmd.CommandText = string.Format(Constants.SELECT, settings.table, steamId);
Connection.Open();
MySqlDataReader dr = cmd.ExecuteReader();
if (dr.Read())
{
query.kills = (int)dr[0];
query.deaths = (int)dr[1];
query.rounds = (int)dr[2];
query.first = (int)dr[3];
query.second = (int)dr[4];
query.third = (int)dr[5];
query.isFirstQuery = false;
}
else
{
query.kills = 0;
query.deaths = 0;
query.rounds = 0;
query.first = 0;
query.second = 0;
query.third = 0;
query.isFirstQuery = true;
}
Connection.Close();
return(query);
}
public override void Execute()
{
if (isExecuting)
{
if (onScore.IsNull())
{
return;
}
Player.PlayerID scorerPID = onScore();
PlayerQuery query = new PlayerQuery(
game.Players,
scorerPID
);
scorer = Player.ExtractScoringPlayer(query);
text = string.Format("POINT: {0}", scorer.ScorerPID);
onScore = null;
isExecuting = false;
return;
}
else
{
OnChangeState();
}
}
public async Task <IActionResult> GetPlayers([FromQuery] PlayerQuery playerQuery)
{
var players = await _playerService.GetAsync(playerQuery);
var returnPlayers = _mapper.Map <PaginatedList <PlayerListDto> >(players);
return(Ok(returnPlayers));
}
public async Task <IActionResult> UpdateName(int id, [FromBody] Player body)
{
await Db.Connection.OpenAsync();
var query = new PlayerQuery(Db);
await query.UpdateName(id, body.Name);
return(new OkObjectResult(body));
}
public static PlayerScorer ExtractScoringPlayer(PlayerQuery pQuery)
{
foreach (Player current in pQuery.Players)
{
if (pQuery.QueryTargetPID == current.PID)
{
return(new PlayerScorer(current));
}
}
return(null);
}
public async Task <IActionResult> GetPlayerInfo(int id)
{
await Db.Connection.OpenAsync();
var query = new PlayerQuery(Db);
var result = await query.GetPlayerInfo(id);
if (result is null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(result));
}
public void PlayerQueryHandler_ReturnsPlayer2()
{
var query = new PlayerQuery(
teamCode: "SF",
firstName: "George",
lastName: "Kittle");
var sut = new PlayerQueryHandler();
var result = sut.Handle(query);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsActive);
Assert.AreEqual(
expected: new DateTime(1993, 10, 9),
actual: result.BirthDate);
}
public void PlayerQueryHandler_ReturnsPlayer()
{
var query = new PlayerQuery(
teamCode: "SF",
firstName: "Nick",
lastName: "Mullens");
var sut = new PlayerQueryHandler();
var result = sut.Handle(query);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsActive);
Assert.AreEqual(
expected: new DateTime(1995, 3, 21),
actual: result.BirthDate);
}
public static void SavePlayer(ulong steamId, PlayerQuery query)
{
MySqlCommand cmd = Connection.CreateCommand();
if (query.isFirstQuery)
{
cmd.CommandText = string.Format(Constants.INSERT, settings.table, steamId, query.kills, query.deaths, query.rounds, query.first, query.second, query.third);
}
else
{
cmd.CommandText = string.Format(Constants.UPDATE, settings.table, query.kills, query.deaths, query.rounds, query.first, query.second, query.third, steamId);
}
Connection.Open();
cmd.ExecuteNonQuery();
Connection.Close();
}
public async Task <IActionResult> GetPlayer(PlayerQuery query)
{
var api = DataAccess.DbConfig.GameAPI + GameUrl.GetPlayer;
var ret = await APIFuncOTAsync(query, "---获取单个玩家---", async (d, p) =>
{
var res = new AjaxResult
{
data = await api
.SetQueryParams(query)
.GetAsync()
.ReceiveJson()
};
return(res);
});
return(Json(ret));
}
public async Task <PaginatedList <Player> > GetAsync(PlayerQuery playerQuery)
{
var query = Context.Players
.Include(p => p.SquadPlayers)
.AsQueryable();
if (playerQuery.SquadId.HasValue)
{
query = query.Where(p => p.SquadPlayers
.Any(sp => sp.SquadId == playerQuery.SquadId &&
(sp.EndDate == null || sp.EndDate >= DateTime.Now)));
}
else if (playerQuery.SeasonId.HasValue && playerQuery.ClubId.HasValue)
{
query = query.Where(p => p.SquadPlayers
.Any(sp => sp.Squad.SeasonId == playerQuery.SeasonId &&
sp.Squad.ClubId == playerQuery.ClubId &&
(sp.EndDate == null || sp.EndDate >= DateTime.Now)));
}
if (playerQuery.Name != null)
{
query = query.Where(p => p.Name.Contains(playerQuery.Name));
}
if (playerQuery.PositionType.HasValue)
{
query = query.Where(p => p.PositionType == playerQuery.PositionType);
}
var columnsMap = new Dictionary <string, Expression <Func <Player, object> > >()
{
["id"] = p => p.Id,
["name"] = p => p.Name,
["positionType"] = p => p.PositionType,
["nationality"] = p => p.Nationality,
["birthdate"] = p => p.Birthdate,
["height"] = p => p.Height,
["weight"] = p => p.Weight
};
query = query.Sort(playerQuery, columnsMap);
return(await PaginatedList <Player> .CreateAsync(query, playerQuery.PageNumber, playerQuery.PageSize));
}
public async Task GetPlayers_WhenCalled_ReturnPlayersFromDb()
{
var playerQuery = new PlayerQuery
{
PageNumber = 1,
PageSize = 10,
SortBy = "name",
IsSortAscending = true
};
var expectedPlayers = new PaginatedList <Player>
{
Pagination = new Pagination
{
PageNumber = 1,
PageSize = 10
},
Items = new List <Player>()
{
new Player {
Id = 1
},
new Player {
Id = 2
},
new Player {
Id = 3
},
}
};
_playerService.Setup(p => p.GetAsync(playerQuery)).ReturnsAsync(expectedPlayers);
var result = await _playersController.GetPlayers(playerQuery);
var okObjectResult = result as OkObjectResult;
var okObjectResultValue = okObjectResult.Value as PaginatedList <PlayerListDto>;
Assert.That(result, Is.TypeOf <OkObjectResult>());
Assert.That(okObjectResultValue, Is.Not.Null);
Assert.That(okObjectResultValue.Pagination.PageNumber, Is.EqualTo(1));
Assert.That(okObjectResultValue.Pagination.PageSize, Is.EqualTo(10));
Assert.That(okObjectResultValue.Items.Count(), Is.EqualTo(3));
}
public void ItGets_PlayerFromMediator()
{
var mediator = new Mediator();
mediator.Register <IHandleQueries <IQuery <List <Player> >, List <Player> > >(delegate
{
return(new PlayerListQueryHandler());
});
mediator.Register <IHandleQueries <IQuery <Player>, Player> >(delegate
{
return(new PlayerQueryHandler());
});
mediator.Register <IHandleQueries <IQuery <List <Player> >, List <Player> >, PlayerListQueryHandler>();
mediator.Register <IHandleQueries <IQuery <Player>, Player>, PlayerQueryHandler>();
var playerQuery = new PlayerQuery("Hank");
var players = mediator.Request(playerQuery);
Assert.NotNull(players);
Assert.Equal(players.Name, PlayerDbContext.GetPlayer("Hank").Name);
}
public async Task GetAsync_WhenCalled_GetPlayersFromDb()
{
var playerQuery = new PlayerQuery
{
PageNumber = 1,
PageSize = 10,
SortBy = "name",
IsSortAscending = true
};
var expectedPlayers = new PaginatedList <Player>
{
Pagination = new Pagination
{
PageNumber = 1,
PageSize = 10
},
Items = new List <Player>()
{
new Player {
Id = 1
},
new Player {
Id = 2
},
new Player {
Id = 3
},
}
};
_playerRepository.Setup(p => p.GetAsync(playerQuery)).ReturnsAsync(expectedPlayers);
var result = await _playerService.GetAsync(playerQuery);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(expectedPlayers));
}
public async Task <PaginatedList <Player> > GetAsync(PlayerQuery playerQuery)
{
return(await _playerRepository.GetAsync(playerQuery));
}
