public async Task <IActionResult> CreateExerciseSubmissionAsync([FromServices] IExerciseService exerciseService, int labId, int slotId, int exerciseId, int userId, DateTime submissionTime, bool passed, int weight)
{
try
{
// Create submission
var submission = new ExerciseSubmission
{
ExerciseId = exerciseId,
UserId = userId,
ExercisePassed = passed,
SubmissionTime = submissionTime,
Weight = passed ? 1 : weight
};
await exerciseService.CreateExerciseSubmissionAsync(submission, HttpContext.RequestAborted);
AddStatusMessage(_localizer["CreateExerciseSubmissionAsync:Success"], StatusMessageTypes.Success);
}
catch (InvalidOperationException ex)
{
_logger.LogError(ex, "Create exercise submission");
AddStatusMessage(_localizer["CreateExerciseSubmissionAsync:UnknownError"], StatusMessageTypes.Error);
}
return(await RenderAsync(labId, slotId));
}
public async Task <IActionResult> UploadExercise2(List <IFormFile> files, int?activityId)
{
if (activityId == null)
{
return(NotFound());
}
var activity
= await _context.CourseActivity
.Include(a => a.Module)
.ThenInclude(m => m.Course)
.FirstOrDefaultAsync(a => a.Id == activityId);
var user = await _userManager.Users.FirstOrDefaultAsync(u => u.UserName == User.Identity.Name);
// We handle only one file at a time, so this foreach should not be needed.
// Maybe just take the first item in the list.
// Maybe change the .cshtml so that it does not return a list.
string fileName = "";
foreach (var formFile in files)
{
if (formFile.Length > 0)
{
string[] splitFileName = formFile.FileName.Split('.');
string fileExtension = splitFileName[splitFileName.Length - 1];
fileName = "a" + activity.Id + "u" + user.Id + "." + fileExtension;
using (var stream = new FileStream("wwwroot/Exercises/" + fileName, FileMode.Create))
{
await formFile.CopyToAsync(stream);
}
}
// Need to check that file was created OK.
}
var docRec = new ExerciseSubmission()
{
FileName = fileName,
SubmissionTime = DateTime.Now,
ApplicationUserId = user.Id,
CourseActivityId = activity.Id
};
_context.ExerciseSubmission.Add(docRec);
_context.SaveChanges();
return(RedirectToAction("DetailsForStudent", new { id = activity.Id }));
}
public async Task <ExerciseSubmission> CreateExerciseSubmissionAsync(ExerciseSubmission submission, CancellationToken cancellationToken)
{
// Create new submission
var submissionEntity = _dbContext.ExerciseSubmissions.Add(new ExerciseSubmissionEntity
{
ExerciseId = submission.ExerciseId,
ExercisePassed = submission.ExercisePassed,
UserId = submission.UserId,
SubmissionTime = submission.SubmissionTime,
Weight = submission.Weight
}).Entity;
// Apply changes
await _dbContext.SaveChangesAsync(cancellationToken);
return(_mapper.Map <ExerciseSubmission>(submissionEntity));
}
public async Task <IActionResult> CreateExerciseSubmissionAsync(CtfApiRequest request)
{
try
{
// Resolve lab
var lab = await _labService.GetLabAsync(request.LabId, HttpContext.RequestAborted);
if (lab == null)
{
return(BadRequest(new { error = $"Could not resolve requested lab {request.LabId}" }));
}
// Decode request
var apiExerciseSubmission = request.Decode <ApiExerciseSubmission>(new CryptoService(lab.ApiCode));
// Resolve exercise
var exercise = await _exerciseService.FindExerciseAsync(lab.Id, apiExerciseSubmission.ExerciseNumber, HttpContext.RequestAborted);
if (exercise == null)
{
return(NotFound(new { error = "Exercise not found" }));
}
// Check lab execution
// This will also automatically check whether the given user exists
var labExecution = await _labExecutionService.GetLabExecutionForUserAsync(apiExerciseSubmission.UserId, lab.Id, HttpContext.RequestAborted);
var now = DateTime.Now;
if (labExecution == null || now < labExecution.PreStart)
{
return(NotFound(new { error = "Lab is not active for this user" }));
}
// Some exercises may only be submitted after the pre-start phase has ended
if (!exercise.IsPreStartAvailable && now < labExecution.Start)
{
return(NotFound(new { error = "This exercise may not be submitted in the pre-start phase" }));
}
// Create submission
var submission = new ExerciseSubmission
{
ExerciseId = exercise.Id,
UserId = apiExerciseSubmission.UserId,
ExercisePassed = apiExerciseSubmission.ExercisePassed,
SubmissionTime = apiExerciseSubmission.SubmissionTime ?? DateTime.Now,
Weight = apiExerciseSubmission.ExercisePassed ? 1 : (apiExerciseSubmission.Weight >= 0 ? apiExerciseSubmission.Weight : 1)
};
await _exerciseService.CreateExerciseSubmissionAsync(submission, HttpContext.RequestAborted);
return(Ok());
}
catch (CryptographicException ex)
{
_logger.LogError(ex, "Create exercise submission for user");
return(StatusCode(StatusCodes.Status401Unauthorized, new { error = "Could not decode the request packet" }));
}
catch (Exception ex)
{
_logger.LogError(ex, "Create exercise submission for user");
return(StatusCode(StatusCodes.Status500InternalServerError, new { error = "An internal error occured during processing of the request" }));
}
}
