public async Task <ActionResult <AssignmentDto> > UpdateAssignment(UpdateAssignmentDto assignmentDto)
{
if (assignmentDto == null)
{
return(BadRequest(InvalidAssignmentError));
}
if (assignmentDto.Start >= assignmentDto.End)
{
return(BadRequest("Start time was on or after end time."));
}
var savedAssignment = await AssignmentService.GetAssignment(assignmentDto.Id);
if (savedAssignment == null)
{
return(NotFound());
}
if (!PermissionDataFiltersExtensions.HasAccessToLocation(User, Db, savedAssignment.LocationId))
{
return(Forbid());
}
var updateAssignment = assignmentDto.Adapt <Assignment>();
var updatedAssignment = await AssignmentService.UpdateAssignment(updateAssignment);
return(Ok(updatedAssignment.Adapt <AssignmentDto>()));
}
public void Validate_OrderIsZero_ShouldHaveError()
{
var dto = new UpdateAssignmentDto
{
Order = 0
};
_validator.ShouldHaveValidationErrorFor(x => x.Order, dto);
}
public void Validate_StatusIsInvalid_ShouldHaveError()
{
var dto = new UpdateAssignmentDto
{
Status = "Finished",
};
_validator.ShouldHaveValidationErrorFor(x => x.Status, dto);
}
public void Validate_PriorityIsInvalid_ShouldHaveError()
{
var dto = new UpdateAssignmentDto
{
Priority = "Critical",
};
_validator.ShouldHaveValidationErrorFor(x => x.Priority, dto);
}
public void Validate_StatusIsEmpty_ShouldHaveError()
{
var dto = new UpdateAssignmentDto
{
Status = string.Empty,
};
_validator.ShouldHaveValidationErrorFor(x => x.Status, dto);
}
public void Validate_PriorityIsEmpty_ShouldHaveError()
{
var dto = new UpdateAssignmentDto
{
Priority = string.Empty,
};
_validator.ShouldHaveValidationErrorFor(x => x.Priority, dto);
}
public void Validate_RequesterIsEmpty_ShouldHaveError()
{
var dto = new UpdateAssignmentDto
{
Requester = string.Empty,
};
_validator.ShouldHaveValidationErrorFor(x => x.Requester, dto);
}
public void Validate_DescriptionIsEmpty_ShouldHaveError()
{
var dto = new UpdateAssignmentDto
{
Description = string.Empty,
};
_validator.ShouldHaveValidationErrorFor(x => x.Description, dto);
}
public void Validate_TitleIsEmpty_ShouldHaveError()
{
var dto = new UpdateAssignmentDto
{
Title = string.Empty,
};
_validator.ShouldHaveValidationErrorFor(x => x.Title, dto);
}
public async Task <IActionResult> UpdateAssignment(UpdateAssignmentDto updatedAssignment)
{
ServiceResponse <GetAssignmentDto> response = await _assignmentService.UpdateAssignment(updatedAssignment);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public void Validate_DtoIsValid_ShouldNotHaveError()
{
var dto = new UpdateAssignmentDto
{
Title = "Title",
Description = "Description",
Requester = "Me",
Status = "To Do",
Priority = "Low",
Order = 1
};
_validator.ShouldNotHaveValidationErrorFor(x => new { x.Title, x.Description, x.Requester, x.Status, x.Priority, x.Order }, dto);
}
public async Task <IActionResult> Update([FromRoute] Guid id, [FromBody] UpdateAssignmentDto assignment)
{
var existingAssignment = await _repository.FindById(id);
if (existingAssignment == null)
{
return(NotFound());
}
_mapper.Map(assignment, existingAssignment);
var result = await _repository.Update(existingAssignment);
var response = _mapper.Map <AssignmentDto>(result);
return(Ok(response));
}
public async Task <ServiceResponse <GetAssignmentDto> > UpdateAssignment(UpdateAssignmentDto dto)
{
ServiceResponse <GetAssignmentDto> response = new ServiceResponse <GetAssignmentDto>();
Assignment assignment = await _context.Assignments.FirstOrDefaultAsync(a => a.Id == dto.AssignmentId);
if (assignment == null)
{
response.Data = null;
response.Message = "There is no submission under this id";
response.Success = false;
return(response);
}
User user = await _context.Users.Include(u => u.InstructedCourses)
.FirstOrDefaultAsync(u => u.Id == GetUserId());
if (!user.InstructedCourses.Any(c => c.CourseId == assignment.AfilliatedCourseId))
{
response.Data = null;
response.Message = "You are not allowed to see for this assignment";
response.Success = false;
return(response);
}
assignment.AssignmentDescription = dto.AssignmenDescription;
assignment.DueDate = dto.DueDate;
assignment.IsItGraded = dto.IsItGraded;
assignment.Title = dto.Title;
assignment.AcceptedTypes = dto.AcceptedTypes;
assignment.MaxFileSizeInBytes = dto.MaxFileSizeInBytes;
assignment.VisibilityOfSubmission = dto.VisibiltyOfSubmission;
assignment.CanBeGradedByStudents = dto.CanBeGradedByStudents;
_context.Assignments.Update(assignment);
await _context.SaveChangesAsync();
response.Data = _mapper.Map <GetAssignmentDto>(assignment);
return(response);
}
public async Task <ServiceResponse <GetAssignmentDto> > UpdateAssignment(UpdateAssignmentDto updatedAssignment)
{
ServiceResponse <GetAssignmentDto> serviceResponse = new ServiceResponse <GetAssignmentDto>();
try
{
Assignment assignment = await _context.Assignments.Include(a => a.User).FirstOrDefaultAsync(a => a.Id == updatedAssignment.Id);
if (assignment.User.Id == GetUserId())
{
if ((updatedAssignment.Status == "Done" && updatedAssignment.TimeSpent == null) ||
(updatedAssignment.Status == "Done" && updatedAssignment.WayOfSolving == null)
)
{
serviceResponse.Success = false;
serviceResponse.Message = "Please enter informations about time spent for solving this assignment and way of solving.";
}
else if (DateTime.Compare(updatedAssignment.StartDate, updatedAssignment.EndDate) > 0)
{
serviceResponse.Success = false;
serviceResponse.Message = "Start date is later than End date.";
}
else
{
assignment.AssignmentDescription = updatedAssignment.AssignmentDescription;
assignment.StartDate = updatedAssignment.StartDate;
assignment.EndDate = updatedAssignment.EndDate;
assignment.Note = updatedAssignment.Note;
assignment.Priority = updatedAssignment.Priority;
assignment.EditDate = DateTime.UtcNow;
assignment.UserIdEdit = GetUserId();
if (assignment.Status == "Done" && updatedAssignment.Status != "Done")
{
assignment.Status = updatedAssignment.Status;
assignment.TimeSpent = null;
assignment.WayOfSolving = null;
}
else
{
assignment.Status = updatedAssignment.Status;
assignment.TimeSpent = updatedAssignment.TimeSpent;
assignment.WayOfSolving = updatedAssignment.WayOfSolving;
}
_context.Assignments.Update(assignment);
await _context.SaveChangesAsync();
serviceResponse.Data = _mapper.Map <GetAssignmentDto>(assignment);
}
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = "Assignment not found.";
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
