public async Task <string> GetScoreboard(Activity activity, Match match, CancellationToken cancellationToken)
{
var topOrBottom = match.Groups[1].Value;
string partition = "defaultpartition";
if (MessageLogic.ThingsSlopPhrases.Contains(match.Groups[3].Value))
{
partition = "msteams_entity";
}
else if (MessageLogic.UsersSlopPhrases.Contains(match.Groups[3].Value))
{
partition = "msteams_user";
}
ScoreboardModel response = await _db.ExecuteStoredProcedureAsync($"/{_db.GetCollectionUri()}/sprocs/scoreboard", partition, cancellationToken, (topOrBottom == "bottom").ToString().ToLower());
var sb = new StringBuilder();
foreach (KarmaModel karma in response.Feed)
{
sb.AppendFormat("{0}={1},\n\n ", karma.Entity, karma.Score);
}
return(sb.ToString().TrimEnd(',', ' '));
}
public GymStandingViewModel(
ScoreboardModel scoreboard,
ILookup <int, TeamMemberModel> teamMembers)
: base(scoreboard, true, false)
{
TeamMembers = teamMembers;
}
public ActionResult Stats()
{
ViewBag.Message = "A page to contain stats";
//grab the data
List <ScoreboardModel> scoreboard = new List <ScoreboardModel>();
PokerViewModel viewModel = _pokerService.GetPokerData();
List <Data.PokerResult> results = _pokerService.GetResults();
List <Data.PokerMatch> matches = _pokerService.GetMatches();
//loop through data and map it to model
foreach (var user in viewModel.Users)
{
int totalIncoming = 0;
int totalOutgoings = 0;
int totalWins = 0;
var userResults = results.Where(x => x.PokerUserId == user.Id).ToList();
foreach (var result in userResults)
{
var currentMatch = matches.Where(x => x.Id == result.PokerMatchId).FirstOrDefault();
var matchResults = results.Where(x => x.PokerMatchId == currentMatch.Id);
totalOutgoings += currentMatch.BuyIn;
//if this user won
if (result.Placing == (int)Enums.Placing.First)
{
totalWins += 1;
totalIncoming += (currentMatch.BuyIn * matchResults.Count());
if (!currentMatch.IsWinnerTakesAll)
{
//second place gets money back
totalIncoming -= currentMatch.BuyIn;
}
}
}
ScoreboardModel userScore = new ScoreboardModel();
userScore.Name = user.Name;
userScore.GamesPlayed = userResults.Count;
userScore.TotalWins = totalWins;
userScore.TotalIncomings = totalIncoming;
userScore.TotalOutgoings = totalOutgoings;
userScore.Profit = totalIncoming - totalOutgoings;
userScore.TotalLosses = userResults.Count - totalWins;
userScore.WinPercentage = Math.Round((totalWins * 100.0) / userResults.Count);
scoreboard.Add(userScore);
}
viewModel.Scoreboard = scoreboard;
return(View(viewModel));
}
public TinyBoard(
ScoreboardModel scb,
int teamid,
Category category,
Affiliation affiliation)
: base(scb)
{
_row = scb.Data[teamid];
_category = category;
_affiliation = affiliation;
}
public List <Data.PokerMatch> GetScoreboardData()
{
ScoreboardModel scoreboard = new ScoreboardModel();
using (var db = new EFContext())
{
var data = from matches in db.PokerMatches
join results in db.PokerResults on matches.Id equals results.PokerMatchId
join users in db.PokerUsers on results.PokerUserId equals users.Id
select matches;
return(data.ToList());
};
}
public ActionResult GetNewScore(ScoreboardModel model)
{
try
{
ActionType action;
if (!Enum.TryParse(model.scoreAction, out action))
{
throw new Exception("Entered action is not valid.");
}
scoreService.GetScoreByAction(model, action);
return(View("CurrentScoreboared", model));
}
catch (Exception ex)
{
return(View("Feedback", ex.Message as object));
}
}
public TeamHomeViewModel(
ScoreboardModel scb,
int teamid,
IReadOnlyList <Clarification> clars,
IReadOnlyList <SubmissionViewModel> submits)
: base(scb)
{
var row = scb.Data[teamid];
RankCache = row.RankCache;
ScoreCache = row.ScoreCache;
TeamId = row.TeamId;
TeamName = row.TeamName;
TeamLocation = row.TeamLocation;
Affiliation = scb.Affiliations[row.AffiliationId];
Category = scb.Categories[row.CategoryId];
Clarifications = clars;
Submissions = submits;
}
public static void OnScoreboardUpdate(Object unused)
{
List <ScoreboardModel> AllPlayer = new List <ScoreboardModel>();
foreach (PlayerModel player in Alt.GetAllPlayers())
{
TimeSpan PlayTimeSpan = TimeSpan.FromMinutes(player._Playtime);
string NormalizedPlaytime = string.Format("{0:00}:{1:00}", (int)PlayTimeSpan.TotalHours, PlayTimeSpan.Minutes);
if (player._LoggedIn)
{
ScoreboardModel cplayerModel = new ScoreboardModel
{
Name = player.GetVnXName(),
Kills = player._Kills.ToString(),
Tode = player._Deaths.ToString(),
Playtime = NormalizedPlaytime,
Ping = player.Ping.ToString(),
Streaks = player._Level.ToString()
};
AllPlayer.Add(cplayerModel);
}
else
{
ScoreboardModel cplayerModel = new ScoreboardModel
{
Name = player.Name,
Kills = "-",
Tode = "-",
Playtime = "Connecting...",
Ping = "-",
Streaks = "-"
};
AllPlayer.Add(cplayerModel);
}
}
foreach (PlayerModel player in Alt.GetAllPlayers())
{
player.Emit("Scoreboard:Update", JsonConvert.SerializeObject(AllPlayer));
}
}
public JuryViewTeamModel(
Team team,
Category category,
Affiliation affiliation,
IReadOnlyList <TeamMemberModel> members,
IReadOnlyList <Solution> solutions,
ScoreboardModel scoreboard)
{
Solutions = solutions;
Category = category;
Affiliation = affiliation;
Members = members;
Status = team.Status;
TeamId = team.TeamId;
TeamName = team.TeamName;
TeamLocation = team.Location;
if (scoreboard.Data.ContainsKey(TeamId))
{
Board = new TinyBoard(scoreboard, TeamId, category, affiliation);
}
}
public ActionResult Index()
{
var viewModel = new ScoreboardModel();
return(View(viewModel));
}
public async Task <JobStatus> ExecuteAsync(string arguments, Job job, ILogger logger)
{
var args = arguments.AsJson <Models.ScoreboardArguments>();
var context = await _factory.CreateAsync(args.ContestId, _serviceProvider, true);
if (context == null)
{
logger.LogError("Unknown contest ID specified.");
return(JobStatus.Failed);
}
var contest = context.Contest;
if (!contest.StartTime.HasValue ||
contest.RankingStrategy == CcsDefaults.RuleCodeforces ||
contest.Feature == CcsDefaults.KindProblemset)
{
logger.LogError("Export constraint failed.");
return(JobStatus.Failed);
}
logger.LogInformation("Calculating scoreboard...");
DateTimeOffset?endTime = args.IncludeUpsolving
? DateTimeOffset.Now
: (contest.StartTime + contest.EndTime);
var raw = await RankingSolver.Select(contest)
.RefreshCache(
_scoreboard,
new Events.ScoreboardRefreshEvent(context, endTime));
var rankCaches = raw.RankCache.ToDictionary(r => r.TeamId);
var scoreCaches = raw.ScoreCache.ToLookup(r => r.TeamId);
var teams1 = await((ITeamContext)context).GetScoreboardRowsAsync();
var teams = teams1.ToDictionary(
k => k.TeamId,
v => v.With(rankCaches.GetValueOrDefault(v.TeamId), scoreCaches[v.TeamId]));
logger.LogInformation("Loading other things from database...");
var affs = await context.ListAffiliationsAsync();
var orgs = await context.ListCategoriesAsync();
var probs = await context.ListProblemsAsync();
var scb = new ScoreboardModel(contest.Id, teams, orgs, affs, probs, contest, RankingSolver.Select(contest));
var board = new FullBoardViewModel(scb, false)
{
FilteredAffiliations = args.FilteredAffiliations?.ToHashSet(),
FilteredCategories = args.FilteredCategories?.ToHashSet(),
};
logger.LogInformation("Data loaded.");
using var workbook = OpenXmlScoreboard.Create(board, contest.Name);
using var memoryStream = new MemoryStream();
workbook.SaveAs(memoryStream);
memoryStream.Position = 0;
await _files.SaveOutputAsync(job, memoryStream);
logger.LogInformation("Export succeeded.");
return(JobStatus.Finished);
}
public void GetScoreboard()
{
ScoreboardModel scoreboard = new ScoreboardModel();
}
public ScoreboardController()
{
view = new ScoreboardView(this);
model = new ScoreboardModel();
}
