public List <PhaseDTO> GeneratePhases(int numberTeams)
{
int div = 0;
int numberPhase = 1;
List <PhaseDTO> phaseResult = new List <PhaseDTO>();
while (div != 1)
{
div = div == 0 ? numberTeams / 2 : div / 2;
PhaseDTO phase = new PhaseDTO()
{
Id = null,
NumberPhase = numberPhase,
Matches = new List <MatchDTO>(),
Closed = numberPhase == 1 ? false : true
};
for (int index = 1; index <= div; index++)
{
phase.Matches.Add(new MatchDTO()
{
Id = null,
NumberMatch = index,
FirstTeam = null,
SecondTeam = null,
WinnerTeam = null
});
}
numberPhase++;
phaseResult.Add(phase);
}
return(phaseResult);
}
public IActionResult Get(Guid id)
{
var phase = _phaseRepository.GetPhaseByID(id);
PhaseDTO phaseDTO = _mapper.Map <PhaseDTO>(phase);
return(new OkObjectResult(phase));
}
public Response <PhaseDTO> GenerateTeams([FromBody] PhaseDTO phase)
{
Response <PhaseDTO> response = new Response <PhaseDTO>();
_tournamentAppBusinessService.ClosePhase(phase);
response.messages = _tournamentAppBusinessService.GetMessages();
return(response);
}
public async void Update_phase_valid_input_Integration()
{
var phase = new PhaseDTO();
var results = await _phaseLogic.Update(phase);
Assert.Equal(true, results);
}
public void Create_phase_invalid_input()
{
var phase = new PhaseDTO();
_phaseController.ModelState.AddModelError("", "");
var results = _phaseController.CreatePhase(phase).Result;
Assert.IsType <BadRequestObjectResult>(results);
}
public void Update_phase_invalid_input()
{
var phase = new PhaseDTO {
Id = 2
};
var results = _phaseController.UpdatePhase(phase).Result;
Assert.IsType <NotFoundResult>(results);
}
public void Update_phase_valid_input()
{
var phase = new PhaseDTO();
_phaseDtoRepository.Setup(a => a.UpdateAsync(It.IsAny <PhaseDTO>())).ReturnsAsync(true);
var results = _phaseLogic.Update(phase).Result;
Assert.Equal(true, results);
}
public void Start_phase_invalid_input()
{
var phase = new PhaseDTO {
Id = 10
};
var results = _phaseController.StartPhase(phase.Id).Result;
Assert.IsType <NotFoundResult>(results);
}
public void Start_phase_valid_input()
{
var phase = new PhaseDTO {
Id = 10
};
_phaseLogic.Setup(a => a.StartPhase(phase)).ReturnsAsync(true);
var results = _phaseController.StartPhase(phase.Id).Result;
Assert.IsType <NoContentResult>(results);
}
public void Update_phase_valid_input()
{
var phase = new PhaseDTO {
Id = 5
};
_phaseLogic.Setup(a => a.Update(phase)).ReturnsAsync(true);
var results = _phaseController.UpdatePhase(phase).Result;
Assert.IsType <NoContentResult>(results);
}
public Response <PhaseDTO> Put([FromBody] PhaseDTO phase)
{
Response <PhaseDTO> response = new Response <PhaseDTO>();
Phase updatePhase = _phaseAppCRUDService.GetById(phase.Id);
for (int i = 0; i < updatePhase.Matches.Count; i++)
{
updatePhase.Matches[i].WinnerTeam = phase.Matches.Find(x => x.NumberMatch == updatePhase.Matches[i].NumberMatch).WinnerTeam?.ConvertToTeam();
}
_phaseAppCRUDService.Update(updatePhase);
response.data = phase.ConvertToDTO(updatePhase);
response.messages = _phaseAppCRUDService.GetMessages();
return(response);
}
public void Get_phase_by_id_valid_input()
{
var phase = new PhaseDTO {
Id = 1
};
_phaseLogic.Setup(a => a.GetById(It.IsAny <int>())).ReturnsAsync(phase);
var results = _phaseController.GetPhaseById(phase.Id).Result;
var jResults = Assert.IsType <OkObjectResult>(results);
var aResults = Assert.IsType <PhaseDTO>(jResults.Value);
Assert.Equal(phase, aResults);
}
public async Task <IActionResult> CreatePhase([FromBody] PhaseDTO phase)
{
if (!ModelState.IsValid || phase.Id != 0)
{
return(BadRequest(ModelState));
}
var create = await _phaseLogic.Create(phase);
//phase.Id = create;
return(Ok());
//return Ok(phase.Id);
//return CreatedAtAction("GetPhaseById", new { id = phase.Id }, phase);
}
public void Create_phase_valid_input()
{
var phase = new PhaseDTO();
_phaseLogic.Setup(a => a.Create(phase)).ReturnsAsync(2);
var results = _phaseController.CreatePhase(phase).Result;
//var created = results.Value as PhaseDTO;
_phaseLogic.Verify(r => r.Create(phase), Times.Once);
Assert.IsAssignableFrom <OkResult>(results);
//Assert.Equal(10, created.Id);
}
public async Task <IActionResult> UpdatePhase([FromBody] PhaseDTO phase)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var update = await _phaseLogic.Update(phase);
if (update)
{
return(NoContent());
}
return(NotFound());
}
public static Phase ConvertToEntity(this PhaseDTO dto)
{
return(new Phase {
Id = dto.Id,
StudyId = dto.Id,
Automatic = dto.IsAutomatic,
OverlapPercentage = dto.OverlapPercentage,
UserParticipants = dto.Participants?.Select(d => d.ConvertToEntity()).ToList(),
DisplayFields = dto.DisplayFields?.Select(d => d.ConvertToEntity()).ToList(),
Purpose = dto.Purpose,
ConflictManager = dto.ConflictManager?.ConvertToEntity(),
InputFields = dto.InputFields?.Select(d => d.ConvertToEntity()).ToList(),
ConflictManagerId = dto.ConflictManager?.Id ?? 0,
TaskDelegations = dto.TaskDelegations?.Select(d => d.ConvertToEntity()).ToList()
});
}
public async void Get_Phase_By_Id_Valid_Input_Integration()
{
var phase = new PhaseDTO {
Id = 0,
Purpose = "something",
DisplayFields = null,
Participants = null,
InputFields = null,
TaskDelegations = null,
IsAutomatic = false,
ConflictManager = null,
OverlapPercentage = 10
};
var result = await _phaseLogic.GetById(phase.Id);
Assert.Equal(phase, result);
Assert.Equal(phase.Purpose, result.Purpose);
}
public void ClosePhase(PhaseDTO phaseDto)
{
Phase pDto = _phaseCRUDService.GetById(phaseDto.Id);
Tournament t = _tournamentCRUDService.GetById(pDto.Tournament.Id);
foreach (var phase in t.Phases)
{
if (phase.NumberPhase == pDto.NumberPhase + 1)
{
List <Match> matches = new List <Match>();
foreach (var temp in pDto.Matches)
{
matches.Add(temp);
}
foreach (var match in phase.Matches)
{
var firstMatch = matches.Find(x => x.NumberMatch == (match.NumberMatch + match.NumberMatch - 1));
var secondMatch = matches.Find(x => x.NumberMatch == (match.NumberMatch + match.NumberMatch));
match.FirstTeam = firstMatch?.WinnerTeam;
match.SecondTeam = secondMatch?.WinnerTeam;
}
phase.Closed = false;
}
else
{
if (t.Phases.Count == pDto.NumberPhase && pDto.NumberPhase == phase.NumberPhase)
{
phase.Matches[0].WinnerTeam = phaseDto.Matches[0].WinnerTeam.ConvertToTeam();
messages.Add(new Message("TOR02", MessageType.success, String.Concat("Parabens ao time ", phase.Matches[0].WinnerTeam.Name, " que é o campeão do torneio ", t.Name, "!")));
phase.Closed = true;
}
phase.Closed = true;
}
}
_tournamentCRUDService.Update(t);
messages.Add(new Message("TOR01", MessageType.success, "Fase fechada com sucesso!"));
}
public void Get_Phase_By_Id_Valid_Input()
{
var phase = new PhaseDTO
{
Id = 0,
Purpose = "something",
DisplayFields = null,
Participants = null,
InputFields = null,
TaskDelegations = null,
IsAutomatic = false,
ConflictManager = null,
OverlapPercentage = 10
};
_phaseDtoRepository.Setup(a => a.ReadAsync(It.IsAny <int>())).ReturnsAsync(phase);
var result = _phaseLogic.GetById(phase.Id).Result;
Assert.Equal(phase, result);
Assert.Equal(phase.Purpose, result.Purpose);
}
public void ClosePhase(PhaseDTO phaseDto)
{
_serviceBusinessBase.ClosePhase(phaseDto);
}
public async Task <int> Create(PhaseDTO phase)
{
return(await _phaseRepo.CreateAsync(phase));
}
public async Task <bool> Update(PhaseDTO phase)
{
return(await _phaseRepo.UpdateAsync(phase));
}
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);
}
