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; }