public static ReviewTask ConvertToEntity(this ReviewTaskDTO dto)
{
return(new ReviewTask {
Id = dto.Id,
Answers = dto.Answers?.Select(e => e.ConvertToEntity()).ToList(),
TaskDelegationId = dto.TaskDelegationId,
User = dto.User?.ConvertToEntity(),
UserId = dto.User?.Id ?? 0,
IsSubmitted = dto.IsSubmitted
});
}
public async Task <IActionResult> SubmitTask([FromBody] ReviewTaskDTO taskDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _taskLogic.SubmitTask(taskDto);
if (!result)
{
return(BadRequest(ModelState));
}
return(Ok(result));
}
public async Task <bool> StartPhase(PhaseDTO phase)
{
var study = await _studyRepo.ReadAsync(phase.StudyId);
study.ActivePhase = phase;
await _studyRepo.UpdateAsync(study);
var p = study.Users;
p = p.OrderBy(a => Guid.NewGuid()).ToList();
var participants = p.ToList();
study.Publications = study.Publications.OrderBy(a => Guid.NewGuid()).ToList(); // Shuffle list
/*
* Gennemgå hver publication
* Lav en task delegation for hver publication
* Lav antal x tasks (hver til én user)
* Få id fra GetNextUser
**/
var publications = study.Publications.ToList();
var numPubs = study.Publications.Count();
var numUsers = participants.Count();
var numOverlap = numPubs * 100.0 / phase.OverlapPercentage;
var numMinTasks = numOverlap / numUsers; // Number of minimum tasks for each researcher
var numExtraTasks = numOverlap % numUsers; // Number of researchers that must get an extra task
int curUserIdx = 0;
var taskList = new List <ReviewTaskDTO>();
foreach (PublicationDTO publication in publications)
{
var delegation = new TaskDelegationDTO {
PhaseId = phase.Id,
Publication = publication,
Tasks = taskList
};
await _taskDelRepo.CreateAsync(delegation);
var numTasks = numMinTasks + (numExtraTasks-- >= 0 ? 1 : 0); // Min tasks and maybe plus an extra
for (int n = 0; n < numTasks; n++)
{
var task = new ReviewTaskDTO {
TaskDelegationId = delegation.Id,
User = participants[curUserIdx].User
};
await _taskRepo.CreateAsync(task);
taskList.Add(task);
curUserIdx = (curUserIdx + 1) % participants.Count();
}
await _taskDelRepo.UpdateAsync(delegation);
return(await Update(phase));
}
return(false);
}
/// <summary>
/// Submits the given task. The task has to be created in the database beforehand.
/// </summary>
/// <param name="task">The task to be submitted</param>
/// <returns>True if successful, false if the task could not be submitted</returns>
public async Task <bool> SubmitTask(ReviewTaskDTO task)
{
// Make a list of all field ids in the answers of the task
List <int> taskListId = new List <int>();
foreach (AnswerDTO a in task.Answers)
{
taskListId.Add(a.Field.Id);
}
ReviewTaskDTO readTask;
if ((readTask = await _taskRepo.ReadAsync(task.Id)) != null)
{
var readTaskDelegation = await _taskDelegationRepository.ReadAsync(readTask.TaskDelegationId);
var readPhase = await _phaseRepository.ReadAsync(readTaskDelegation.PhaseId);
var taskDelegation = await _taskDelegationRepository.ReadAsync(task.TaskDelegationId);
var phase = await _phaseRepository.ReadAsync(taskDelegation.PhaseId);
// Check if the phases match
if (readPhase.Id != phase.Id)
{
return(false);
}
// Check if all the fields in the phase match the fields in the answers
var fieldListId = from s in phase.InputFields
where taskListId.Contains(s.Id)
select s.Id;
// Check if the answers and the phase have the same amount of fields
if (fieldListId.Count() != taskListId.Count())
{
return(false);
}
// Use the above fieldList to get all tasks that match the
if (fieldListId == null)
{
return(false);
}
List <AnswerDTO> answerList = new List <AnswerDTO>();
foreach (AnswerDTO a in task.Answers)
{
if (fieldListId.Contains(a.Field.Id))
{
answerList.Add(a);
}
}
// Create all the answers
if (answerList[0] == null)
{
return(false);
}
foreach (AnswerDTO a in answerList)
{
await _answerRepo.CreateAsync(a);
}
// Submit the task
task.IsSubmitted = true;
// Update the task
if (!await _taskRepo.UpdateAsync(task))
{
return(false);
}
var taskList = taskDelegation.Tasks.ToList();
int j = 0;
// Check if all tasks have been submitted
for (int i = 0; i < taskList.Count(); i++)
{
if (taskList[i].IsSubmitted)
{
j++;
}
}
// Check if all tasks have been submitted
if (j == taskList.Count())
{
CommitTaskDelegation(taskDelegation);
var exclusions = (await _studyRepo.ReadAsync(phase.StudyId)).ExclusionCriteria;
foreach (var exclusionCriterionDto in exclusions)
{
var publication = taskDelegation.Publication;
var dataField = publication.Data.Single(d =>
{
var f = _fieldRepository.ReadAsync(d.FieldId).Result;
return(f.Id == exclusionCriterionDto.FieldId);
});
publication.Active = publication.Active && exclusionCriterionDto.Condition.Apply(dataField.Value);
}
}
}
return(true);
}
