public Task <FeedbackDto> Run(SubmissionDto submissionDto)
{
var id = Thread.CurrentThread.ManagedThreadId;
using (var workspace = Factory.Workspace(Convert.ToString(id)))
{
var path = workspace.CreateDirectory();
var preprocess = Factory.Preprocessor(submissionDto.ApplicationMode);
if (preprocess.Preprocessing(submissionDto, path, out var workingDirectories, out var feedback))
{
var analysis = Factory.TestCaseAnalysis();
analysis.Run(submissionDto, ref workingDirectories, ref feedback);
var coverage = Factory.CoverageStats();
}
feedback.StudentId = submissionDto.SubmitterId;
feedback.SubmissionId = submissionDto.SubmissionId;
//var sender = Factory.FeedbackSender();
//Commented out for tests
//sender.SendFeedback(feedback);
return(Task.FromResult(feedback));
}
}
public void LearningMode_ShouldPass()
{
var submission = new SubmissionDto()
{
ApplicationMode = "Learning Mode",
TestCaseSolution = ConvertToZipByteArray(
"def test():\r\n" +
" assert \"a\" in \"abc\"\r\n",
"my_test.py"),
AssignmentSolution = null,
ReferenceSolution = ConvertToZipByteArray(
"def func():\r\n" +
" return 3"
, "solution.py"),
ReferenceTestSolution = ConvertToZipByteArray(
"def test():\r\n" +
" assert \"a\" in \"abc\"\r\n",
"my_test.py"),
SolutionFolderName = "Solution"
};
var preprocessor = Factory.Preprocessor(submission.ApplicationMode);
var result = preprocessor.Preprocessing(submission,
CurrentDirectory, out var workingDirectories,
out var feedback);
Assert.IsTrue(result);
Directory.Delete(Path.Combine(CurrentDirectory, "ReferenceTestSuit"), true);
Directory.Delete(Path.Combine(CurrentDirectory, "Solution"), true);
Directory.Delete(Path.Combine(CurrentDirectory, "StudentTestSuit"), true);
}
public void DevelopingModeNoReferenceTestSuit_ShouldFail()
{
var submission = new SubmissionDto()
{
ApplicationMode = "Development Mode",
TestCaseSolution = ConvertToZipByteArray(
"import sys\r\n" +
"sys.path.append('../Solution/')\r\n" +
"from solution import func\r\n" +
"def test():\r\n" +
" assert func() == 3\r\n",
"my_test.py"),
AssignmentSolution = ConvertToZipByteArray(
"def func():\r\n" +
" return 3"
, "solution.py"),
ReferenceSolution = ConvertToZipByteArray(
"def func():\r\n" +
" return 3"
, "solution.py"),
ReferenceTestSolution = null,
SolutionFolderName = "Solution"
};
var preprocessor = Factory.Preprocessor(submission.ApplicationMode);
var result = preprocessor.Preprocessing(submission,
CurrentDirectory, out var workingDirectories,
out var feedback);
Assert.IsFalse(result);
}
public void LearningModeNoReferenceTestSuit_ShouldFail()
{
var submission = new SubmissionDto()
{
ApplicationMode = "Learning Mode",
TestCaseSolution = ConvertToZipByteArray(
"def test():\r\n" +
" assert \"a\" in \"abc\"\r\n",
"my_test.py"),
ReferenceSolution = ConvertToZipByteArray(
"def func():\r\n" +
" return 3"
, "solution.py"),
ReferenceTestSolution = null,
SolutionFolderName = "Solution"
};
var preprocessor = Factory.Preprocessor(submission.ApplicationMode);
var result = preprocessor.Preprocessing(submission,
CurrentDirectory, out var workingDirectories,
out var feedback);
Assert.IsFalse(result);
}
public bool ValidateSubmission(SubmissionDto submissionDto, out FeedbackDto feedback)
{
feedback = new FeedbackDto();
if (submissionDto.TestCaseSolution == null)
{
feedback.Message = "Test Case Solution not provided";
return(false);
}
if (submissionDto.ReferenceTestSolution == null)
{
feedback.Message = "Reference Test Case Solution not provided";
return(false);
}
if (submissionDto.ReferenceSolution == null)
{
feedback.Message = "Reference Solution not provided";
return(false);
}
if (submissionDto.AssignmentSolution == null)
{
feedback.Message = "Student's Solution not provided";
return(false);
}
return(true);
}
public bool Preprocessing(SubmissionDto submissionDto, string directory, out EngineWorkingDirectories workingDirectories,
out FeedbackDto feedback)
{
workingDirectories = new EngineWorkingDirectories();
if (!ValidateSubmission(submissionDto, out feedback))
{
return(false);
}
var handler = Factory.FileHandler();
workingDirectories.ParentDirectory = directory;
workingDirectories.ReferenceTestSuit = Path.Combine(directory, "ReferenceTestSuit");
workingDirectories.Solution = Path.Combine(directory, submissionDto.SolutionFolderName);
workingDirectories.StudentTestSuit = Path.Combine(directory, "StudentTestSuit");
handler.UnzipByteArray(submissionDto.ReferenceTestSolution, directory,
workingDirectories.ReferenceTestSuit);
handler.UnzipByteArray(submissionDto.ReferenceSolution, directory,
workingDirectories.Solution);
handler.UnzipByteArray(submissionDto.TestCaseSolution, directory,
workingDirectories.StudentTestSuit);
return(true);
}
public void LearningModePassCase()
{
var InstructorBytes = File.ReadAllBytes(@"C:\Users\Admin\Desktop\ReferenceSolution.zip");
var StudentBytes = File.ReadAllBytes(@"C:\Users\Admin\Desktop\StudentSolution.zip");
var submission = new SubmissionDto()
{
ApplicationMode = "Learning Mode",
TestCaseSolution = ConvertToZipByteArray(@"C:\Users\Nate\Desktop\VSTT-Demo\TestBank\bin\Debug\TestBank.dll"
, "TestBank.dll"),
AssignmentSolution = ConvertToZipByteArray(@"C:\Users\Nate\Desktop\VSTT-Demo\Bank\bin\Debug\Bank.dll", "Bank.dll"
),
ReferenceSolution = ConvertToZipByteArray(@"C:\Users\Nate\Desktop\VSTT-Demo\TestBank\bin\Debug\TestBank.dll", "TestBank.dll"
),
ReferenceTestSolution = ConvertToZipByteArray(@"C:\Users\Nate\Desktop\VSTT-Demo\Bank\bin\Debug\Bank.dll", "Bank.dll"
),
SolutionFolderName = "Solution"
};
var preprocessor = Factory.Preprocessor(submission.ApplicationMode);
var result = preprocessor.Preprocessing(submission,
CurrentDirectory, out var workingDirectories,
out var feedback);
Assert.IsTrue(result);
Directory.Delete(Path.Combine(CurrentDirectory, "ReferenceTestSuit"), true);
Directory.Delete(Path.Combine(CurrentDirectory, "Solution"), true);
Directory.Delete(Path.Combine(CurrentDirectory, "StudentTestSuit"), true);
}
public async Task <ActionResult <SubmissionDto> > GetSubmission(int id)
{
int currentUserId = 0;
if (User.Identity.IsAuthenticated)
{
currentUserId = int.Parse(User.FindFirst(JwtRegisteredClaimNames.Sub).Value);
}
var submission = await _context.Submissions.SingleOrDefaultAsync(s => s.Id == id && (s.Task.IsPublic || s.Task.UserId == currentUserId));
if (submission == null)
{
return(NotFound());
}
await _context.Entry(submission).Reference(t => t.Task).LoadAsync();
await _context.Entry(submission).Reference(t => t.User).LoadAsync();
await _context.Entry(submission).Reference(t => t.ComputerLanguage).LoadAsync();
SubmissionDto dto = mapper.Map <SubmissionDto>(submission);
// Hide source code if submission somebody else's
if (currentUserId == 0 || dto.User.Id != currentUserId)
{
dto.SourceCode = "";
}
return(Ok(dto));
}
public void LearningModeWithSolutionsLessTests()
{
Engine = new Engine.CSharpEngine(Factory);
var refSolutionPath = Path.Combine(CurrentDirectory + "\\TestSolutions\\ReferenceSolution.zip");
var refTestSolutionPath = Path.Combine(CurrentDirectory + "\\TestSolutions\\ReferenceTestSolutionLessTests.zip");
var studentTestPath = Path.Combine(CurrentDirectory + "\\TestSolutions\\StudentTestSolutionLessTests.zip");
var InstructorSolutionBytes = File.ReadAllBytes(refSolutionPath);
var StudentTestBytes = File.ReadAllBytes(studentTestPath);
var InstructorTestSolutionBytes = File.ReadAllBytes(refTestSolutionPath);
var fileHandler = new FileHandler();
var newLocation = Path.Combine(CurrentDirectory, "ResultDir");
//Act
var submission = new SubmissionDto()
{
ApplicationMode = "Learning Mode",
TestCaseSolution = StudentTestBytes,
AssignmentSolution = null,
ReferenceSolution = InstructorSolutionBytes,
ReferenceTestSolution = InstructorTestSolutionBytes,
SolutionFolderName = "Solution"
};
var task = Engine.Run(submission);
Assert.IsTrue(task.IsCompleted);
}
public bool Preprocessing(SubmissionDto submissionDto, string directory, out EngineWorkingDirectories workingDirectories,
out FeedbackDto feedback)
{
workingDirectories = new EngineWorkingDirectories();
if (!ValidateSubmission(submissionDto, out feedback))
{
return(false);
}
var handler = Factory.FileHandler();
workingDirectories.ParentDirectory = directory;
workingDirectories.ReferenceTestSuit = Path.Combine(directory, "ReferenceTestSuit");
workingDirectories.Solution = Path.Combine(directory, Path.GetFileNameWithoutExtension(submissionDto.SolutionFolderName));
workingDirectories.StudentTestSuit = Path.Combine(directory, "StudentTestSuit");
handler.UnzipByteArray(submissionDto.ReferenceTestSolution, directory,
workingDirectories.ReferenceTestSuit);
handler.UnzipByteArray(submissionDto.AssignmentSolution, directory,
workingDirectories.Solution);
handler.UnzipByteArray(submissionDto.TestCaseSolution, directory,
workingDirectories.StudentTestSuit);
var exitCode = Factory.Pytest().Run(workingDirectories.StudentTestSuit, "$null", workingDirectories.StudentTestSuit);
if (exitCode != 0)
{
feedback.Message = "Student's solution didn't pass their own Test Suite";
return(false);
}
return(true);
}
public void LearningModeWithSolutions()
{
var InstructorBytes = File.ReadAllBytes(@"C:\Users\Admin\Desktop\ReferenceSolution.zip");
var StudentBytes = File.ReadAllBytes(@"C:\Users\Admin\Desktop\StudentSolution.zip");
var fileHandler = new FileHandler();
var newLocation = Path.Combine(CurrentDirectory, "ResultDir");
var submission = new SubmissionDto()
{
ApplicationMode = "Learning Mode",
TestCaseSolution = StudentBytes,
AssignmentSolution = StudentBytes,
ReferenceSolution = InstructorBytes,
ReferenceTestSolution = InstructorBytes,
SolutionFolderName = "Solution"
};
var preprocessor = Factory.Preprocessor(submission.ApplicationMode);
var result = preprocessor.Preprocessing(submission,
CurrentDirectory, out var workingDirectories,
out var feedback);
Assert.IsTrue(result);
Directory.Delete(Path.Combine(CurrentDirectory, "ReferenceTestSuit"), true);
Directory.Delete(Path.Combine(CurrentDirectory, "Solution"), true);
Directory.Delete(Path.Combine(CurrentDirectory, "StudentTestSuit"), true);
}
public void SaveSubmission(SubmissionDto submission)
{
var coreSubmission = _mapper.Map <Submission>(submission);
_unitOfWork.Submission.Create(coreSubmission);
_unitOfWork.Save();
}
public Task <FeedbackDto> Run(SubmissionDto submissionDto)
{
Count++;
Task.Delay(1000);
var feedbackDto = new FeedbackDto();
return(Task.FromResult(feedbackDto));
}
public void Post([FromBody] SubmissionDto value)
{
//if (value != null)
//{
// var task = Engine.Run(value);
// if (!task.IsCompleted) task.Start();
//}
}
public async Task SubmitJavaEngineJobAsync(string uri, SubmissionDto submissionDto)
{
var submissionXml = Serialize <SubmissionDto>(submissionDto);
var response = PostXMLData(uri, submissionXml);
//var response = await Client.PostAsXmlAsync(uri, submissionDto);
//return response.Headers.Location;
}
public Task <FeedbackDto> Run(SubmissionDto submissionDto)
{
_submission = Submission.MapFrom(submissionDto);
ModeEngineFactory.GetEngine(_submission).Run(out var feedbackDto);
feedbackDto.StudentId = submissionDto.SubmitterId;
feedbackDto.SubmissionId = submissionDto.SubmissionId;
return(Task.FromResult(feedbackDto));
}
public async Task <Uri> SubmitEngineJobAsync(string uri, SubmissionDto submissionDto)
{
//http://localhost:49829/
var response = await Client.PostAsJsonAsync(uri, submissionDto);
//var response = await Client.PostAsJsonAsync("http://localhost:49824/api/Submissions", submissionDto);
response.EnsureSuccessStatusCode();
return(response.Headers.Location);
}
public ActionResult Update([FromBody] SubmissionDto submissionDto)
{
var inspectionCenterDto = CustomSchemaHelper <InspectionCenterDto> .Deserialize(submissionDto.SubmissionJSON);
var inspectionCenter = _mapper.Map <InspectionCenter>(inspectionCenterDto);
_inspectionCenterManager.Update(inspectionCenter, submissionDto.SubmissionJSON);
return(Ok(new { result = "success" }));
}
public void Post([FromBody] SubmissionDto value)
{
if (value != null)
{
var task = Engine.Run(value);
if (!task.IsCompleted)
{
task.Start();
}
}
}
public ActionResult Add([FromBody] SubmissionDto submissionDto)
{
var res = "{\"name\":\"Imam Inspection Center 33\",\"refCode\":\"7\",\"inspectionCenterCoverages\":[{\"city\":\"\",\"district\":\"\",\"cityId\":1,\"districtId\":390,\"fieldsupportemail\":\"\",\"newData\":false}],\"test\":{\"city\":\"\",\"district\":\"\",\"cityId\":1,\"districtId\":392,\"fieldsupportemail\":\"\",\"newData\":false,\"newTest\":[{\"city\":\"\",\"district\":\"\",\"cityId\":1,\"districtId\":392,\"fieldsupportemail\":\"\",\"newData\":false}]},\"roleEmails\":[{\"role\":\"FieldSupporter\",\"roleEmail\":\"[email protected]\",\"newData\":false}],\"submit\":true}";
var typeObject = CustomSchemaHelper <InspectionCenterDto> .Deserialize(res);// JsonConvert.DeserializeObject<InspectionCenterDto>(res, new CustomJsonSchemaDeserializer());
var inspectionCenterDto = JsonUtils <InspectionCenterDto> .Deserialize(submissionDto.SubmissionJSON);
var inspectionCenter = _mapper.Map <InspectionCenter>(typeObject);
_inspectionCenterManager.Create(inspectionCenter, submissionDto.SubmissionJSON);
return(Ok(new { result = "success" }));
}
public void Submit(JavaEngine.Engine.JavaEngine engine, SubmissionDto submissionDto, string username)
{
try
{
var feedbackDtoResult = engine.Run(submissionDto);//BackgroundJob.Enqueue(() => _engine.Run(submissionDto));
var feedback = MapFeedbackDtoToFeedbackModel(feedbackDtoResult.Result);
int assignmentId;
using (var context = CreateDatabase())
{
context.Feedback.Add(feedback);
context.SaveChanges();
var submission = context.Submissions.Single(s => s.Id.Equals(submissionDto.SubmissionId));
submission.FeedbackId = feedback.Id;
context.SaveChanges();
assignmentId = submission.AssignmentId;
}
var hub = CreateHub();
if (SubmissionHub.Users.TryGetValue(username, out var user))
{
IList <string> cids;
lock (user.ConnectionIds)
{
cids = user.ConnectionIds.ToList();
}
int submissionIndex;
using (var context = CreateDatabase())
{
submissionIndex = context.Submissions.AsNoTracking()
.Count(s => s.SubmitterId.Equals(submissionDto.SubmitterId) && s.AssignmentId == assignmentId) - 1;
}
foreach (var cid in cids)
{
hub.Clients.Client(cid).SendAsync("FeedbackFinish", assignmentId, submissionIndex).Wait();
}
}
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
}
public static Submission MapFrom(SubmissionDto submissionDto)
{
return(new Submission
{
SubmitterId = submissionDto.SubmitterId,
SubmissionId = submissionDto.SubmissionId,
ApplicationMode = submissionDto.ApplicationMode,
ReferenceSolution = ZipUtilities.UnZipToMemory(submissionDto.ReferenceSolution),
ReferenceTestSolution = ZipUtilities.UnZipToMemory(submissionDto.ReferenceTestSolution),
PackageName = submissionDto.SolutionFolderName,
AssignmentSolution = ZipUtilities.UnZipToMemory(submissionDto.AssignmentSolution),
TestCaseSolution = ZipUtilities.UnZipToMemory(submissionDto.TestCaseSolution)
});
}
protected async Task <bool> SetSubmissionAsync(SubmissionDto submissionDto)
{
_logger.LogInformation("[Hangfire] Starting submission {submissionObjectId}", (long)submissionDto.SubmissionObjectId);
_submission = await _submissionRepo.GetSubmissionObjecForBackgroundJobAsync(submissionDto.SubmissionObjectId);
_submission.SubmissionStatusId = _statusService.FileInProgress;
_unitOfWork.Commit();
_submissionRows = new Dictionary <decimal, HmrSubmissionRow>();
_methodLogHeader = $"[Hangfire] Submission ({_submission.SubmissionObjectId}): ";
_enableMethodLog = _config.GetValue <string>("DISABLE_METHOD_LOGGER") != "Y"; //enabled by default
_serviceArea = await _serviceAreaService.GetServiceAreaByServiceAreaNumberAsyc(_submission.ServiceAreaNumber);
return(true);
}
public void Run(SubmissionDto submissionDto, ref EngineWorkingDirectories workingDirectories, ref FeedbackDto feedback)
{
var instructorTestSuit = CollectTestCases(workingDirectories.ReferenceTestSuit, workingDirectories.Solution, ref workingDirectories);
var studentTestSuit = CollectTestCases(workingDirectories.StudentTestSuit, workingDirectories.Solution, ref workingDirectories);
var coverDirectory = Path.Combine(workingDirectories.ParentDirectory, "CoverDirectory");
Directory.CreateDirectory(coverDirectory);
var tracer = new Tracer(EngineFactory);
var instructorTestCoverage = tracer.GetTestCoverage(workingDirectories.InstructorDllPath,
coverDirectory, instructorTestSuit);
var studentTestCoverage = tracer.GetTestCoverage(workingDirectories.StudentDllPath,
coverDirectory, studentTestSuit);
var comparator = EngineFactory.Comparator();
comparator.Compare(ref annotatedTests, ref instructorTestCoverage, ref studentTestCoverage,
ref feedback, workingDirectories);
}
public async Task <bool> ProcessSubmissionMain(SubmissionDto submissionDto)
{
try
{
return(await ProcessSubmission(submissionDto));
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
if (_submission != null)
{
((HmcrRepositoryBase <HmrSubmissionObject>)_submissionRepo).RollBackEntities();
_submission.ErrorDetail = FileError.UnknownException;
_submission.SubmissionStatusId = _statusService.FileUnexpectedError;
await CommitAndSendEmailAsync();
}
}
return(true);
}
private void TransmitToEngine(SubmissionDto submissionDto)
{
switch (Assignment.Language.Name)
{
case "Python":
//var pythonEngineResponse = client.SubmitEngineJobAsync("http://localhost:7591/api/Submissions", submissionDto);
throw new NotImplementedException();
//var pythonResult = new EngineSubmitter(new PythonEngine.Engine.PythonEngine(new EngineFactory(Directory.GetCurrentDirectory())),
// HttpContext.RequestServices.GetService<IAppDbContextFactory>()).Submit(submissionDto);
break;
case "Java":
//var javaEngineResponse = client.SubmitJavaEngineJobAsync("http://localhost:8080/JavaEngine/submit", submissionDto);
BackgroundJob.Enqueue <EngineSubmitter>(sub =>
sub.Submit(new JavaEngine.Engine.JavaEngine(), submissionDto, User.Identity.Name));
//_engineSubmitter.Submit(new JavaEngine.Engine.JavaEngine(), submissionDto);
break;
case "CSharp":
break;
}
}
public void GetStats(SubmissionDto submission, ref EngineWorkingDirectories workingDirectories, ref FeedbackDto feedback)
{
var pytestcov = _factory.PytestCov();
var filepath = Path.Combine(workingDirectories.ParentDirectory, "stats");
pytestcov.Run($"--cov-branch --cov={workingDirectories.Solution} .", filepath, workingDirectories.StudentTestSuit);
var file = File.ReadAllLines(filepath);
var found = false;
foreach (var line in file)
{
if (found)
{
if (!line.StartsWith('-') && !line.StartsWith('=') && !string.IsNullOrWhiteSpace(line))
{
var match = Regex.Match(line, @"(.+)(\s+)(\d+)(\s+)(\d+)(\s+)(\d+)(\s+)(\d+)(\s+)(\d+)(%)(\s*)");
if (match.Groups.Count == 14)
{
feedback.NumberOfStatements = int.Parse(match.Groups[3].Value);
feedback.NumberOfMissingStatements = int.Parse(match.Groups[5].Value);
feedback.NumberOfBranchesHit = int.Parse(match.Groups[7].Value);
feedback.CoveragePercentage = Convert.ToDouble(int.Parse(match.Groups[11].Value)) / 100.00f;
}
}
}
else
{
if (_coverageHeaderRegex.IsMatch(line))
{
found = true;
}
}
}
}
/// <summary>
/// Returns if it can continue to the next submission or not.
/// When it encounters a concurrency issue - when there are more than one job for the same submission,
/// one of them must stop and the return value indicates whether to stop or not.
/// </summary>
/// <param name="submissionDto"></param>
/// <returns></returns>
public override async Task <bool> ProcessSubmission(SubmissionDto submissionDto)
{
var errors = new Dictionary <string, List <string> >();
if (!await SetSubmissionAsync(submissionDto))
{
return(false);
}
var(untypedRows, headers) = ParseRowsUnTyped(errors);
//text after duplicate lines are removed. Will be used for importing to typed DTO.
var(rowCount, text) = await SetRowIdAndRemoveDuplicate(untypedRows, headers);
if (rowCount == 0)
{
errors.AddItem("File", "No new records were found in the file; all records were already processed in the past submission.");
_submission.ErrorDetail = errors.GetErrorDetail();
_submission.SubmissionStatusId = _statusService.FileDuplicate;
await CommitAndSendEmailAsync();
return(true);
}
foreach (var untypedRow in untypedRows)
{
errors = new Dictionary <string, List <string> >();
var submissionRow = _submissionRows[(decimal)untypedRow.RowNum];
submissionRow.RowStatusId = _statusService.RowSuccess; //set the initial row status as success
var entityName = GetValidationEntityName(untypedRow);
_validator.Validate(entityName, untypedRow, errors);
if (errors.Count > 0)
{
SetErrorDetail(submissionRow, errors, _statusService.FileBasicError);
}
}
var typedRows = new List <RockfallReportTyped>();
if (_submission.SubmissionStatusId == _statusService.FileInProgress)
{
var(rowNum, rows) = ParseRowsTyped(text, errors);
if (rowNum != 0)
{
var submissionRow = _submissionRows[rowNum];
SetErrorDetail(submissionRow, errors, _statusService.FileConflictionError);
await CommitAndSendEmailAsync();
return(true);
}
typedRows = rows;
CopyCalculatedFieldsFormUntypedRow(typedRows, untypedRows);
PerformAdditionalValidation(typedRows);
}
if (_submission.SubmissionStatusId != _statusService.FileInProgress)
{
await CommitAndSendEmailAsync();
return(true);
}
var rockfallReports = PerformSpatialValidationAndConversionBatchAsync(typedRows);
_logger.LogInformation($"{_methodLogHeader} PerformSpatialValidationAndConversionAsync 100%");
if (_submission.SubmissionStatusId != _statusService.FileInProgress)
{
await CommitAndSendEmailAsync();
return(true);
}
_submission.SubmissionStatusId = _statusService.FileSuccess;
await foreach (var entity in _rockfallReportRepo.SaveRockfallReportAsnyc(_submission, rockfallReports))
{
}
await CommitAndSendEmailAsync();
return(true);
}
public async Task <ActionResult <SubmissionDto> > PostSubmission(int taskId, [FromBody] SubmissionDto submissionDto)
{
int currentUserId = int.Parse(User.FindFirst(JwtRegisteredClaimNames.Sub).Value);
// Get task info
Entities.Task task = await _context.Tasks.SingleOrDefaultAsync(t => t.Id == taskId && (t.IsPublic || t.UserId == currentUserId));
if (task == null)
{
return(BadRequest());
}
// Get language info
ComputerLanguage lang = await _context.ComputerLanguages.FindAsync(submissionDto.LangId);
if (lang == null)
{
return(BadRequest());
}
// Get test cases
await _context.Entry(task).Collection(t => t.TestCases).LoadAsync();
Submission submission = new Submission
{
SourceCode = submissionDto.SourceCode,
LangId = submissionDto.LangId,
UserId = currentUserId,
TimeSubmitted = DateTime.Now,
TaskId = taskId,
Status = "UD",
ExecutionTime = 0,
ExecutionMemory = 0,
};
// Save initial submission to DB to get a unique id
_context.Submissions.Add(submission);
await _context.SaveChangesAsync();
string executionRootDir = Grader.GetExecutionRootDir();
string sourceFileName = $"{submission.Id}.{lang.Extension}";
string binaryFileName = submission.Id.ToString();
string sourceFilePath = $"{executionRootDir}{sourceFileName}";
string binaryFilePath = $"{executionRootDir}{binaryFileName}";
// Create file from source code inside rootDir
System.IO.File.WriteAllText(sourceFilePath, submissionDto.SourceCode);
bool readyToRun = true;
// Check if compiled language
if (!string.IsNullOrEmpty(lang.CompileCmd))
{
// Compile submission
CompilationOutputDto co = Grader.Compile(lang, sourceFileName, binaryFileName);
if (co.ExitCode != 0)
{
// Compile error
submission.Status = "CE"; // Mark status as Compile Error
submissionDto.Message = co.Error; // Set message as compile error message
readyToRun = false;
}
}
if (readyToRun)
{
// Compiled successfully or interpreted language, so we're ready to run the solution
submission.Status = "AC"; // Submission status will stay accepted if all test cases pass (or if there aren't any TCs)
string fileName = string.IsNullOrEmpty(lang.CompileCmd) ? sourceFileName : binaryFileName;
int maxTimeMs = 0; // Track max execution time of test cases
int maxMemoryB = 0; // Track max execution memory of test cases
bool correctSoFar = true;
for (int i = 0; correctSoFar && i < task.TestCases.Count; ++i)
{
TestCase tc = task.TestCases.ElementAt(i);
GradeDto grade = Grader.Grade(lang, fileName, tc.Input, tc.Output, task.TimeLimit, task.MemoryLimit);
maxTimeMs = Math.Max(maxTimeMs, grade.ExecutionTime);
maxMemoryB = Math.Max(maxMemoryB, grade.ExecutionMemory);
submission.Status = grade.Status;
correctSoFar = grade.Status.Equals("AC");
}
submission.ExecutionTime = maxTimeMs; // Set submission execution time as max out of all test cases
submission.ExecutionMemory = maxMemoryB; // Set submission execution memory as max out of all test cases
// Delete binary file if compiled
if (!string.IsNullOrEmpty(lang.CompileCmd))
{
System.IO.File.Delete(binaryFilePath);
}
}
// Edit submission object status and stats
await _context.SaveChangesAsync();
// Delete source file
System.IO.File.Delete(sourceFilePath);
// Prepare response DTO
SubmissionDto responseDto = mapper.Map <SubmissionDto>(submission);
responseDto.Message = submissionDto.Message;
responseDto.Task = null;
responseDto.ComputerLanguage = null;
responseDto.User = null;
return(CreatedAtAction("GetSubmission", new { id = submission.Id }, responseDto));
}
public virtual Task <bool> ProcessSubmission(SubmissionDto submissionDto)
{
throw new NotImplementedException();
}
