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