public async Task RequestPlayerUpdate(PlayerModel playerModel)
{
PlayerRequest playerRequest = new PlayerRequest {
PlayerId = playerModel.PlayerId
};
await _playerDataService.RequestUpdate(playerRequest);
}
public TeamResponse AddPlayerToTeam(int teamId, PlayerRequest player)
{
var entity = _repository.GetById(teamId);
//TODO:Wrap this in a Response object to send errors;
if (entity == null)
{
return(null);
}
//if player id present get player from db and add it other wise create a new player
if (player.PlayerId > 0)
{
var existingPlayer = _playerRepository.GetById(player.PlayerId);
if (existingPlayer != null)
{
entity.Players.Add(existingPlayer);
}
}
else
{
entity.Players.Add(Mapper.Map <Player>(player));
}
_repository.Edit(entity);
_unitOfWork.Commit();
return(Mapper.Map <TeamResponse>(entity));
}
public async Task <IActionResult> Play([FromQuery] PlayerRequest playerRequest)
{
var filePath = await _fileService.GetFilePath(playerRequest.Id);
if (filePath == null)
{
return(NotFound());
}
var memory = new MemoryStream();
var buffer = new byte[BufferSize];
await using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
var totalSize = fileStream.Length;
while (totalSize > 0)
{
var count = totalSize > BufferSize ? BufferSize : (int)totalSize;
var sizeBufferRead = fileStream.Read(buffer, 0, count);
await memory.WriteAsync(buffer.AsMemory(0, sizeBufferRead));
totalSize -= sizeBufferRead;
}
return(File(memory, new MediaTypeHeaderValue(playerRequest.Mime).MediaType, true));
}
public async Task AddPlayer()
{
try
{
if (!SessionBegun)
{
throw new System.ArgumentNullException(nameof(GameSessionId), "Session not initialized");
}
var player = new PlayerRequest
{
SessionId = GameSessionId,
Name = EditPlayer.Name
};
var result = await HttpService.Post("/player")
.AddBody(string.Empty, JsonConvert.SerializeObject(player))
.ExecuteAsync <Player>();
if (result != null)
{
Players.Add(result);
}
AddingPlayer = !AddingPlayer;
}
catch (System.Exception e)
{
await MessageService.ShowError(e.Message);
}
}
public Response UpdatePlayerProfile(PlayerRequest request)
{
var validationResult = validator.Validate(request);
if (!validationResult.IsValid)
{
return(Response.CreateResponse(validationResult.Messages));
}
if (request.PlayerId.IsEmpty())
{
return(Response.CreateResponse(new ArgumentNullException("PlayerId cannot be null")));
}
var player = memberQuery.GetPlayer(request.PlayerId.Value);
if (player == null || player.SquadId != request.SquadId)
{
return(Response.CreateResponse(new EntityNotFoundException("The specified player does not exist")));
}
player = MapPlayer(request);
try {
playerRepository.UpdatePlayer(player);
return(Response.CreateSuccessResponse());
} catch (Exception ex) {
return(Response.CreateResponse(ex));
}
}
private void Register(string key, Project project)
{
if (!AndroidPermissionsManager.CheckBluetoothPermissions())
{
return;
}
var req = new RegisterRequest
{
Key = key,
Project = project
};
var registerRequests = new List <RegisterRequest> {
req
};
var request = PlayerRequest.Create();
request.Register = registerRequests;
if (hapticPlayer == null)
{
return;
}
hapticPlayer.Call("register", request.ToJsonObject().ToString());
}
public void ChangePlayerPosition(Vector3 direction, float magnitude, float timeDelta, bool isRunning)
{
PlayerRequest request = new PlayerRequest();
request.sequenceNumber = sequenceNumber++;
if (snapshot != null)
{
request.acknowledgmentNumber = snapshot.sequenceNumber;
}
request.magnitude = magnitude;
request.timeDelta = timeDelta;
request.direction = direction;
request.isRunning = isRunning;
requests.Enqueue(request);
string json = JsonUtility.ToJson(request).ToString();
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(json);
udpClient.Send(bytes, bytes.Length);
// Debug.Log("sent: " + request);
}
public void AddPlayer(PlayerRequest playerRequest)
{
Player newPlayer = context.Player.Where(p => p.FirstName == playerRequest.FirstName).
Where(p => p.LastName == playerRequest.LastName).
Where(p => p.DateOfBirth == playerRequest.DateOfBirth).SingleOrDefault();
if (playerRequest == null)
{
throw new Exc("This player does not exist.");
}
Team newTeam = context.Team.Where(t => t.IdTeam == playerRequest.IdTeam).SingleOrDefault();
var today = DateTime.Today;
var age = today - playerRequest.DateOfBirth;
//sprawdzic czy nalezy do druzyny, jesli nie to dodac do kontekstu i zapisac zmiany
context.SaveChanges();
//if (age.ToString > newTeam.MaxAge)
//{
// throw new ExcAge("Player to old");
//}
}
public PlayerResponse Response(PlayerRequest @request)
{
PlayerRequestModel req = _mapper.Map <PlayerRequestModel>(request);
var player = _playerService.GetRandom(req);
return(_mapper.Map <PlayerResponse>(player));
}
public IActionResult Edit(PlayerViewModel player)
{
if (!ModelState.IsValid)
{
return(View("Edit", player));
}
var request = new PlayerRequest {
DateOfBirth = player.DateOfBirth,
DominantFoot = player.DominantFoot.FirstOrDefault(),
Email = player.Email,
FirstName = player.FirstName,
LastName = player.LastName,
Nationality = player.Nationality,
SquadNumber = player.SquadNumber,
SquadId = player.SquadId,
PlayerId = player.PlayerId.Value
};
var response = playerService.UpdatePlayerProfile(request);
if (!response.RequestIsFulfilled)
{
foreach (var error in response.Errors)
{
ModelState.AddModelError("", error);
}
return(View("Edit", player));
}
return(RedirectToAction("Index", "Squads", new { SquadId = player.SquadId }));
}
public Response RegisterPlayer(PlayerRequest request)
{
var validationResult = validator.Validate(request);
if (!validationResult.IsValid)
{
return(Response.CreateResponse(validationResult.Messages));
}
var squad = squadQuery.GetSquad(request.SquadId);
if (squad == null)
{
return(Response.CreateResponse(new EntityNotFoundException("The specified squad does not exist")));
}
Player player = MapPlayer(request);
try {
playerRepository.AddPlayer(player);
return(Response.CreateSuccessResponse());
} catch (Exception ex) {
return(Response.CreateResponse(ex));
}
}
/************************************************************************************/
public bool CastJestersCap()
{
if (!IsAbilityReady(m_uiJestersCapAbilityID))
{
return(false);
}
while (m_JestersCapQueue.Count > 0)
{
PlayerRequest ThisRequest = m_JestersCapQueue.Dequeue();
if (!m_FriendDictionary.ContainsKey(ThisRequest.m_strName))
{
Program.Log("Jester's Cap rejected on {0}; not a friend.", ThisRequest.m_strName);
continue;
}
if (ThisRequest.Age > TimeSpan.FromMinutes(m_fJestersCapRequestTimeoutMinutes))
{
Program.Log("Jester's Cap rejected on {0}; request timed out.", ThisRequest.m_strName);
continue;
}
if (!CastAbility(m_uiJestersCapAbilityID, ThisRequest.m_strName, true))
{
continue;
}
SpamSafeRaidSay(m_strJestersCapCallout, ThisRequest.m_strName);
return(true);
}
return(false);
}
public async Task <ActionResult> UpdatePlayer(int id, [FromBody] PlayerRequest playerRequest)
{
if (id < 1 || playerRequest == null)
{
return(BadRequest());
}
var playerToUpdate = await this.playerService.FindAsync(id);
if (playerToUpdate == null)
{
return(NotFound());
}
var player = this.mapper.Map(playerRequest, playerToUpdate);
if (!validator.Validate(player).IsValid)
{
return(BadRequest());
}
await this.playerService.UpdateAsync(player);
logger.LogInformation($"UpdatePlayer {player.Id}");
return(Ok());
}
public IActionResult DreamTeam()
{
List <PlayerPerformance.Player> playerPerformanceLst = new List <PlayerPerformance.Player>();
PlayerRequest req = new PlayerRequest()
{
MatchId = Convert.ToInt32(HttpContext.Session.GetString("MatchId")),
TourId = Convert.ToInt32(HttpContext.Session.GetString("tourId")),
TeamNameOne = HttpContext.Session.GetString("TeamNameOne"),
TeamNameTwo = HttpContext.Session.GetString("TeamNameTwo"),
FullTeamName = HttpContext.Session.GetString("FullTeamName"),
};
List <int> playerIdLst = _playerService.GetPlayerId(req);
req.PlayerIdLst = playerIdLst;
string webroot = _env.WebRootPath;
var file = System.IO.Path.Combine(webroot, "Player.json");
//deserialize JSON from file
string Json = System.IO.File.ReadAllText(file);
req.PlayerJson = Json;
playerPerformanceLst = _playerService.GetPlayerPerformanceLst(req);
List <PlayPercentage> playerByPercent = _playerService.GetPlayerByPercentage(playerPerformanceLst);
MatchDetails matchDetails = new MatchDetails();
matchDetails.PlayerList = playerPerformanceLst;
matchDetails.PlayPercentageLst = playerByPercent;
return(View(matchDetails));
}
public async Task RequestUpdate()
{
var gameId = "ABCDEF";
var playerId = "0";
var singlePlayerRequest = new PlayerRequest
{
GameId = gameId,
PlayerId = playerId
};
var allPlayerRequest = new PlayerRequest {
GameId = gameId
};
var playerDTO = new PlayerDTO
{
GameId = gameId,
PlayerId = playerId,
Squads = new List <SquadDTO>()
};
var playerDTOs = new List <PlayerDTO> {
playerDTO
};
_mockClient.Setup(c => c.RequestPlayer(gameId, playerId)).Returns(Task.FromResult(playerDTO));
_mockClient.Setup(c => c.RequestPlayerList(gameId)).Returns(Task.FromResult(playerDTOs));
var playerDataService = Container.Resolve <IDataService <PlayerModel, PlayerRequest> >();
await playerDataService.RequestUpdate(singlePlayerRequest);
await playerDataService.RequestUpdate(allPlayerRequest);
Assert.True(true); // pass if no exceptions thrown
}
/// <summary>
/// Sends message with game action request.
/// </summary>
/// <param name="msg">Request message.</param>
public void SendGameMessage(PlayerRequest msg)
{
if (CurrentState == ClientState.GAME_IN_PLAY && !_ResumeMode)
{
_Socket.SendMessage(msg);
}
}
public async Task <PlayerEntity> GetPlayerAsync(string name)
{
var request = new PlayerRequest {
PlayerName = name
};
return(await base.RequestAsync <PlayerEntity>(request));
}
public void Awake()
{
CloseIpConfig();
playerRequest = new PlayerRequest();
LoadIP();
ActivateLoginScreen();
OnDeselect();
}
//add in subscription to unity for player updates
//send in updates on update method
public override async Task Players(PlayerRequest request, IServerStreamWriter <PlayerUpdate> responseStream, ServerCallContext context)
{
PlayerSubscriberStream.Add(responseStream);
await Task.Run(() => {
Thread.Sleep(3600000 * 100);
}).ConfigureAwait(false);
}
public async Task RequestPlayersUpdate()
{
var gameId = _gameState.Game.GameId;
PlayerRequest playerRequest = new PlayerRequest {
GameId = gameId
};
await _playerDataService.RequestUpdate(playerRequest);
}
public PlayerEntity GetPlayer(string name)
{
var request = new PlayerRequest {
PlayerName = name
};
return(base.Request <PlayerEntity>(request));
}
public List <string> GetPlayerName(PlayerRequest player)
{
string json = "{\"returnType\":\"response\",\"query\":\"query CreateTeamQuery( $site: String! $tourId: Int! $teamId: Int = -1 $matchId: Int!) { site(slug: $site) { name teamPreviewArtwork { src } teamCriteria { totalCredits maxPlayerPerSquad totalPlayerCount } roles { id artwork { src } color name pointMultiplier shortName } playerTypes { id name minPerTeam maxPerTeam shortName artwork { src } } tour(id: $tourId) { match(id: $matchId) { id guru squads { flag { src } id jerseyColor name shortName } startTime status players(teamId: $teamId) { artwork { src } squad { id name jerseyColor shortName } credits id name points type { id maxPerTeam minPerTeam name shortName } isSelected role { id artwork { src } color name pointMultiplier shortName } } } } } me { isGuestUser }}\",\"variables\":{\"tourId\":" + player.TourId + ",\"matchId\":" + player.MatchId + ",\"teamId\":null,\"site\":\"cricket\"}}";
Dictionary <string, PlayerDetails> dict = _playerRepo.ConstructJsonForPlayer(json);
List <string> playerListId = GetPlayerNamefromDict(dict);
return(playerListId);
}
public IActionResult AddPlayer([Required] string tournamentId, [FromBody, Required] PlayerRequest request)
{
var response = tournamentService.AddPlayer(
requestFieldExtractor.ExtractTomUserSessionCredentials(),
tournamentId,
request);
return(Ok(response));
}
public List <ContestDetailsResp> GetContestDetails(PlayerRequest req)
{
List <ContestDetailsResp> contestLst = new List <ContestDetailsResp>();
string json = "{\"returnType\": \"response\",\"query\": \"query ContestHomeData($site: String!, $tourId: Int!, $matchId: Int!) { me { isGuestUser showOnboarding } site(slug: $site) { canCreateContest name showWalletIcon } contestSections(site: $site, matchId: $matchId, tourId: $tourId) { id name description artwork { src } totalContestCount displayContests { contestCategory contestSize currentSize entryFee { amount symbol } hasJoined id inviteCode isInfiniteEntry isGuaranteed isMultipleEntry isRecommended numberOfWinners prizeAmount { amount symbol } showInvite isFreeEntry match { id status } tour { id name } site } }}\",\"variables\": {\"tourId\": 0,\"matchId\": " + req.MatchId + ",\"site\": \"cricket\",\"category\": \"PAID\"}}";
Dictionary <string, Contest> dict = _contestRepo.ConstructContestJson(json);
contestLst = MapContestDetailsFromDict(dict);
return(contestLst);
}
public ActionResult <Response <EmptyResponse> > UpdatePlayer([FromBody, Required] PlayerRequest request)
{
var response = playerService.UpdatePlayer
(
requestFieldExtractor.ExtractTomUserSessionCredentials(),
request
);
return(Ok(response));
}
public static ElementResponse Execute(Guid id, PlayerRequest request)
{
DbHelper.CheckAddPlayer(id, request.Number);
var playerId = DbHelper.AddPlayer(id, request.MiddleName, request.Name, request.Surname, request.Number);
return(new ElementResponse {
Txt = playerId
});
}
public async Task <ActionResult <PlayerResponse> > PostPlayer([FromBody] PlayerRequest player)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var playerResponce = await _service.AddPlayer(player);
return(CreatedAtAction("GetPlayer", new { id = playerResponce.Id }, playerResponce));
}
public IHttpActionResult Post([FromBody] PlayerRequest player)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var response = _service.Create(player);
return(CreatedAtRoute("DefaultApi", response.PlayerId, response));
}
public GroupResponse CreateGroup(PlayerRequest request)
{
const string baseUrl = "https://api.ws.sonos.com/control/api/v1/";
try
{
using (var client = new HttpClient())
{
client.ConfigureClient(baseUrl);
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", Token);
using (var message = new HttpRequestMessage(HttpMethod.Post,
$"households/{request.HouseholdId}/groups/createGroup"))
{
var content = new SonosGroupRequest
{
PlayerIds = request.PlayerIds
};
var json = JsonConvert.SerializeObject(content);
message.Content = new StringContent(json, Encoding.UTF8, "application/json");
message.Headers.Clear();
message.Headers.Accept.Clear();
message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")
{
CharSet = "utf-8"
});
var response = client.SendAsync(message).Result;
if (response.StatusCode == HttpStatusCode.OK)
{
var result = response.Content.ReadAsStringAsync().Result;
var groupResponse = JsonConvert.DeserializeObject <GroupResponse>(result);
return(groupResponse);
}
return(null);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public PlayerResponse Create(PlayerRequest request)
{
if (request == null)
{
throw new ArgumentNullException("entity");
}
var response = _repository.Add(Mapper.Map <Player>(request));
_unitOfWork.Commit();
return(Mapper.Map <PlayerResponse>(response));
}
