public async Task <int> CascadeDeleteAsync(Testcase testcase)
{
using var tran = await Context.Database.BeginTransactionAsync();
int dts;
try
{
// details are set ON DELETE NO ACTION, so we have to delete it before
dts = await Context.Set <Detail>()
.Where(d => d.TestcaseId == testcase.TestcaseId)
.BatchDeleteAsync();
await Testcases
.Where(t => t.TestcaseId == testcase.TestcaseId)
.BatchDeleteAsync();
// set the rest testcases correct rank
await Testcases
.Where(t => t.Rank > testcase.Rank && t.ProblemId == testcase.ProblemId)
.BatchUpdateAsync(t => new Testcase {
Rank = t.Rank - 1
});
await tran.CommitAsync();
}
catch
{
dts = -1;
}
return(dts);
}
public async Task <ActionResult <string> > File(int id, string type)
{
if (type == "input")
{
type = "in";
}
else if (type == "output")
{
type = "out";
}
else
{
return(BadRequest());
}
var tc = await Testcases.FindAsync(id);
if (tc is null)
{
return(NotFound());
}
var fileInfo = Testcases.GetFile(tc, type);
if (!fileInfo.Exists)
{
return(NotFound());
}
// return Convert.ToBase64String(
// await fileInfo.ReadBinaryAsync());
return(new Base64StreamResult(fileInfo));
}
public Task <int> BatchScoreAsync(int pid, int lower, int upper, int score)
{
return(Testcases
.Where(t => t.ProblemId == pid && t.Rank >= lower && t.Rank <= upper)
.BatchUpdateAsync(t => new Testcase {
Point = score
}));
}
public Task <List <Testcase> > ListAsync(int pid, bool?secret)
{
var query = Testcases.Where(t => t.ProblemId == pid);
if (secret.HasValue)
{
query = query.Where(t => t.IsSecret == secret.Value);
}
query = query.OrderBy(t => t.Rank);
return(query.ToListAsync());
}
private void CreateDefaultConfig()
{
string[] subDir = Directory.GetDirectories(Path.Combine(ParentDirectory, ProblemName));
Testcases.Clear();
for (int i = 0; i < subDir.Length; ++i)
{
Testcases.Add(new Testcase()
{
TestcaseName = Path.GetFileName(subDir[i]),
Point = 1.0
});
}
Input = ProblemName + ".INP";
Output = ProblemName + ".OUT";
SaveConfig();
}
public async Task ChangeRankAsync(int pid, int tid, bool up)
{
var tc = await Testcases
.Where(t => t.ProblemId == pid && t.TestcaseId == tid)
.FirstOrDefaultAsync();
if (tc == null)
{
return;
}
int rk2 = tc.Rank + (up ? -1 : 1);
var tc2 = await Testcases
.Where(t => t.ProblemId == pid && t.Rank == rk2)
.FirstOrDefaultAsync();
if (tc2 != null)
{
var tcid1 = tc.TestcaseId;
var tcid2 = tc2.TestcaseId;
var rk1 = tc.Rank;
await Testcases
.Where(t => t.TestcaseId == tcid1)
.BatchUpdateAsync(t => new Testcase {
Rank = -1
});
await Testcases
.Where(t => t.TestcaseId == tcid2)
.BatchUpdateAsync(t => new Testcase {
Rank = rk1
});
await Testcases
.Where(t => t.TestcaseId == tcid1)
.BatchUpdateAsync(t => new Testcase {
Rank = rk2
});
}
}
public async ValueTask <(Stream stream, string mime, string fileName)> ExportAsync(Problem problem)
{
var testc = await Testcases.ListAsync(problem.ProblemId);
var execs = new List <Executable>();
if (problem.CompareScript != "compare")
{
execs.Add(await Executables.FindAsync(problem.CompareScript));
}
if (problem.RunScript != "run")
{
execs.Add(await Executables.FindAsync(problem.RunScript));
}
var subs = await Submissions.ListAsync(
predicate : s => s.ProblemId == problem.ProblemId && s.ExpectedResult != null,
projection : s => new ExportSubmission
{
ExpectedResult = s.ExpectedResult,
SourceCode = s.SourceCode,
SubmissionId = s.SubmissionId,
FileExtension = s.l.FileExtension
});
var memStream = new MemoryStream();
using (var zip = new ZipArchive(memStream, ZipArchiveMode.Create, true))
{
foreach (var tc in testc)
{
await AttachTestcase(zip, problem, tc);
}
foreach (var sub in subs)
{
await AttachSubmission(zip, sub);
}
foreach (var st in IProblemStore.MarkdownFiles)
{
await AttachMarkdownFile(zip, problem, st);
}
foreach (var exec in execs)
{
await AttachExecutable(zip, problem.ProblemId, exec);
}
var sb = new StringBuilder();
sb.AppendLine("name: " + problem.Title);
if (!string.IsNullOrEmpty(problem.Source))
{
sb.AppendLine("source: " + problem.Source);
}
sb.AppendLine();
sb.AppendLine("limits:");
sb.AppendLine(" time: " + (problem.TimeLimit / 1000.0));
sb.AppendLine(" memory: " + (problem.MemoryLimit / 1024));
if (problem.OutputLimit != 4096)
{
sb.AppendLine(" output: " + (problem.OutputLimit / 1024));
}
sb.AppendLine();
if (!string.IsNullOrEmpty(problem.ComapreArguments))
{
sb.AppendLine("validator_flags: " + problem.ComapreArguments);
}
if (problem.RunScript != "run")
{
sb.AppendLine("validation: custom interactive");
}
else if (problem.CompareScript != "compare")
{
sb.AppendLine("validation: custom");
}
zip.CreateEntryFromString(sb.ToString(), "problem.yaml");
zip.CreateEntryFromString(
content: $"timelimit = {problem.TimeLimit / 1000.0}\n",
entry: "domjudge-problem.ini");
}
memStream.Position = 0;
return(memStream, "application/zip", $"p{problem.ProblemId}.zip");
}
public Task <Testcase> FindAsync(int pid, int tid)
{
return(Testcases
.Where(t => t.ProblemId == pid && t.TestcaseId == tid)
.SingleOrDefaultAsync());
}
public Task <Testcase> FindAsync(int tid)
{
return(Testcases.SingleOrDefaultAsync(t => t.TestcaseId == tid));
}
public Task <int> CountAsync(int pid)
{
return(Testcases.CountAsync(p => p.ProblemId == pid));
}
