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 <ActionResult <StudentAssignedTaskDTO> > GetStudentAssignedTask(Guid assignmentId)
{
if (!User.Identity.IsAuthenticated)
{
return(Challenge());
}
var studentId = userManager.GetUserId(User);
var studentTask = await _context.StudentAssignedTasks
.Where(sat => sat.StudentId == studentId && sat.Task.AssignmentId == assignmentId)
.Select(sat => new StudentTaskProjection {
Id = sat.Id,
Task = sat.Task,
StudentId = sat.StudentId,
Student = sat.Student,
CourseId = sat.Task.Assignment.Course.Id,
State = sat.State,
Review = sat.Review,
FinalGrading = sat.FinalGrading,
Submissions = sat.Submissions
})
.FirstOrDefaultAsync();
if (studentTask is null)
{
return(NotFound());
}
var authorization = await authorizationService.AuthorizeAsync(User, studentTask, AuthorizationConstants.CanViewStudentTaskPolicy);
if (!authorization.Succeeded)
{
return(Forbid());
}
await _context.Entry(studentTask.Student)
.Reference(t => t.User)
.LoadAsync();
await _context.TaskSubmissions
.Where(t => studentTask.Submissions.Contains(t))
.Include(s => s.Files).ThenInclude(f => f.File)
.ToListAsync();
return(await taskMapper.MapStudentAssignedTask(studentTask));
}
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 <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());
}