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()); }