public async Task <IActionResult> OnPostCreateAsync()
{
if (!await CheckModel(false))
{
if (await GetData(PostData.Metadata.Id))
{
return(Page());
}
else
{
return(NotFound());
}
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
ProblemMetadata pro = await client.CreateAsync(new API.Models.ProblemData
{
Description = PostData.Description,
Metadata = PostData.Metadata,
});
return(RedirectToPage(new { id = pro.Id }));
}
catch
{
return(NotFound());
}
}
public async Task <IActionResult> OnPostImportAsync()
{
if (!await CheckModel(true))
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
string sp = "";
using (Stream st = PostData.ImportFile.OpenReadStream())
using (StreamReader sr = new StreamReader(st))
sp = await sr.ReadToEndAsync();
ProblemPackage package = Newtonsoft.Json.JsonConvert.DeserializeObject <ProblemPackage>(sp);
package.Metadata.UserId = PostData.Metadata.UserId;
ProblemMetadata pro = await client.ImportAsync(package);
return(RedirectToPage(new { id = pro.Id }));
}
catch
{
return(NotFound());
}
}
public async Task <IActionResult> OnPostEditAsync()
{
if (!await CheckModel(false))
{
if (await GetData(PostData.Metadata.Id))
{
return(Page());
}
else
{
return(NotFound());
}
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
await client.UpdateMetadataAsync(PostData.Metadata.Id, PostData.Metadata);
await client.UpdateDescriptionAsync(PostData.Metadata.Id, PostData.Description);
return(RedirectToPage(new { id = PostData.Metadata.Id }));
}
catch
{
return(NotFound());
}
}
public async Task <IActionResult> OnPostDeleteTestAsync()
{
if ((await GetModifyAuthorization()) == false)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
await client.DeleteTestAsync(PostData.ProblemId, PostData.TestCaseId);
return(RedirectToPage(new { id = PostData.ProblemId }));
}
catch
{
return(NotFound());
}
}
public async Task <IActionResult> OnPostCreateSampleAsync()
{
if ((await GetModifyAuthorization()) == false)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
ShowId = PostData.TestCaseId;
if (await GetData(PostData.ProblemId))
{
return(Page());
}
else
{
return(NotFound());
}
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
TestCaseMetadata tmeta = await client.CreateSampleAsync(PostData.ProblemId, PostData.TestCase);
return(RedirectToPage(new { id = PostData.ProblemId, showId = tmeta.Id }));
}
catch
{
return(NotFound());
}
}
async Task <bool> GetData(string id)
{
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
ProblemMetadata metadata = await client.GetAsync(id);
Problem = await ProblemModel.GetAsync(metadata, httpclient, false, true);
}
catch
{
return(false);
}
TestCasePreviewModel emptyTestCase = new TestCasePreviewModel
{
Metadata = new TestCaseMetadata
{
Id = "empty",
TimeLimit = TimeSpan.FromSeconds(1),
MemoryLimit = 128 * MemoryValueHelper.MB,
},
IsNew = true,
};
{
List <TestCasePreviewModel> ls = new List <TestCasePreviewModel>();
foreach (TestCaseMetadata item in Problem.Samples)
{
ls.Add(new TestCasePreviewModel
{
Metadata = item,
Input = await client.GetSampleInputPreviewAsync(Problem.Metadata.Id, item.Id, MaxPreviewBytes),
Output = await client.GetSampleOutputPreviewAsync(Problem.Metadata.Id, item.Id, MaxPreviewBytes),
IsNew = false,
});
}
ls.Add(emptyTestCase);
SamplePreview = ls;
}
{
List <TestCasePreviewModel> ls = new List <TestCasePreviewModel>();
foreach (TestCaseMetadata item in Problem.Tests)
{
ls.Add(new TestCasePreviewModel
{
Metadata = item,
Input = await client.GetTestInputPreviewAsync(Problem.Metadata.Id, item.Id, MaxPreviewBytes),
Output = await client.GetTestOutputPreviewAsync(Problem.Metadata.Id, item.Id, MaxPreviewBytes),
});
}
ls.Add(emptyTestCase);
TestPreview = ls;
}
return(true);
}
public async Task <IActionResult> OnPostExportAsync()
{
if (!await GetModifyAuthorization())
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
Core.Problems.ProblemPackage package = await client.ExportAsync(PostData.Metadata.Id);
string str = Newtonsoft.Json.JsonConvert.SerializeObject(package);
return(File(Encoding.UTF8.GetBytes(str), "text/plain", $"{PostData.Metadata.Id}.json"));
}
catch
{
return(NotFound());
}
}
public async Task <IActionResult> OnPostInitializeAsync()
{
if ((await CanAdmin()) == false)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
WorkspaceClient client = new WorkspaceClient(httpclient);
await client.InitializeAsync();
UserMetadata rawUser = new UserMetadata {
Email = "admin@localhost", Name = "Admin"
};
await _userManager.CreateAsync(rawUser, "admin");
{
UsersClient ucli = new UsersClient(httpclient);
UserMetadata user = await ucli.GetByNameAsync(rawUser.NormalizedName);
ProblemsClient pcli = new ProblemsClient(httpclient);
await pcli.CreateAsync(Helpers.Problems.GetAPlusB(user.Id));
}
return(RedirectToPage());
}
public static async Task <SubmissionModel> GetAsync(SubmissionMetadata metadata, HttpClient client)
{
SubmissionModel res = new SubmissionModel
{
Metadata = metadata
};
try
{
SubmissionsClient scli = new SubmissionsClient(client);
res.Result = await scli.GetResultAsync(metadata.Id);
}
catch
{
res.Result = new SubmissionResult
{
State = JudgeState.Pending
};
}
try
{
SubmissionsClient scli = new SubmissionsClient(client);
using (FileResponse file = await scli.GetCodeAsync(metadata.Id))
using (StreamReader sr = new StreamReader(file.Stream))
res.Code = await sr.ReadToEndAsync();
}
catch
{
res.Code = "<Loading error>.";
}
try
{
ProblemsClient pcli = new ProblemsClient(client);
res.Problem = await pcli.GetAsync(metadata.ProblemId);
}
catch
{
res.Problem = new ProblemMetadata
{
Id = res.Metadata.ProblemId,
Name = $"Not found: {res.Metadata.ProblemId}"
};
}
try
{
UsersClient ucli = new UsersClient(client);
res.User = await ucli.GetAsync(metadata.UserId);
}
catch
{
res.User = new UserMetadata
{
Id = res.Metadata.UserId,
Name = $"Not found: {res.Metadata.UserId}"
};
}
return(res);
}
public async Task OnGetAsync()
{
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
IList <Core.Problems.ProblemMetadata> ms = await client.GetAllAsync();
List <ProblemModel> ss = new List <ProblemModel>();
foreach (Core.Problems.ProblemMetadata v in ms)
{
ss.Add(await ProblemModel.GetAsync(v, httpclient, false, false));
}
Problems = ss;
}
async Task <bool> GetData(string id)
{
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
ProblemMetadata metadata = await client.GetAsync(id);
Problem = await ProblemModel.GetAsync(metadata, httpclient, true, false);
}
catch
{
return(false);
}
return(true);
}
public async Task <IActionResult> OnPostDeleteAsync()
{
if (!await CheckModel(false))
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
await client.DeleteAsync(PostData.Metadata.Id);
return(RedirectToPage("/Problems/Index"));
}
catch
{
return(NotFound());
}
}
public async Task <IActionResult> OnPostQueryAsync()
{
try
{
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
List <Core.Problems.ProblemMetadata> ms = (await client.QueryAsync(PostData.QueryId, PostData.QueryUserId, PostData.QueryName, PostData.QuerySource)).ToList();
List <ProblemModel> ss = new List <ProblemModel>();
foreach (Core.Problems.ProblemMetadata v in ms)
{
ss.Add(await ProblemModel.GetAsync(v, httpclient, false, false));
}
Problems = ss;
}
catch
{
Problems = Array.Empty <ProblemModel>();
}
return(Page());
}
public async Task <IActionResult> OnPostTestOutputFileAsync()
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
FileResponse file = await client.GetTestOutputAsync(PostData.ProblemId, PostData.TestCaseId);
return(File(file.Stream, "text/plain", $"test{PostData.TestCaseId}.out"));
}
catch
{
return(NotFound());
}
}
public async Task <IActionResult> OnPostDeleteAsync()
{
if ((await _authorizationService.AuthorizeAsync(User, Authorizations.Administrator)).Succeeded == false)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
await client.DeleteAsync(PostData.Metadata.Id);
return(RedirectToPage("/Problems/Index"));
}
catch
{
return(NotFound());
}
}
public static async Task <ProblemModel> GetAsync(ProblemMetadata metadata, HttpClient client, bool loadDescription, bool loadData)
{
ProblemModel res = new ProblemModel
{
Metadata = metadata,
};
ProblemsClient pcli = new ProblemsClient(client);
{
try
{
StatisticsClient stcli = new StatisticsClient(client);
res.Statistics = await stcli.GetProblemAsync(metadata.Id);
}
catch
{
res.Statistics = null;
}
}
if (loadDescription)
{
try
{
res.Description = await pcli.GetDescriptionAsync(metadata.Id);
}
catch { }
}
if (loadData)
{
try
{
res.Samples = await pcli.GetSamplesAsync(metadata.Id);
}
catch
{
res.Samples = Array.Empty <TestCaseMetadata>();
}
try
{
res.Tests = await pcli.GetTestsAsync(metadata.Id);
}
catch
{
res.Tests = Array.Empty <TestCaseMetadata>();
}
}
{
UsersClient ucli = new UsersClient(client);
try
{
res.User = await ucli.GetAsync(metadata.UserId);
}
catch
{
res.User = null;
}
}
return(res);
}
public async Task <IActionResult> OnGetAsync(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
ProblemMetadata metadata = await client.GetAsync(id);
Problem = await ProblemModel.GetAsync(metadata, httpclient, true, true);
}
catch
{
return(NotFound());
}
List <TestCaseData> samples = new List <TestCaseData>();
foreach (TestCaseMetadata s in Problem.Samples)
{
Core.DataPreview input = await client.GetSampleInputPreviewAsync(id, s.Id, int.MaxValue);
Core.DataPreview output = await client.GetSampleOutputPreviewAsync(id, s.Id, int.MaxValue);
TestCaseData td = new TestCaseData
{
Metadata = s,
Input = input.Content,
Output = output.Content,
};
samples.Add(td);
}
SampleData = samples;
CurrentUser = await _userManager.GetUserAsync(User);
EnableCode = CurrentUser != null;
if (EnableCode)
{
StringBuilder res = new StringBuilder();
WorkspaceClient wclient = new WorkspaceClient(httpclient);
IList <ProgrammingLanguage> langs;
try
{
langs = await wclient.GetSupportLanguagesAsync();
}
catch
{
langs = Array.Empty <ProgrammingLanguage>();
}
if (langs.Count == 0)
{
EnableCode = false;
}
else
{
EnableCode = true;
foreach (ProgrammingLanguage item in langs)
{
string editorId = Helper.GetEditorLanguage(item);
if (editorId == "plaintext")
{
continue;
}
res.Append("{editorId: \"" + editorId + "\", ");
switch (item)
{
// editorId for editor, lang for enum, show for selector in html
case ProgrammingLanguage.C:
res.Append("lang: \"C\", show: \"C\"},");
break;
case ProgrammingLanguage.Cpp:
res.Append("lang: \"Cpp\", show: \"C++\"},");
break;
case ProgrammingLanguage.Java:
res.Append("lang: \"Java\", show: \"Java\"},");
break;
case ProgrammingLanguage.Python:
res.Append("lang: \"Python\", show: \"Python\"},");
break;
case ProgrammingLanguage.CSharp:
res.Append("lang: \"CSharp\", show: \"C#\"},");
break;
case ProgrammingLanguage.Rust:
res.Append("lang: \"Rust\", show: \"Rust\"},");
break;
case ProgrammingLanguage.VisualBasic:
res.Append("lang: \"VisualBasic\", show: \"Visual Basic\"},");
break;
case ProgrammingLanguage.Go:
res.Append("lang: \"Go\", show: \"Go\"},");
break;
case ProgrammingLanguage.Haskell:
res.Append("lang: \"Haskell\", show: \"Haskell\"},");
break;
case ProgrammingLanguage.Javascript:
res.Append("lang: \"Javascript\", show: \"Javascript\"},");
break;
case ProgrammingLanguage.Kotlin:
res.Append("lang: \"Kotlin\", show: \"Kotlin\"},");
break;
case ProgrammingLanguage.Php:
res.Append("lang: \"Php\", show: \"PHP\"},");
break;
case ProgrammingLanguage.Ruby:
res.Append("lang: \"Ruby\", show: \"Ruby\"},");
break;
case ProgrammingLanguage.Scala:
res.Append("lang: \"Scala\", show: \"Scala\"},");
break;
}
}
}
LanguageConfig = res.ToString();
}
return(Page());
}
