public async Task <ActionResult <PaginatedCollection <RankingEntryLight> > > GetRankingAsync( [FromRoute] Game game, [FromRoute] DateTime?date, [FromQuery] int page, [FromQuery] int count, [FromQuery] bool full, [FromQuery] long?simulatedPlayerId) { var request = new RankingRequest { Game = game, FullDetails = full }; var now = ServiceProviderAccessor.ClockProvider.Now; if (simulatedPlayerId.HasValue && date.HasValue) { request.PlayerVsLegacy = (simulatedPlayerId.Value, date.Value); request.RankingDate = now; } else { request.RankingDate = date ?? now; } var rankingEntries = await _statisticsProvider .GetRankingEntriesAsync(request) .ConfigureAwait(false); return(Ok(PaginatedCollection <RankingEntryLight> .CreateInstance(rankingEntries, page, count))); }
// Gets the full game ranking entries private async Task <List <RankingDto> > GetFullGameRankingAsync(RankingRequest request) { var rankingEntries = new ConcurrentBag <RankingDto>(); var tasks = new List <Task>(); foreach (var stage in request.Game.GetStages()) { tasks.Add(Task.Run(async() => { foreach (var level in SystemExtensions.Enumerate <Level>()) { if (!request.SkipStages.Contains(stage)) { var stageLevelRankings = await GetStageLevelRankingAsync(request, stage, level) .ConfigureAwait(false); rankingEntries.AddRange(stageLevelRankings); } } })); } await Task.WhenAll(tasks).ConfigureAwait(false); return(rankingEntries.ToList()); }
// Gets entries for a stage and level private async Task <List <EntryDto> > GetStageLevelEntriesAsync( RankingRequest request, Stage stage, Level level) { var entries = await GetStageLevelEntriesCoreAsync(request.Players, stage, level, request.Entries) .ConfigureAwait(false); if (request.Engine.HasValue) { entries.RemoveAll(_ => (_.Engine != Engine.UNK && _.Engine != request.Engine.Value) || (!request.IncludeUnknownEngine && _.Engine == Engine.UNK)); } if (request.RankingStartDate.HasValue) { entries.RemoveAll(_ => _.Date < request.RankingStartDate.Value); } if (request.PlayerVsLegacy.HasValue) { entries.RemoveAll(_ => _.Date > request.PlayerVsLegacy.Value.Item2 && _.PlayerId != request.PlayerVsLegacy.Value.Item1); } return(entries); }
public IHttpActionResult Post([FromBody] RankingRequest rankingRequest) { try { using (var db = new DesputadosContext()) { var u = db.usuarios.FirstOrDefault(x => x.ID == rankingRequest.idUsuario); if (u == null) { return(Ok(new { sucesso = false, mensagem = "O usuário informado não existe" })); } else { var ranking = db.ranking_usuario.FirstOrDefault(x => x.ID_USUARIO == rankingRequest.idUsuario); ranking.PONTUACAO += 1; db.SaveChanges(); return(Ok(new { sucesso = true, mensagem = "" })); } } } catch (Exception ex) { return(InternalServerError(ex)); } }
/// <inheritdoc /> public async Task <IReadOnlyCollection <RankingEntryLight> > GetRankingEntriesAsync( RankingRequest request) { request.Players = await GetPlayersInternalAsync().ConfigureAwait(false); return(await GetFullGameConsolidatedRankingAsync(request) .ConfigureAwait(false)); }
public RankingRequest Request(Guid usuarioId) { var request = new RankingRequest { UsuarioId = usuarioId.ToString() }; return(request); }
public void RequestScoreRanking(int skip, int take, UserInfo info = null) { Debug.Assert(IsActive); RankingRequest request = new RankingRequest(); request.Skip = skip; request.Take = take; if (info != null) { request.Sereal = info.Sereal; } MessageMan.SendSystemMessage(MessageCommand.GetScoreRanking, request); }
private async Task <List <RankingEntry> > GetRankingsWithParamsAsync( Game game, DateTime rankingDate, long?playerId, int?monthsPrior, Stage[] skipStages, bool?excludeWinners, int?engine) { var request = new RankingRequest { Game = game, FullDetails = true, SkipStages = skipStages, RankingDate = rankingDate, Engine = (Engine?)engine, IncludeUnknownEngine = true }; if (playerId.HasValue) { request.PlayerVsLegacy = (playerId.Value, rankingDate); request.RankingDate = DateTime.Now; } if (excludeWinners != false) { request.ExcludePlayer = excludeWinners.HasValue ? RankingRequest.ExcludePlayerType.HasWorldRecord : RankingRequest.ExcludePlayerType.HasUntied; } if (monthsPrior.HasValue) { request.RankingStartDate = rankingDate.AddMonths(-monthsPrior.Value); } var rankingEntriesBase = await _statisticsProvider .GetRankingEntriesAsync(request) .ConfigureAwait(false); return(rankingEntriesBase.Select(r => r as RankingEntry).ToList()); }
IEnumerator coRanking(RankingRequest request, RPCHandler <RankingReply> handler) { //try //{ // var metaData = new Metadata // { // { "access_key", GameDataManager.Instance.userData.accessKey } // }; // var reply = client.Ranking(request, metaData); // handler(reply); //} //catch (Grpc.Core.RpcException e) //{ // Debug.LogError("RPC failed " + e); //} yield return(null); }
public override Task <RankingResponse> Obter(RankingRequest request, ServerCallContext context) { var response = new RankingResponse(); try { var usuarioId = request.UsuarioId.ToGuid(); var envelopeResponse = servico.Obter(usuarioId); var obterParser = new RankingObter(); response = obterParser.Response(envelopeResponse); } catch (Exception ex) { response.HttpStatusCode = (int)HttpStatusCode.InternalServerError; } return(Task.FromResult(response)); }
public UserRankInfo[] GetRanking(RankingRequest request) { using (var connection = new SQLiteConnection(ConnectionString))// 「DataSource=:memory:」にするとオンメモリのDBとして動作 { // データベースに接続 connection.Open(); using (var context = new DataContext(connection)) { User target = (request.Sereal != 0)? User.Find(context, request.Sereal): null; var data = UserScore.Rank(context, request.Skip, request.Take, target); UserRankInfo[] ret = new UserRankInfo[data.Length]; // foreach (var score in data) for (int i = 0; i < data.Length; i++) { var score = data[i]; UserRankInfo rankInfo = new UserRankInfo(); rankInfo.Point = score.Point; rankInfo.Rank = request.Skip + i; User user = User.FindByUserId(context, score.UserId); rankInfo.UserId = score.UserId; rankInfo.Name = user.Name; ret[i] = rankInfo; } connection.Close(); return(ret); } } }
public bool RecieveMessage(MessageManager manager, MessageHeader header, byte[] data) { Debug.Assert(data != null); string text = Encoding.UTF8.GetString(data); Console.WriteLine("Recieve " + header.Name); MessageCommand param; try { param = (MessageCommand)Enum.Parse(typeof(MessageCommand), header.Name); } catch (Exception e) { Console.WriteLine(header.Name + " is unmanaged " + e); return(false); } switch (param) { case MessageCommand.Login: UserInfo userInfo = JsonConvert.DeserializeObject <UserInfo>(text); int userId = DBManager.UpdateUserData(userInfo); if (userId > 0) { UserInfoResponse userInfoRespon = new UserInfoResponse(userInfo, userId); // アップデートした情報を返す manager.SendSystemMessage(MessageCommand.ResUserInfo, userInfoRespon); lock (Server.ClientDataCollection) { foreach (var client in Server.ClientDataCollection) { if (client.Manager == manager) { client.Serieal = userInfo.Sereal; client.Name = userInfo.Name; client.UserId = userId; break; } } } } else { Console.WriteLine("Login Failed"); return(false); } break; // case "UploadScore": case MessageCommand.UploadUserScore: UserScoreParam scoreParam = JsonConvert.DeserializeObject <UserScoreParam>(text); UserRankInfo rankInfo = new UserRankInfo(); if (DBManager.StoreUserScore(scoreParam, ref rankInfo)) { // アップデートした情報を返す manager.SendSystemMessage(MessageCommand.ResUserRank, rankInfo); } else { Console.WriteLine("Login Failed"); return(false); } break; // case "ReqScoreRanking": case MessageCommand.GetScoreRanking: RankingRequest rankingReq = JsonConvert.DeserializeObject <RankingRequest>(text); UserRankInfo[] rankInfos = DBManager.GetRanking(rankingReq); if (rankInfos != null) { // アップデートした情報を返す manager.SendSystemMessage(MessageCommand.ResScoreRanking, rankInfos); Server.UserScoreRankDataCollection.Clear(); foreach (var info in rankInfos) { Server.UserScoreRankDataCollection.Add(new UserScoreRankData(info)); } } else { Console.WriteLine("Login Failed"); return(false); } break; default: Console.WriteLine(header.Name + " is unmanaged"); // break; return(false); } return(true); }
// Ranking public void Ranking(RankingRequest request, RPCHandler <RankingReply> handler) { StartCoroutine(coRanking(request, handler)); }
// Gets ranking entries for a stage and level private async Task <List <RankingDto> > GetStageLevelRankingAsync( RankingRequest request, Stage stage, Level level) { var entries = await GetStageLevelEntriesAsync(request, stage, level) .ConfigureAwait(false); // Groups and sorts by date var entriesDateGroup = new SortedList <DateTime, List <EntryDto> >( entries .GroupBy(e => e.Date.Value.Date) .ToDictionary( eGroup => eGroup.Key, eGroup => eGroup.ToList())); var rankingsToInsert = new List <RankingDto>(); // For the current date + previous days // Gets the min time entry for each player // Then orders by entry time overall (ascending) var selectedEntries = entriesDateGroup .Where(kvp => kvp.Key <= request.RankingDate) .SelectMany(kvp => kvp.Value) .GroupBy(e => e.PlayerId) .Select(eGroup => eGroup.First(e => e.Time == eGroup.Min(et => et.Time))) .OrderBy(e => e.Time) .ThenBy(e => e.Date.Value) .ToList(); var pos = 1; var posAgg = 1; long?currentTime = null; foreach (var entry in selectedEntries) { if (!currentTime.HasValue) { currentTime = entry.Time; } else if (currentTime == entry.Time) { posAgg++; } else { pos += posAgg; posAgg = 1; currentTime = entry.Time; } var ranking = new RankingDto { Date = request.RankingDate, Level = entry.Level, PlayerId = entry.PlayerId, Rank = pos, Stage = entry.Stage, Time = entry.Time, EntryDate = entry.Date.Value, IsSimulatedDate = entry.IsSimulatedDate }; rankingsToInsert.Add(ranking); } return(rankingsToInsert); }
// Gets the full game ranking private async Task <List <RankingEntryLight> > GetFullGameConsolidatedRankingAsync(RankingRequest request) { // Gets ranking var finalEntries = await GetFullGameRankingAsync(request) .ConfigureAwait(false); if (request.ExcludePlayer.HasValue) { // Computes WR holders (untied or not) var wrHolders = finalEntries .Where(e => e.Rank == 1 && ( request.ExcludePlayer == RankingRequest.ExcludePlayerType.HasWorldRecord || !finalEntries.Any(eBis => eBis.Rank == 1 && eBis.PlayerId != e.PlayerId && eBis.Stage == e.Stage && eBis.Level == e.Level))) .Select(e => e.PlayerId) .ToList(); // Remove WR holders from players list request.Players = request.Players .Where(p => !wrHolders.Contains(p.Key)) .ToDictionary(p => p.Key, p => p.Value); // Gets ranking without WR holders finalEntries = await GetFullGameRankingAsync(request) .ConfigureAwait(false); } var rankingEntries = finalEntries .GroupBy(e => e.PlayerId) .Select(e => request.FullDetails ? new RankingEntry(request.Game, request.Players[e.Key]) : new RankingEntryLight(request.Game, request.Players[e.Key])) .ToList(); foreach (var entryGroup in finalEntries.GroupBy(r => new { r.Stage, r.Level })) { foreach (var timesGroup in entryGroup.GroupBy(l => l.Time).OrderBy(l => l.Key)) { var rank = timesGroup.First().Rank; bool isUntied = rank == 1 && timesGroup.Count() == 1; foreach (var timeEntry in timesGroup) { rankingEntries .Single(e => e.Player.Id == timeEntry.PlayerId) .AddStageAndLevelDatas(timeEntry, isUntied); } } } return(rankingEntries .OrderByDescending(r => r.Points) .ToList() .WithRanks(r => r.Points)); }