public async Task <IActionResult> PutStudyDomain(Guid id, StudyDomainDTO studyDomain)
{
if (id != studyDomain.Id)
{
return(BadRequest());
}
var domain = courseMapper.MapStudyDomainDTO(studyDomain);
_context.Entry(domain).State = EntityState.Modified;
try {
await _context.SaveChangesAsync();
} catch (DbUpdateConcurrencyException) {
if (!StudyDomainExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutAcademicYear(Guid id, AcademicYearDTO academicYear)
{
if (id != academicYear.Id)
{
return(BadRequest());
}
var year = courseMapper.MapYearDTO(academicYear);
_context.Entry(year).State = EntityState.Modified;
try {
await _context.SaveChangesAsync();
} catch (DbUpdateConcurrencyException) {
if (!AcademicYearExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PostSubmitTask(CreateTaskSubmissionRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var studentTask = await _context.StudentAssignedTasks
.FirstOrDefaultAsync(st => st.Id == request.StudentTaskId);
if (studentTask is null)
{
return(NotFound());
}
if (studentTask.StudentId != userManager.GetUserId(User))
{
return(Forbid());
}
var submission = new TaskSubmission {
AssignedTaskId = studentTask.Id,
State = TaskSubmissionState.Submitted,
DateAdded = DateTime.Now,
Files = new List <TaskSubmissionFile>(),
Description = request.Description
};
_context.TaskSubmissions.Add(submission);
await _context.SaveChangesAsync();
foreach (var uploadedFile in request.UploadedFiles)
{
var submissionFolder = $"StudentSubmissions/{studentTask.StudentId}/{studentTask.Id}/{submission.Id}";
// TODO: validate file extension.
var(fileName, extension) = FilesHelpers.GetFileNameAndExtension(uploadedFile.OriginalName);
var file = await fileService.MoveTempFile(uploadedFile.TempFileName, submissionFolder, uploadedFile.OriginalName);
submission.Files.Add(new TaskSubmissionFile {
FileId = file.Id,
FileType = TaskSubmissionFileType.SourceCode,
TaskSubmission = submission
});
}
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> PutGroup(Guid id, GroupDTO group)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != group.Id)
{
return(BadRequest());
}
var domain = await _context.StudyDomains.FirstOrDefaultAsync(sd => sd.Id == group.Domain);
if (domain is null)
{
ModelState.AddModelError("domain", "Invalid domain id.");
return(BadRequest(ModelState));
}
var year = await _context.AcademicYears.FirstOrDefaultAsync(y => y.Id == group.Year);
if (year is null)
{
ModelState.AddModelError("year", "Invalid year id.");
return(BadRequest(ModelState));
}
var dbGroup = courseMapper.MapGroupDTO(group, domain, year);
_context.Entry(dbGroup).State = EntityState.Modified;
try {
await _context.SaveChangesAsync();
} catch (DbUpdateConcurrencyException) {
if (!GroupExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCourseDefinition(Guid id, CourseDefinitionDTO courseDefinition)
{
if (id != courseDefinition.Id)
{
return(BadRequest());
}
var year = await _context.AcademicYears.FirstAsync(y => y.Id == courseDefinition.Year);
if (year is null)
{
ModelState.AddModelError("year", "Invalid course year provided.");
return(BadRequest(ModelState));
}
var courseDef = courseMapper.MapDefinitionDTO(courseDefinition, year);
courseDef.Slug = slugService.TransformText(courseDef.Name);
var existingDef = await _context.CourseDefinitions.FirstOrDefaultAsync(c => c.Id != courseDef.Id && c.Slug == courseDef.Slug);
if (!(existingDef is null))
{
ModelState.AddModelError("name", $"Failed to generate unique url slug from the course name. The generated slug ({courseDef.Slug}) is used by another course.");
return(BadRequest(ModelState));
}
_context.Entry(courseDef).State = EntityState.Modified;
try {
await _context.SaveChangesAsync();
await cache.ClearCourseDefinitionCacheAsync(id);
} catch (DbUpdateConcurrencyException) {
if (!CourseDefinitionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCourse(Guid id, CourseEditDTO course)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != course.Id)
{
return(BadRequest("The request id parameter did not match the course id in the request body."));
}
var dbCourse = courseMapper.MapCourseEditDTO(course);
var authorization = await authorizationService.AuthorizeAsync(User, dbCourse, AuthorizationConstants.CanUpdateCoursePolicy);
if (!authorization.Succeeded)
{
return(Forbid());
}
_context.Entry(dbCourse).State = EntityState.Modified;
try {
await _context.SaveChangesAsync();
await cache.ClearCourseCacheAsync(id, dbCourse.CourseInfo.Slug);
} catch (DbUpdateConcurrencyException) {
if (!CourseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <StudentAssignedTaskDTO> > PostStudentAssignedTask(Guid taskId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var task = await _context.AssignmentTasks
.Include(t => t.Assignment)
.Include(t => t.StudentsAssigned)
.FirstOrDefaultAsync(t => t.Id == taskId);
if (task is null)
{
return(NotFound());
}
//var authorization = await authorizationService.AuthorizeAsync(User, assignmentEntry, AuthorizationConstants.CanEditAssignmentEntriesPolicy);
//if (!authorization.Succeeded)
// return Forbid();
if (task.Assignment.StartDate > DateTime.UtcNow)
{
ModelState.AddModelError(string.Empty, "The assignment has not started yet.");
return(BadRequest(ModelState));
}
if (task.Assignment.EndDate < DateTime.UtcNow)
{
ModelState.AddModelError(string.Empty, "The assignment deadline has passed.");
return(BadRequest(ModelState));
}
if (task.Assignment.Type == AssignmentType.CustomAssignedTasks)
{
ModelState.AddModelError(string.Empty, "Tasks cannot be self assigned for this assignment.");
return(BadRequest(ModelState));
}
if (task.Assignment.Type == AssignmentType.SingleChoiceList && task.StudentsAssigned.Any())
{
ModelState.AddModelError(string.Empty, "A task can only be assigned to a single student.");
return(BadRequest(ModelState));
}
if (task.Assignment.Type == AssignmentType.MultipleChoiceList && task.Assignment.NumberOfDuplicates <= task.StudentsAssigned.Count)
{
ModelState.AddModelError(string.Empty, "This task has reached maximum student assignments.");
return(BadRequest(ModelState));
}
var studentId = userManager.GetUserId(User);
var studentAssignedTask = new StudentAssignedTask {
State = StudentAssignedTaskState.Assigned,
StudentId = studentId,
TaskId = task.Id
};
_context.StudentAssignedTasks.Add(studentAssignedTask);
await _context.SaveChangesAsync();
var studentTask = await _context.StudentAssignedTasks
.Where(sat => sat.Id == studentAssignedTask.Id)
.Select(sat => new StudentTaskProjection {
Task = sat.Task,
Student = sat.Student,
StudentId = sat.StudentId,
CourseId = sat.Task.Assignment.Course.Id,
State = sat.State,
FinalGrading = sat.FinalGrading,
Submissions = sat.Submissions
})
.FirstOrDefaultAsync();
await _context.Entry(studentTask.Task)
.Collection(t => t.StudentsAssigned)
.Query()
.Include(sa => sa.Student).ThenInclude(s => s.User)
.LoadAsync();
return(CreatedAtAction("GetAssignmentEntry", new { id = studentAssignedTask.Id }, await taskMapper.MapStudentAssignedTask(studentTask)));
}
public async Task <IActionResult> PutAssignment(Guid id, AssignmentEditDTO assignment)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != assignment.Id)
{
return(BadRequest());
}
var dbAssignment = assignmentMapper.MapAssignmentEditDTO(assignment);
dbAssignment.Slug = slugService.TransformText(dbAssignment.Name);
var collidingAssignment = await _context.Assignments
.Where(a => a.Course.Id == dbAssignment.Course.Id && a.Id != dbAssignment.Id && a.Slug == dbAssignment.Slug)
.FirstOrDefaultAsync();
if (collidingAssignment != null)
{
ModelState.AddModelError("name", $"Failed to generate unique url slug from the assignment name. The generated slug ({dbAssignment.Slug}) is used by another assignment of this course.");
return(BadRequest(ModelState));
}
var course = await _context.Courses
.Include(c => c.Professor)
.Include(c => c.Assistants)
.Include(c => c.Groups)
.Include(c => c.Students)
.FirstOrDefaultAsync(c => c.Id == dbAssignment.Course.Id);
var authorization = await authorizationService.AuthorizeAsync(User, course, AuthorizationConstants.CanUpdateCoursePolicy);
if (!authorization.Succeeded)
{
return(Forbid());
}
var existingAssignment = await _context.Assignments
.AsNoTracking()
.FirstOrDefaultAsync(a => a.Id == dbAssignment.Id);
dbAssignment.DateAdded = existingAssignment.DateAdded;
dbAssignment.LastUpdated = DateTime.UtcNow;
_context.Entry(dbAssignment).State = EntityState.Modified;
try {
await _context.SaveChangesAsync();
} catch (DbUpdateConcurrencyException) {
if (!AssignmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}