public static MatchResponse GetDominectMatch(GameCom.GameComClient client, uint width, uint height, string userToken) { var cancellationToken = new System.Threading.CancellationToken(); cancellationToken.Register(() => Console.WriteLine("Request cancelled!")); var mmParam = new MatchmakingParameter(); mmParam.RandomIsDefault = new Nothing(); var request = new MatchRequest() { UserToken = userToken, GameToken = "dom", MatchmakingParameters = mmParam, TimeoutSuggestionSeconds = 400, DomGameParameters = new GameParameter() { BoardWidth = width, BoardHeight = height } }; var reply = client.NewMatch(request, null, DateTime.UtcNow.AddMinutes(1d), cancellationToken); return(reply); }
public void MatchRequest_Url() { var r = new MatchRequest { Coordinates = matchLocations, Timestamps = new int[] { 1424684612, 1424684616, 142468462 } }; // Default values are not sent //Assert.AreEqual<int>(1, ParamValues(r.UrlParams, "steps").Length); //Assert.AreEqual<string>("false", ParamValues(r.UrlParams, "steps")[0]); //Assert.AreEqual<int>(1, ParamValues(r.UrlParams, "geometries").Length); //Assert.AreEqual<string>("polyline", ParamValues(r.UrlParams, "geometries")[0]); //Assert.AreEqual<int>(1, ParamValues(r.UrlParams, "overview").Length); //Assert.AreEqual<string>("simplified", ParamValues(r.UrlParams, "overview")[0]); Assert.IsTrue(r.CoordinatesUrlPart.Contains("13.393252,52.542648")); Assert.IsTrue(r.CoordinatesUrlPart.Contains("13.394780,52.543079")); Assert.IsTrue(r.CoordinatesUrlPart.Contains("13.397389,52.542107")); var tParams = ParamValues(r.UrlParams, "timestamps"); Assert.AreEqual <int>(1, tParams.Length); Assert.IsTrue(tParams[0].Contains("1424684612")); Assert.IsTrue(tParams[0].Contains("1424684616")); Assert.IsTrue(tParams[0].Contains("142468462")); }
/// <summary> /// Zwiększa "wagę" słowa wybranego z propozycji fraz. /// </summary> public void Match(MatchRequest request) { using (var ctx = new TypeFineContext()) { SaveInfo(request, ctx, RequestType.Match); KeywordPhraseReference reference; try { reference = ctx.KeywordPhraseReferences.Include(x => x.Keyword).Include(x => x.Phrase).Single(x => x.Keyword.Value == request.Keyword && x.Phrase.Value == request.Phrase); } catch (Exception) { throw new FaultException("nie znaleziono złączenia pomiędzy podanym słowem kluczowym i frazą", new FaultCode("Match")); } reference.UserWeight += 0.02; if (reference.CompositeConvergance > 1) { reference.Keyword.Phrase = reference.Phrase; var toRemove = reference.Keyword.WeakReferences.ToList(); ctx.KeywordPhraseReferences.RemoveRange(toRemove); ctx.SaveChanges(); } ctx.SaveChanges(); } }
public async Task ShouldGetAMatchesBeOkHavingElements() { var existing = Scenario.Matches.FirstOrDefault(); if (existing == null) { Assert.Inconclusive("No match found"); return; } var groups = Scenario.Groups.Where(x => x.MatchId == existing.Id).Select(x => x.Id).ToList(); var shooterGroups = Scenario.GroupShooters.Where(x => groups.Contains(x.GroupId)).ToList(); if (shooterGroups.Count == 0) { Assert.Inconclusive("No shooter in group"); return; } //conteggio esistenti generici o inseriti dall'utente var request = new MatchRequest { MatchId = existing.Id }; //Invoke del metodo var response = await Controller.GetMatch(request); //Parsing della risposta e assert var parsed = ParseExpectedOk <MatchContract>(response); Assert.IsTrue(parsed.Data.Groups.SelectMany(x => x.Shooters).Any()); }
private MatchResult GetExistsIIIds(object[] iiidsFilter) { if (iiidsFilter == null || iiidsFilter.Length == 0) { return(null); } var searchService = GetService <ISearchService>(); var matchRequest = new MatchRequest(); matchRequest.Top = 10; var dataMatchFilter = new Dictionary <string, object[]>(); dataMatchFilter.Add("iiid", iiidsFilter); matchRequest.Filter = dataMatchFilter; var dataMatchSort = new List <PKSKeyValuePair <string, object> >(); dataMatchSort.Add(new PKSKeyValuePair <string, object>("iiid", 1)); matchRequest.Sort = dataMatchSort; var fieldFilter = new SearchSourceFilter(); fieldFilter.Includes = new List <string> { "iiid", "dataid" }; matchRequest.Fields = fieldFilter; return(searchService.Match(matchRequest)); }
public async Task <ActionResult> UpdateMatch(int id, [FromBody] MatchRequest matchRequest) { if (id < 1 || matchRequest == null) { return(BadRequest()); } var matchToUpdate = await this.matchService.FindAsync(id); if (matchToUpdate == null) { return(NotFound()); } var match = this.mapper.Map(matchRequest, matchToUpdate); if (!validator.Validate(match).IsValid) { return(BadRequest()); } await this.matchService.UpdateAsync(match); logger.LogInformation($"UpdateMatch {match.Id}"); return(Ok()); }
public void CreateWithMatchmakerUI(MatchRequest request, IRealTimeMultiplayerListener listener) { Util.NullArgumentTest(request); Util.NullArgumentTest(listener); if (mCurrentMatchmakerVC != null) { Debug.Log("Ignoring CreateWithMatchmakerUI call because another matchmaker UI is being shown."); return; } // Create a new GKMatchmakerViewController. var vc = InteropObjectFactory <GKMatchmakerViewController> .Create( () => { using (var gkReq = request.ToGKMatchRequest()) return(new GKMatchmakerViewController(gkReq)); }, viewController => { return(viewController.ToPointer()); }); // Create a delgate for the vc. vc.MatchmakerDelegate = new InternalGKMatchmakerViewControllerDelegateImpl(this, listener); // Store the VC ref. mCurrentMatchmakerVC = vc; // Now show the VC. using (var unityVC = UIViewController.UnityGetGLViewController()) unityVC.PresentViewController(vc, true, null); }
public Task <Match> UpdateAsync(int id, MatchRequest request) { return(CommonOperationAsync(async() => { var result = await GetByIdAsync(id); Mapper.Map(request, result); /**************MatchDate And Order are unique*****************/ /*************************************************************/ var matchDateAndOrderUniqueResult = await _uow.Matches.GetByMatchDateAndOrderAsync(result.MatchDate, result.Order); matchDateAndOrderUniqueResult.CheckUniqueValueForUpdate(result.Id, WebApiResourceConstants.MatchDateAndOrder); /**************MatchDate And Order are unique*****************/ /*************************************************************/ SameValueCheckForTeam1AndTeam2(result); _uow.Matches.Update(result, GetLoggedInUserId()); await _uow.SaveChangesAsync(); return result; }, new BusinessBaseRequest() { MethodBase = MethodBase.GetCurrentMethod() })); }
public static void RespondToRequest(RpsAgent victim, RpsAgent initiator, bool accepted) { int requestIndex = instance.requests.FindIndex(r => r.victim == victim && r.initiator == initiator); if (requestIndex < 0) { Debug.Log("Server: " + victim.AgentName + " tried responding to a match that does not exist."); // TODO: Notify victim. return; } else { MatchRequest request = instance.requests[requestIndex]; if (accepted) { // Spawn new match. Debug.Log("Server: Match created between " + initiator.AgentName + " and " + victim.AgentName); RpsMatch match = GameObject.Instantiate <RpsMatch>(instance.RpsMatchPrefab); match.Initialize(request.initiator, request.victim); match.transform.SetParent(instance.transform); instance.ongoingMatches.Add(match); NetworkServer.Spawn(match.gameObject); } else { // Tell initiator that the victim declined. } instance.requests.RemoveAt(requestIndex); } }
public void Should_Return_Weighted_Scores_Based_On_Queued_Time() { var now = DateTime.Now; var player1 = new[] { new Player("bob") }; var player2 = new[] { new Player("sue") }; var player3 = new[] { new Player("jerry") }; var request1QueuedOn = now - TimeSpan.FromSeconds(2.75); var request1 = new MatchRequest(player1, new [] { GameTitle.HaloReach }, new [] { GameMode.Slayer, GameMode.Swat }, request1QueuedOn); var request2QueuedOn = now - TimeSpan.FromSeconds(6); var request2 = new MatchRequest(player2, new [] { GameTitle.HaloReach, GameTitle.Halo2 }, new [] { GameMode.Slayer, GameMode.Snipers }, request2QueuedOn); var request3QueuedOn = now - TimeSpan.FromSeconds(14); var request3 = new MatchRequest(player3, new [] { GameTitle.HaloReach }, new [] { GameMode.AssetDenial, GameMode.ActionSack }, request3QueuedOn); var scores = _sut.GetScores(new[] { request1, request2, request3 }); Assert.Equal(7, scores.Count); Assert.Equal(3, scores[new Preference(GameTitle.HaloReach, GameMode.Slayer)]); Assert.Equal(1, scores[new Preference(GameTitle.HaloReach, GameMode.Swat)]); Assert.Equal(2, scores[new Preference(GameTitle.HaloReach, GameMode.Snipers)]); Assert.Equal(2, scores[new Preference(GameTitle.Halo2, GameMode.Slayer)]); Assert.Equal(2, scores[new Preference(GameTitle.Halo2, GameMode.Snipers)]); Assert.Equal(3, scores[new Preference(GameTitle.HaloReach, GameMode.AssetDenial)]); Assert.Equal(3, scores[new Preference(GameTitle.HaloReach, GameMode.ActionSack)]); }
public async Task <IActionResult> PutMatch(int id, MatchRequest match) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // _context.Entry(match).State = EntityState.Modified; try { var responce = await _service.UpdateMatchAsync(match, id); if (responce == null) { return(BadRequest(ModelState)); } return(Ok(responce)); } catch (DbUpdateConcurrencyException) { if (!MatchExists(id)) { return(NotFound()); } else { throw; } } // return Ok(); // return NoContent(); }
/// <summary> /// This demo shows how the customer ledger can be printed out, matched and unmatched. /// The same code can run for supplier ledger by changing api.Reporting.CustomerLedger to api.Reporting.SupplierLedger. /// </summary> public static async Task CustomerLedger() { var authorizationSettings = new AuthorizationSettings { ApplicationKey = "<You Application Key Here>", ClientKey = "<PowerOffice Go Client Key Here>", TokenStore = new BasicTokenStore(@"my.tokenstore"), EndPointHost = Settings.EndPointMode.Production //For authorization against the demo environment - Change this to Settings.EndPointMode.Demo }; // Initialize the PowerOffice Go API and request authorization var api = await Go.CreateAsync(authorizationSettings); Console.WriteLine("Customer ledger:"); PrintStatement(api); //PrintOpenItems(api); //Create a match request with all IDs that you want matched or unmatched. var matchRequest = new MatchRequest(DateTime.Today, new long[] { 2612317, 2890048 }); //Request to clear matches api.Reporting.CustomerLedger.UnmatchEntries(matchRequest); //Request to match entries together api.Reporting.CustomerLedger.MatchEntries(matchRequest); //NOTE: The same API methods also exists on api.Reporting.SupplierLedger }
public async Task <ActionResult <MatchResponse> > MatchRequest(MatchRequest request) { var matchResponse = new MatchResponse(); try { using var channel = GrpcChannel.ForAddress(FrontendUrl); var client = new FrontendServiceClient(channel); var searchFields = new SearchFields(); searchFields.Tags.Add(request.GameMode.ToString()); var ticket = new Ticket(); ticket.SearchFields = searchFields; CreateTicketRequest createTicketRequest = new CreateTicketRequest(); createTicketRequest.Ticket = ticket; var response = await client.CreateTicketAsync(createTicketRequest); matchResponse.TicketId = response.Id; } catch (Exception ex) { Console.WriteLine(ex.ToString()); } return(matchResponse); }
public async Task ShouldDeleteMatchBeOkHavingDeletedElement() { //Recupero una Match esistente non utilizzato var existing = Scenario.Matches.FirstOrDefault(); if (existing == null) { Assert.Inconclusive("Match does not exists"); } //Conteggio gli elementi prima della cancellazione var countBefore = Scenario.Matches.Count; //Composizione della request var request = new MatchRequest { MatchId = existing.Id }; //Invoke del metodo var response = await Controller.DeleteMatch(request); //Parsing della risposta var parsed = ParseExpectedOk <MatchContract>(response); //Conteggio gli elementi dopo la cancellazione var countAfter = Scenario.Matches.Count; Assert.IsTrue( parsed.Data.MatchId == existing.Id); Assert.AreEqual(countBefore - 1, countAfter); }
static void Main(string[] args) { var url = "http://localhost:2710//api//WhoScored//GetMatchDetails"; MatchRequest request = new MatchRequest(); request.HomeTeamId = 75; request.Date = "03-11-16"; MatchRequest request2 = new MatchRequest(); request.HomeTeamId = 256; request.Date = "06-11-16"; MatchRequest request3 = new MatchRequest(); request.HomeTeamId = 36; request.Date = "18-11-16"; string x = ""; Task.Factory.StartNew(() => x = PostApiCall(url, request)); Task.Factory.StartNew(() => PostApiCall(url, request2)); Task.Factory.StartNew(() => PostApiCall(url, request3)); Console.WriteLine("lecimy tutaj"); Console.ReadKey(); }
public void Should_Match_Player_Parties_In_Multiple_Requests() { var now = DateTime.Now; var party1 = new[] { new Player("bob"), new Player("sue") }; var party2 = new[] { new Player("jerry"), new Player("james") }; var request1 = new MatchRequest(party1, new [] { GameTitle.HaloReach }, new [] { GameMode.Slayer }, now); var request2 = new MatchRequest(party2, new [] { GameTitle.HaloReach }, new [] { GameMode.Slayer }, now); var scores = new Dictionary <Preference, int> { { new Preference(GameTitle.HaloReach, GameMode.Slayer), 2 } }; _scoreCalculator.Setup(x => x.GetScores(It.IsAny <IEnumerable <MatchRequest> >())).Returns(scores); var result = _sut.Matchmake(GameFormat.TwoVersusTwo, new [] { request1, request2 }); var matches = result.Matches; Assert.Single(matches); var match1 = matches.ElementAt(0); Assert.Equal(GameFormat.TwoVersusTwo, match1.Format); Assert.Equal(GameTitle.HaloReach, match1.Title); Assert.Equal(GameMode.Slayer, match1.Mode); Assert.Contains(request1, match1.Requests); Assert.Contains(request2, match1.Requests); }
public void Identify(MatchRequest request) { // Clients.All if (Program.ServerForm.BenchmarkMode) { Clients.Caller.addMessage(DateTime.Now, "Got Request. Matching..."); } if (Program.ServerForm.Verbose) { Program.ServerForm.LogMessage("Got Request. Matching..."); } //Func<CompareResult, CompareResult> callback = (result) => //{ // if (result.Success) // Clients.All.addMessage(name, date, "Callback > Scanned: " + result.Scanned); // return null; //}; var result = Program.ServerForm.Identify(request); // Clients.All Clients.Caller.IdentifyComplete(result); if (Program.ServerForm.Verbose) { Program.ServerForm.LogMessage("Result sent."); } }
public async Task <IActionResult> RealizarMatch([FromBody] MatchRequest request) { SimpleResponse response = new SimpleResponse(); if (request.DoacaoId == null || request.DoacaoId == null) { response.Sucesso = false; response.Mensagem = "É necessário informar o id do item de necesside e de doação"; } else { try { response = await ExecutaMatch(request.NecessidadeId.Value, request.DoacaoId.Value); } catch (SessaoExpiradaException) { return(RedirectToAction("Logout", "Account")); } response.Sucesso = true; } return(StatusCode(StatusCodes.Status200OK, response)); }
public void Should_Match_Players_With_Longest_Queued_Times_First() { var now = DateTime.Now; var player1 = new[] { new Player("bob") }; var player2 = new[] { new Player("sue") }; var player3 = new[] { new Player("jerry") }; var request1 = new MatchRequest(player1, new [] { GameTitle.HaloReach }, new [] { GameMode.Slayer, GameMode.Swat }, now + TimeSpan.FromSeconds(2)); var request2 = new MatchRequest(player2, new [] { GameTitle.HaloReach }, new [] { GameMode.Slayer, GameMode.Swat }, now + TimeSpan.FromSeconds(3)); var request3 = new MatchRequest(player3, new [] { GameTitle.HaloReach }, new [] { GameMode.Slayer }, now); var scores = new Dictionary <Preference, int> { { new Preference(GameTitle.HaloReach, GameMode.Swat), 2 }, { new Preference(GameTitle.HaloReach, GameMode.Slayer), 3 } }; _scoreCalculator.Setup(x => x.GetScores(It.IsAny <IEnumerable <MatchRequest> >())).Returns(scores); var result = _sut.Matchmake(GameFormat.OneVersusOne, new [] { request1, request2, request3 }); Assert.Single(result.Matches); var match = result.Matches.Single(); Assert.Equal(GameFormat.OneVersusOne, match.Format); Assert.Equal(GameTitle.HaloReach, match.Title); Assert.Equal(GameMode.Slayer, match.Mode); Assert.Contains(request1, match.Requests); Assert.Contains(request3, match.Requests); Assert.Contains(request2, result.UnmatchedRequests); }
public async Task <IActionResult> DeleteMatch([EntityId] MatchRequest request) { //Recupero l'elemento dal business layer var entity = BasicLayer.GetMatch(request.MatchId); //Se l'utente non hai i permessi non posso rimuovere entità con userId nullo if (entity == null) { return(NotFound()); } //Invocazione del service layer var validations = await BasicLayer.DeleteMatch(entity, PlatformUtils.GetIdentityUserId(User)); if (validations.Count > 0) { return(BadRequest(validations)); } var association = BasicLayer.GetAssociation(entity.AssociationId); var place = BasicLayer.GetPlace(entity.PlaceId); //Return contract return(Ok(ContractUtils.GenerateContract(entity, association, place))); }
public static void CustomerLedger() { var authorizationSettings = new AuthorizationSettings { ApplicationKey = "<You Application Key Here>", ClientKey = "<PowerOffice Go Client Key Here>", TokenStore = new BasicTokenStore(@"my.tokenstore") }; // Initialize the PowerOffice Go API and request authorization var api = new Go(authorizationSettings); Console.WriteLine("Customer ledger:"); PrintStatement(api); //PrintOpenItems(api); //Create a match request with all IDs that you want matched or unmatched. var matchRequest = new MatchRequest(DateTime.Today, new long[] { 2612317, 2890048 }); //Request to clear matches api.Reporting.CustomerLedger.UnmatchEntries(matchRequest); //Request to match entries together api.Reporting.CustomerLedger.MatchEntries(matchRequest); //NOTE: The same API methods also exists on api.Reporting.SupplierLedger }
public async Task <ActionResult <ObjectResult <Cascade <int> > > > Submit([FromBody] MatchRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, Types.SitePermissions.TemplatesMatch)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (site == null) { return(NotFound()); } if (request.ChannelIds != null && request.ChannelIds.Count > 0) { if (request.IsChannelTemplate) { foreach (var channelId in request.ChannelIds) { var channelInfo = await _channelRepository.GetAsync(channelId); channelInfo.ChannelTemplateId = request.TemplateId; await _channelRepository.UpdateChannelTemplateIdAsync(channelInfo); } } else { foreach (var channelId in request.ChannelIds) { var channelInfo = await _channelRepository.GetAsync(channelId); channelInfo.ContentTemplateId = request.TemplateId; await _channelRepository.UpdateContentTemplateIdAsync(channelInfo); } } } await _authManager.AddSiteLogAsync(request.SiteId, "模板匹配"); var channel = await _channelRepository.GetAsync(request.SiteId); var cascade = await _channelRepository.GetCascadeAsync(site, channel, async summary => { var count = await _contentRepository.GetCountAsync(site, summary); var entity = await _channelRepository.GetAsync(summary.Id); return(new { Count = count, entity.ChannelTemplateId, entity.ContentTemplateId }); }); return(new ObjectResult <Cascade <int> > { Value = cascade }); }
public void OnBeginMatch() { ClientRequestBase req = null; req = new MatchRequest(ClientID, SelectBuildManager.Instance.CurrentSelectedBuildInfo.BuildID); SendMessage(req); ClientState = ClientStates.Matching; }
private void cmdSendTasks_Click(object sender, EventArgs e) { var request = new MatchRequest(MatchManager.Cache.Fingerprints[MatchManager.LocaleId][1]); //LastFingerprint); request.ExtraRefCode = 123; RichTextBoxConsole.AppendText(Environment.NewLine + String.Format("{0}", "Request sent")); client.IdentifyAsync(request); }
public void CreateWithMatchmakerUI(MatchRequest request, IRealTimeMultiplayerListener listener) { PlayGamesPlatform.Instance.RealTime.CreateWithInvitationScreen( request.MinPlayers - 1, request.MaxPlayers - 1, (uint)GPGTypeConverter.ToGPGSVariant(request.Variant, MatchType.RealTime), new GPGRealTimeMultiplayerListener(listener, false)); }
public void CreateQuickMatch(MatchRequest request, IRealTimeMultiplayerListener listener) { PlayGamesPlatform.Instance.RealTime.CreateQuickGame( request.MinPlayers - 1, request.MaxPlayers - 1, (uint)GPGTypeConverter.ToGPGSVariant(request.Variant, MatchType.RealTime), new GPGRealTimeMultiplayerListener(listener, true)); }
public async Task <ActionResult <MatchResponse> > FindMatches(MatchRequest request) { var matches = await _matchService.FindMatchesAsync(request.Text, request.Subtext); return(new MatchResponse { Text = request.Text, Subtext = request.Subtext, Matches = matches.ToArray() }); }
public string GetMatchDetails(MatchRequest request) { //https://www.whoscored.com/Teams/256 (Feyenord) id=256 MatchDetails details = _whoscoredService.GetMatchDetails(request.Date, request.HomeTeamId); return(JsonConvert.SerializeObject(details)); }
public Task <IActionResult> FetchAllGroups(MatchRequest request) { //Recupero la lista dal layer var entities = BasicLayer.FetchAllGroupsByMatchId(request.MatchId); //Ritorno i contratti return(Reply(entities.As(x => ContractUtils.GenerateContract(x)))); }
public void MatchRequest_Defaults() { var r = new MatchRequest(); Assert.AreEqual <bool>(false, r.Steps); Assert.AreEqual <string>("polyline", r.Geometries); Assert.AreEqual <string>("simplified", r.Overview); Assert.IsNotNull(r.Timestamps); }
public void TestMatch() { MatchLogic matchLogic = new MatchLogic(); var dataManager = new DataManager(); MatchRequest req = new MatchRequest(); var userDataPuddy = new UserProfileRequest { //UserID = 69, UserName = "******", ProfileAttributeType = ProfileAttributeTypeEnum.All }; UserProfileData match = dataManager.FetchProfile(userDataPuddy); // This is elaine. req.UserID = 6969; MatchResponse response = matchLogic.GetMatchByLocation(req); if (response != null) { if (response.MatchProfiles != null && response.MatchProfiles.Count() > 0) { foreach (ChoiceProfile cp in response.MatchProfiles) { cp.ChoiceType = ChoiceTypeEnum.Like; } // Add the match profiles var userProfileData = new UserProfileData { UserData = match.UserData, UserChoices = response.MatchProfiles }; dataManager.ModifyProfile(userProfileData); } } }