public static void GetChallenge(int rating)
{
PlayerDataManager.ArenaMatchData = null;
IsRequestingChallenge = true;
rating = Mathf.Min(999, rating);
ChallengeRequest challengeRequest = new ChallengeRequest();
challengeRequest.rating = rating;
ChallengeResponse response2 = new ChallengeResponse();
Manager <BackendManager> .instance.SendRequest(challengeRequest, response2, delegate(ChallengeResponse response)
{
if (response.error == BackendError.Ok)
{
UnityEngine.Debug.Log("Challenge found successfully! " + response.payload.name + " " + response.payload.actualRating);
PlayerDataManager.ArenaMatchData = new ArenaMatchData();
PlayerDataManager.ArenaMatchData.arenaPayload = response.payload;
}
else
{
if (response.error == BackendError.InvalidToken)
{
UnityEngine.Debug.LogError("Players token is not valid");
}
else if (response.error == BackendError.NoChallengeFound)
{
UnityEngine.Debug.LogError("No actual challenge was found.");
}
UnityEngine.Debug.LogError("Challenge was not found!");
}
IsRequestingChallenge = false;
});
}
public virtual async Task <ChessGame> ChallengePlayerAsync(string token, string username)
{
var message = new HttpRequestMessage(HttpMethod.Post, GamesControllerUri);
message.Headers.Add("Authorization", $"Bearer {token}");
var challengeDto = new ChallengeRequest()
{
Opponent = username
};
message.Content = new StringContent(JsonConvert.SerializeObject(challengeDto), Encoding.UTF8, "application/json");
var resultMessage = await _client.SendAsync(message);
if (!resultMessage.IsSuccessStatusCode)
{
return(null);
}
var resultString = await resultMessage.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <ChessGame>(resultString);
return(result);
}
private static async Task <IList <ContestResponse> > CreateAndSaveChallengesAsync(string json, ILogger logger)
{
logger.LogInformation($"C# CreateChallenges function processing async: {json}");
ChallengeRequest request = ContestFactory.CreateChallengeRequest(json);
BlobApi blobApi = await BlobApi.Instance;
CloudSkillApi cscApi = await CloudSkillApi.Instance;
Tuple <IList <ContestResponse>, string> tuple = await blobApi.GetAllContestTupleAsync(request.BaseInputs.Mstpid);
if (tuple?.Item1 != null)
{
request.LearningPaths = RemoveDuplicateLearningPaths(request, tuple.Item1);
await blobApi.DeleteBlobAsync(tuple.Item2);
}
List <ContestResponse> response = await cscApi.CreateChallengesAsyc(request);
logger.LogInformation($"Created the Challenges. Saving response to blob");
if (tuple?.Item1 != null)
{
foreach (ContestResponse contest in tuple.Item1)
{
response.Add(contest);
}
}
await WriteToBlobAsync(request.BaseInputs, response);
logger.LogInformation($"C# CreateChallenges function processed");
return(response);
}
public Challenge UpdateChallenge(Challenge existingChallenge, ChallengeRequest request)
{
VerifyNotFinished(existingChallenge.StartTime, existingChallenge.Duration);
VerifyDuration(existingChallenge.StartTime, request.Duration);
//these properties can change for any challenge that is not finished
existingChallenge.Name = request.Name;
existingChallenge.Duration = request.Duration;
existingChallenge.Description = request.Description;
existingChallenge.Units = request.Units;
//these properties can only change before a challenge begins
if (existingChallenge.StartTime > DateTime.Now)
{
if (request.StartTime < DateTime.Now)
{
throw new ApiError(400, "Start date cannot be in the past.");
}
existingChallenge.StartTime = request.StartTime;
existingChallenge.Category = ParseCategory(request.Category);
existingChallenge.DaysPerWeek = request.DaysPerWeek;
}
return(existingChallenge);
}
private void RequestChallenge()
{
ChallengeRequest c = new ChallengeRequest("challenge", ApiKey);
string json = JsonConvert.SerializeObject(c, Formatting.None, Settings);
Console.WriteLine("requesting challenge: " + json);
Ws.Send(json);
}
public static IRequest Serilize(byte[] rawRequest)
{
IRequest request;
if (rawRequest.Length < 1)
{
return(null);
}
switch ((QRPacketType)rawRequest[0])
{
case QRPacketType.AvaliableCheck:
request = new AvaliableRequest(rawRequest);
break;
//verify challenge to check game server is real or fake;
//after verify we can add game server to server list
case QRPacketType.Challenge:
request = new ChallengeRequest(rawRequest);
break;
case QRPacketType.HeartBeat:
request = new HeartBeatRequest(rawRequest);
break;
case QRPacketType.KeepAlive:
request = new KeepAliveRequest(rawRequest);
break;
case QRPacketType.EchoResponse:
request = new QRRequestBase(rawRequest);
break;
case QRPacketType.ClientMessageACK:
request = new QRRequestBase(rawRequest);
break;
default:
LogWriter.UnknownDataRecieved(rawRequest);
request = null;
break;
}
if (request == null)
{
return(null);
}
if (!(bool)request.Parse())
{
LogWriter.ToLog(LogEventLevel.Error, ErrorMessage.GetErrorMessage(QRErrorCode.Parse));
return(null);
}
return(request);
}
public async Task <FaceToNamesChallenge> CreateFaceToNamesChallengeAsync(ChallengeRequest request)
{
var allProfiles = await GetProfiles().ConfigureAwait(false);
var(options, selectedProfile) = RandomizeSelection(allProfiles, request.NumberOfOptions);
var userId = await _userRepository.GetOrCreateUser(request.UserName).ConfigureAwait(false);
return(await CreateFaceToNamesChallenge(options, selectedProfile, userId).ConfigureAwait(false));
}
public async Task CreateChallengesAsycTestAsync()
{
Configuration config = await TestHelper.GetConfigurationAsync();
CloudSkillApi cscApi = new CloudSkillApi(config);
string json = ContestFactory.CreateChallengeRequestJson();
ChallengeRequest request = ContestFactory.CreateChallengeRequest(json);
List <ContestResponse> contestReponseList = await cscApi.CreateChallengesAsyc(request);
Assert.IsTrue(contestReponseList.Count > 0);
}
/// <inheritdoc />
public ChallengeRequestResult Add(string participantPlayerName, ChallengeRequest challengeRequest)
{
var initiatedBy = _dbContext.Users.SingleOrDefault(x => x.UserName == participantPlayerName);
if (initiatedBy == null)
{
return(new ChallengeRequestResult
{
RequestResult = ChallengeRequestResultStatuses.InitiatedByUserNull,
NewlyCreatedGame = null
});
}
var opponent = _dbContext.Users.SingleOrDefault(x => x.UserName == challengeRequest.Opponent);
if (opponent == null)
{
return(new ChallengeRequestResult
{
RequestResult = ChallengeRequestResultStatuses.OpponentNull,
NewlyCreatedGame = null
});
}
var now = DateTime.UtcNow;
// Randomize sides
var players = new[] { initiatedBy, opponent }.OrderBy(x => Guid.NewGuid()).ToArray();
var white = players[0];
var black = players[1];
var newGame = new DbChessGame()
{
ChallengeDate = now,
InitiatedBy = initiatedBy,
Opponent = opponent,
WhitePlayer = white,
BlackPlayer = black,
Name = $"{initiatedBy.UserName} vs {opponent.UserName}",
LastMoveDate = now,
Status = GameState.InProgress
};
var newEntity = _dbContext.Add(newGame).Entity;
_dbContext.SaveChanges();
return(new ChallengeRequestResult
{
RequestResult = ChallengeRequestResultStatuses.Ok,
NewlyCreatedGame = _chessGameConverter.ConvertToChessGameDetails(newEntity)
});
}
void SendChallenge(IOutOctetStream outStream)
{
var challenge = new ChallengeRequest(challengeNonce);
if (useDebugLogging)
{
log.Debug($"Sending Challenge {challenge}");
}
ChallengeRequestSerializer.Serialize(outStream, challenge);
lastStateChange = monotonicClock.NowMilliseconds();
stateChangeWait = 500;
}
public IActionResult ConfirmAppIdentity([FromBody] ChallengeRequest data, [FromRoute] Guid appId)
{
var userName = User?.Identity?.Name;
if (userName == null || !_challengeRepository.IsPassed(userName, appId, data))
{
return(NotFound()); // endpoint will be masked, so Unauthorized() is an additional info we don't want to share
}
return(Ok(new ChallengeResponse {
AppAuth = _apps.GenerateAndRememberAppKey(userName)
}));
}
public Challenge Create(Guid initiativeId, ChallengeRequest request)
{
var challenge = new Challenge
{
Id = Guid.NewGuid(),
MultiChoiceChallenge = request.MultiChoiceChallenge,
YesNoChallenge = request.YesNoChallenge,
Question = request.Question,
Success = request.Success,
Type = request.Type
};
return(_challengeAdapter.Create(initiativeId, challenge));
}
public void ChallengeTest()
{
var rawRequest = new byte[] {
0x01, //packet type
0x00, 0x00, 0x00, 0x00, //instant key
0x67, 0x61, 0x6D, 0x65, 0x73, 0x70, 0x79, //gamename
0x00
};
var request = new ChallengeRequest(rawRequest);
request.Parse();
Assert.Equal(RequestType.Challenge, request.CommandName);
Assert.Equal((uint)0, request.InstantKey);
}
private static IList <LearningPath> RemoveDuplicateLearningPaths(ChallengeRequest request, IList <ContestResponse> currentContests)
{
List <LearningPath> filteredPaths = new List <LearningPath>();
HashSet <string> collectionHash = GetCollectionNames(currentContests);
foreach (LearningPath path in request.LearningPaths)
{
if (!collectionHash.Contains(path.CollectionName))
{
filteredPaths.Add(path);
}
}
return(filteredPaths);
}
//these exist instead of constructors because the Core does not know about the requests
public Challenge CreateChallenge(ChallengeRequest request)
{
VerifyStartTime(request.StartTime);
return(new Challenge
{
ChallengeId = Guid.NewGuid(),
Name = request.Name,
Duration = request.Duration,
StartTime = request.StartTime,
Category = ConvertString(request.Category),
Description = request.Description,
Units = request.Units,
DaysPerWeek = request.DaysPerWeek
});
}
private (bool, string) ValidateRequest(ChallengeRequest request)
{
if (request == null)
{
return(false, BuildErrorMessage(nameof(request)));
}
if (string.IsNullOrEmpty(request.UserName))
{
return(false, BuildErrorMessage(nameof(request.UserName)));
}
if (request.NumberOfOptions < 1)
{
return(false, BuildErrorMessage(nameof(request.NumberOfOptions)));
}
return(true, null);
}
public async Task <ChallengeDto> Handle(CreateChallengeCommand request, CancellationToken cancellationToken)
{
var userAlliance = await _currentUserService.GetCurrentUserAlliance();
var entity = new Challenge
{
Title = request.Title,
StartDate = request.StartDate,
FinishDate = request.FinishDate,
Status = ChallengeStatus.Scheduled,
Competitors = { userAlliance }
};
foreach (var taskId in request.Exercises)
{
var exercise = await _context.Exercises.FindAsync(new object[] { taskId }, cancellationToken);
if (exercise != null)
{
entity.Exercises.Add(exercise);
}
}
await _context.Challenges.AddAsync(entity, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
foreach (var allianceId in request.Alliances)
{
var challengeRequest = new ChallengeRequest {
AllianceId = allianceId, ChallengeId = entity.Id
};
await _context.ChallengeRequests.AddAsync(challengeRequest, cancellationToken);
}
await _context.SaveChangesAsync(cancellationToken);
return(_mapper.Map <ChallengeDto>(entity));
}
public IActionResult Challenge([FromBody] ChallengeRequest challengeRequest)
{
var result = _repository.Add(GetCurrentUser(), challengeRequest);
switch (result.RequestResult)
{
case ChallengeRequestResultStatuses.Ok:
_logger.LogInformation($"{GetCurrentUser()} has sent a challenge request to user with ID {challengeRequest.Opponent}.");
return(Created(new Uri($"{Request.Path}{result.NewlyCreatedGame.Id}", UriKind.Relative), result.NewlyCreatedGame));
case ChallengeRequestResultStatuses.InitiatedByUserNull:
_logger.LogError($"The challenger user ({GetCurrentUser()}) could not be found.");
return(BadRequest(result));
case ChallengeRequestResultStatuses.OpponentNull:
_logger.LogWarning($"{GetCurrentUser()} has sent a challenge request to user with ID {challengeRequest.Opponent} but opponent couldn't be found.");
return(BadRequest(result));
default:
return(InternalServerError(result));
}
}
public async Task <Result <ChallengeResponse> > Challenge(ChallengeRequest request)
{
var httpRequest = new HttpRequestMessage(HttpMethod.Post, new Uri($"{_settings.ServiceUrl}/token"));
httpRequest.Content = new FormUrlEncodedContent(new Dictionary <string, string>
{
["code"] = request.Code,
["client_id"] = request.ClientId,
["client_secret"] = request.ClientSecret,
["redirect_uri"] = request.RedirectUri,
["grant_type"] = "authorization_code"
});
var response = await _httpClient.SendAsync(httpRequest);
var stringResponseBody = await response.Content.ReadAsStringAsync();
var responseBody = JObject.Parse(stringResponseBody);
return(new ChallengeResponse
{
AccessToken = responseBody["id_token"].Value <string>()
});
}
public async Task <IActionResult> Get()
{
var userName = User?.Identity?.Name;
if (userName == null)
{
return(Unauthorized());
}
var appId = Guid.NewGuid();
var challengeKey = _obfuscatedEndpoints.StoreEndpoint($"/challenge/{appId}");
var challengeData = new ChallengeRequest {
Data = "random data"
};
var challenge = new FixedDataSenderChallenge(challengeData, $"/{challengeKey}");
BuildApp(challenge);
_apps.PrepareAppToBeServed(appId, userName, "/front/dist");
_challengeRepository.SaveChallenge(challenge, userName, appId);
var indexHtml = await _apps.GetHtmlAsync(appId);
return(Content(ObfuscateEndpoints(indexHtml), "text/html"));
}
public static void Serialize(IOutOctetStream stream, ChallengeRequest cmd)
{
stream.WriteUint8(CommandValues.ChallengeRequest);
stream.WriteUint32(cmd.Nonce);
}
public bool IsPassed(ChallengeRequest receivedRequest) => _challengeRequest.Data == receivedRequest.Data;
public FixedDataSenderChallenge(ChallengeRequest challengeRequest, string endpoint)
{
_challengeRequest = challengeRequest;
ChallengeFunction = $@"fetch('{endpoint}', {{method: 'POST', headers: {{ 'Authorization': `${{localStorage.getItem('token')}}`, 'Content-Type': 'Application/json' }}, body: '{JsonConvert.SerializeObject(_challengeRequest)}' }}).then(res => {{setState(res.ok); return res.json();}}).then(res => key = res['appAuth'])";
}
public async Task <IActionResult> IssueChallenge(int?id)
{
if (id is null)
{
return(NotFound());
}
var user = await _userManager.GetUserAsync(User);
var game = await _context.Game.Include(g => g.HomePlayer.User)
.Include(g => g.AwayPlayer.User)
.Include(g => g.Match)
.FirstOrDefaultAsync(g => g.GameId == id);
if (game.HomePlayer == null || game.AwayPlayer == null || game.HomePlayer.User.Id != user.Id)
{
return(NotFound());
}
var awayUser = await _userManager.FindByIdAsync(game.AwayPlayer.UserId + "");
bool userRefreshed = false, awayRefreshed = false;
userRefreshed = await _tokenRefresher.RefreshTokens(user, false);
awayRefreshed = await _tokenRefresher.RefreshTokens(awayUser, false);
if (!userRefreshed)
{
Log.Information("User access token expired");
await _signInManager.SignOutAsync();
return(RedirectToAction(nameof(AdminController.Index), "Home"));
}
GameJson gameJson = new GameJson
{
GameId = game.GameId.ToString(),
ChallengeId = game.ChallengeId,
Fen = game.CurrentFen,
ChallengeUrl = game.ChallengeUrl,
MatchId = game.MatchId,
Moves = new List <string>(),
Completed = false,
Result = "",
BlackPlayerId = game.BoardPosition % 2 == 1 ? game.HomePlayer.User.LichessId : game.AwayPlayer.User.LichessId,
WhitePlayerId = game.BoardPosition % 2 == 0 ? game.HomePlayer.User.LichessId : game.AwayPlayer.User.LichessId,
HomePlayerRating = game.Completed ? $"{game.HomePlayerRatingBefore} -> {game.HomePlayerRatingAfter}" : $"{game.HomePlayerRatingAfter}",
AwayPlayerRating = game.Completed ? $"{game.AwayPlayerRatingBefore} -> {game.AwayPlayerRatingAfter}" : $"{game.AwayPlayerRatingAfter}",
HomePoints = game.HomePoints.ToString(),
AwayPoints = game.AwayPoints.ToString()
};
// If JV, colors are swapped
if (game.BoardPosition > 7)
{
string temp = gameJson.BlackPlayerId;
gameJson.BlackPlayerId = gameJson.WhitePlayerId;
gameJson.WhitePlayerId = temp;
}
bool challengeCreated = false;
LichessApi.LichessApiClient client = new LichessApiClient(user.AccessToken);
if (awayRefreshed)
{
CreateGameRequest request = new CreateGameRequest
{
Rated = true,
ClockLimit = game.Match.ClockTimeLimit,
ClockIncrement = game.Match.ClockIncrement,
Color = game.BoardPosition % 2 == 0 ? Color.White : Color.Black,
Variant = GameVariant.Standard,
Fen = game.CurrentFen,
Message = "Your EPC team game with {opponent} is ready: {game}."
};
// Jv board colors are swapped
if (game.BoardPosition > 7)
{
if (request.Color == Color.White)
{
request.Color = Color.Black;
}
else
{
request.Color = Color.White;
}
}
try
{
var response = await client.Challenges.CreateGame(awayUser.LichessId, awayUser.AccessToken, request);
game.CurrentFen = response.Game.InitialFen;
game.ChallengeUrl = response.Game.Url;
game.ChallengeId = response.Game.Id;
game.ChallengeJson = JsonConvert.SerializeObject(response);
game.IsStarted = true;
gameJson.Status = response.Game.Status.Name;
gameJson.IsStarted = true;
challengeCreated = true;
}
catch (Exception e)
{
Log.Error(e, "Unable to create challenge");
}
}
else // This has to be a pure challenge request
{
ChallengeRequest request = new ChallengeRequest
{
Rated = true,
ClockLimit = game.Match.ClockTimeLimit,
ClockIncrement = game.Match.ClockIncrement,
Color = game.BoardPosition % 2 == 0 ? Color.White : Color.Black,
Variant = GameVariant.Standard,
Fen = game.CurrentFen,
Message = "Your EPC team game with {opponent} is ready: {game}."
};
// Jv board colors are swapped
if (game.BoardPosition > 7)
{
if (request.Color == Color.White)
{
request.Color = Color.Black;
}
else
{
request.Color = Color.White;
}
}
try
{
var response = await client.Challenges.CreateChallenge(awayUser.LichessId, request);
game.ChallengeUrl = response.Challenge.Url;
game.ChallengeId = response.Challenge.Id;
game.ChallengeJson = JsonConvert.SerializeObject(response);
game.IsStarted = true;
gameJson.Status = response.Challenge.Status;
gameJson.IsStarted = true;
challengeCreated = true;
}
catch (Exception e)
{
Log.Error(e, "Unable to create challenge");
}
}
if (challengeCreated)
{
MatchUpdateViewModel vm = new MatchUpdateViewModel
{
MatchId = game.MatchId,
Games = new List <GameJson>(new GameJson[] { gameJson })
};
// Issue an immediate match update
await _hubContext.Clients.Groups("match_" + game.Match.MatchId).SendAsync("UpdateMatches", vm);
_context.Game.Update(game);
await _context.SaveChangesAsync();
}
else
{
Log.Information("Challenge Url was empty");
// This likely happens if the user AccessToken expires and Refresh fails
await _signInManager.SignOutAsync();
return(RedirectToAction(nameof(AdminController.Index), "Home"));
}
return(Redirect(game.ChallengeUrl));
}
public ChallengeResponse(ChallengeRequest request, ChallengeResult result) : base(request, result)
{
}
public async Task <ActionResult <NameToFacesChallenge> > NameToFacesChallenge([FromBody] ChallengeRequest request)
{
try
{
var(success, errorMessage) = ValidateRequest(request);
if (!success)
{
_logger.LogWarning(errorMessage);
return(BadRequest(errorMessage));
}
var newChallenge = await _gameService.CreateNameToFacesChallenge(request).ConfigureAwait(false);
return(Ok(newChallenge));
}
catch (Exception ex)
{
_logger.LogError(ex, ErrorMessages.CreatingNewChallenge);
return(StatusCode((int)HttpStatusCode.InternalServerError, ex));
}
}
public bool IsPassed(string userName, Guid appId, ChallengeRequest receivedRequest) => _challenges.TryGetValue(new UserAppPair(userName, appId), out var challenge) && challenge.IsPassed(receivedRequest);
//we do not need to implement this to check the correctness of the challenge response
public ChallengeHandler(ISession session, IRequest request) : base(session, request)
{
_request = (ChallengeRequest)request;
}
