public async Task Reject(DbContext db, JudgingFinishedRequest args)
{
bool showPublic = !args.Frozen;
double time = (args.SubmitTime - args.ContestTime).TotalSeconds;
int time2 = (int)(time / 60);
int score = args.TotalScore;
bool fullScore = args.Verdict == Verdict.Accepted;
bool isCorrect = fullScore || args.TotalScore > 0;
// 反向操作
var oldScoreQuery = db.Score(args.ContestId, args.ProblemId, args.TeamId)
.Select(sc => new { sc.ContestId, sc.TeamId, Delta = score - (sc.ScoreRestricted ?? 0) });
await db.Set <RankCache>().MergeAsync(
sourceTable: oldScoreQuery,
targetKey: args => new { args.ContestId, args.TeamId },
sourceKey: args => new { args.ContestId, args.TeamId },
delete: false,
updateExpression: (rc, dt) => new RankCache
{
PointsRestricted = rc.PointsRestricted + dt.Delta,
TotalTimeRestricted = time2,
PointsPublic = showPublic ? rc.PointsPublic + dt.Delta : rc.PointsPublic,
TotalTimePublic = showPublic ? time2 : rc.TotalTimePublic,
},
insertExpression: dt => new RankCache
{
ContestId = dt.ContestId,
TeamId = dt.TeamId,
PointsRestricted = dt.Delta,
TotalTimeRestricted = time2,
PointsPublic = showPublic ? dt.Delta : 0,
TotalTimePublic = showPublic ? time2 : 0,
});
await db.Score(args.ContestId, args.ProblemId, args.TeamId)
.BatchUpdateAsync(sc => new ScoreCache
{
ScoreRestricted = score,
SolveTimeRestricted = time,
IsCorrectRestricted = isCorrect,
PendingRestricted = sc.PendingRestricted - 1,
SubmissionRestricted = sc.SubmissionRestricted + 1,
ScorePublic = showPublic ? score : sc.ScorePublic,
SolveTimePublic = showPublic ? time : sc.SolveTimePublic,
IsCorrectPublic = showPublic ? isCorrect : sc.IsCorrectPublic,
PendingPublic = showPublic ? sc.PendingPublic - 1 : sc.PendingPublic,
SubmissionPublic = showPublic ? sc.SubmissionPublic + 1 : sc.SubmissionPublic,
FirstToSolve = fullScore,
});
}
public Task CompileError(DbContext db, JudgingFinishedRequest args)
{
return(db.Score(args.ContestId, args.ProblemId, args.TeamId)
.Where(s => s.PendingRestricted > 0)
.BatchUpdateAsync(s => new ScoreCache
{
PendingRestricted = s.PendingRestricted - 1,
}));
}
public Task CompileError(DbContext db, JudgingFinishedRequest args)
{
bool showPublic = !args.Frozen;
return(db.Score(args.ContestId, args.ProblemId, args.TeamId)
.BatchUpdateAsync(s => new ScoreCache
{
PendingPublic = showPublic ? s.PendingPublic - 1 : s.PendingPublic,
PendingRestricted = s.PendingRestricted - 1,
}));
}
public Task Reject(DbContext db, JudgingFinishedRequest args)
{
// 在这种情况下，是系统终测时测了某个Accepted提交
// 我们规定 System Test 是由某个 Rejudging 关联的，但是处于 Active 状态的 Rejudging。
bool fst = args.Judging.Active && args.Judging.RejudgeId.HasValue;
return(db.Score(args.ContestId, args.ProblemId, args.TeamId)
.BatchUpdateAsync(t => new ScoreCache
{
SubmissionRestricted = t.SubmissionRestricted + 1,
SubmissionPublic = t.IsCorrectPublic ? t.SubmissionPublic : t.SubmissionPublic + 1,
FirstToSolve = fst,
}));
}
public Task Reject(DbContext db, JudgingFinishedRequest args)
{
bool showPublic = !args.Frozen;
int publicDelta = args.Frozen ? 0 : 1;
return(db.Score(args.ContestId, args.ProblemId, args.TeamId)
.Where(s => s.PendingRestricted > 0)
.BatchUpdateAsync(s => new ScoreCache
{
PendingPublic = showPublic ? s.PendingPublic - 1 : s.PendingPublic,
SubmissionPublic = showPublic ? s.SubmissionPublic + 1 : s.SubmissionPublic,
PendingRestricted = s.PendingRestricted - 1,
SubmissionRestricted = s.SubmissionRestricted + 1,
}));
}
public async Task Accept(DbContext db, JudgingFinishedRequest args)
{
double time = (args.SubmitTime - args.ContestTime).TotalSeconds;
int timee = (int)(time / 60);
int minScore = args.CfScore * 3 / 10, rateScore = args.CfScore - timee * (args.CfScore / 250);
var oldScoreQuery = db.Score(args.ContestId, args.ProblemId, args.TeamId)
.Select(old => new
{
old.ContestId,
old.TeamId,
OldScore = old.ScorePublic ?? 0,
NewScore = minScore > rateScore - old.SubmissionRestricted * 50 ? minScore : rateScore - old.SubmissionRestricted * 50,
});
await db.Set <RankCache>().MergeAsync(
sourceTable: oldScoreQuery,
targetKey: rc => new { rc.ContestId, rc.TeamId },
sourceKey: rc => new { rc.ContestId, rc.TeamId },
delete: false,
updateExpression: (r, s) => new RankCache
{
PointsPublic = r.PointsPublic - s.OldScore + s.NewScore,
TotalTimePublic = timee,
},
insertExpression: s => new RankCache
{
ContestId = s.ContestId,
TeamId = s.TeamId,
PointsPublic = s.NewScore,
TotalTimePublic = timee,
});
await db.Score(args.ContestId, args.ProblemId, args.TeamId)
.BatchUpdateAsync(old => new ScoreCache
{
SubmissionRestricted = old.SubmissionRestricted + 1,
PendingRestricted = old.PendingRestricted - 1,
ScorePublic = minScore > rateScore - old.SubmissionRestricted * 50 ? minScore : rateScore - old.SubmissionRestricted * 50,
IsCorrectPublic = true,
SolveTimePublic = time,
SubmissionPublic = old.SubmissionRestricted + 1,
});
}
public Task Accept(DbContext db, JudgingFinishedRequest args)
{
return(Reject(db, args));
}
public async Task Accept(DbContext db, JudgingFinishedRequest args)
{
// first blood：此处竞态条件可以暂时无视？
var fbQuery =
from sc in db.Set <ScoreCache>()
where sc.ContestId == args.ContestId && sc.ProblemId == args.ProblemId && sc.FirstToSolve
join t in db.Set <Team>() on new { sc.ContestId, sc.TeamId } equals new { t.ContestId, t.TeamId }
join c in db.Set <TeamCategory>() on t.CategoryId equals c.CategoryId
where (from t in db.Set <Team>()
where t.ContestId == args.ContestId && t.TeamId == args.TeamId
join c in db.Set <TeamCategory>() on t.CategoryId equals c.CategoryId
select c.SortOrder).Contains(c.SortOrder)
select t.TeamId;
bool firstBlood = !await fbQuery.AnyAsync();
double time = (args.SubmitTime - args.ContestTime).TotalSeconds;
int score = time < 0 ? -(((int)-time) / 60) : ((int)time) / 60;
bool showPublic = !args.Frozen;
int affectedRows = await db.Score(args.ContestId, args.ProblemId, args.TeamId)
.Where(s => s.PendingRestricted > 0)
.BatchUpdateAsync(s => new ScoreCache
{
PendingPublic = showPublic ? s.PendingPublic - 1 : s.PendingPublic,
SubmissionPublic = showPublic ? s.SubmissionPublic + 1 : s.SubmissionPublic,
ScorePublic = showPublic ? score : (int?)null,
SolveTimePublic = showPublic ? time : 0,
IsCorrectPublic = showPublic,
PendingRestricted = s.PendingRestricted - 1,
SubmissionRestricted = s.SubmissionRestricted + 1,
ScoreRestricted = score,
SolveTimeRestricted = time,
IsCorrectRestricted = true,
FirstToSolve = firstBlood,
});
if (affectedRows == 0)
{
return;
}
// 将此处罚时计算交给数据库，减少数据拉取量
var updateRankQuery = db.Score(args.ContestId, args.ProblemId, args.TeamId)
.Select(sc => new
{
sc.ContestId, sc.TeamId,
Penalty = score + 20 * (sc.SubmissionRestricted - 1)
});
await db.Set <RankCache>().MergeAsync(
sourceTable: updateRankQuery,
targetKey: rc => new { rc.ContestId, rc.TeamId },
sourceKey: rc => new { rc.ContestId, rc.TeamId },
delete: false,
updateExpression: (r, s) => new RankCache
{
PointsRestricted = r.PointsRestricted + 1,
TotalTimeRestricted = r.TotalTimeRestricted + s.Penalty,
PointsPublic = showPublic ? r.PointsPublic + 1 : r.PointsPublic,
TotalTimePublic = showPublic ? r.TotalTimePublic + s.Penalty : r.TotalTimePublic,
},
insertExpression: s => new RankCache
{
ContestId = s.ContestId,
TeamId = s.TeamId,
PointsRestricted = 1,
TotalTimeRestricted = s.Penalty,
PointsPublic = showPublic ? 1 : 0,
TotalTimePublic = showPublic ? s.Penalty : 0,
});
}
