private async Task <Step> ToModel(StepEditionAggregate aggregate)
{
var step = await GetModel(aggregate.Id.Value);
var removedTests = GetRemovedTests(aggregate, step);
removedTests.ForEach(test => test.IsDeleted = true);
var currentTests = GetCurrentTests(step);
var newTests = GetNewTests(aggregate, currentTests);
currentTests.ForEach(currentTest =>
{
var test = aggregate.Tests.First(t => t.Id.Value == currentTest.Id);
currentTest.Score = test.Score;
currentTest.InputGenerator = test.InputGenerator;
currentTest.OutputValidator = test.OutputValidator;
currentTest.Name = test.Name;
});
newTests.ForEach(test => step.Tests.Add(test));
step.MinFunctionsCount = aggregate.MinFunctionsCount;
step.MaxFunctionsCount = aggregate.MaxFunctionsCount;
step.Description = aggregate.Description;
step.Difficulty = aggregate.Difficulty;
step.Name = aggregate.Name;
step.Score = aggregate.Score;
step.HeaderCode = aggregate.HeaderCode;
step.ProgrammingLanguage = _context.ProgrammingLanguages.First(p => p.Id == aggregate.LanguageId.Value);
return(step);
}
public StepEditionAggregate GetPublishedStep(int?minFunctionCount = null, int?maxFunctionCount = null)
{
return(StepEditionAggregate.Restore(_id, _name, _description, _headerCode, minFunctionCount,
maxFunctionCount,
_score, _difficulty,
true,
_languageId,
new List <TestEntity>()));
}
public async Task <StepId> SetAsync(StepEditionAggregate aggregate)
{
var step = await ToModel(aggregate);
_context.Steps.Upsert(step);
await _context.SaveChangesAsync();
return(new StepId(step.Id));
}
private static List <Test> GetNewTests(StepEditionAggregate aggregate, List <Test> currentTests)
{
return(aggregate.Tests
.Where(test => currentTests.All(t => t.Id != test.Id.Value))
.Select(test => new Test
{
Id = test.Id.Value, Name = test.Name, Score = test.Score, InputGenerator = test.InputGenerator,
OutputValidator = test.OutputValidator
})
.ToList());
}
private StepEditionAggregate ToAggregate(Step step)
{
return(StepEditionAggregate.Restore(
new StepId(step.Id),
step.Name,
step.Description,
step.HeaderCode,
step.MinFunctionsCount,
step.MaxFunctionsCount,
step.Score,
step.Difficulty,
step.TournamentSteps.Any(tS => tS.Tournament.IsPublished),
new ProgrammingLanguageId(step.ProgrammingLanguage.Id),
step.Tests.Where(t => !t.IsDeleted).Select(ToTestEntity).ToList()
));
}
public async Task <string> Handle(CreateStepCommand request, CancellationToken cancellationToken)
{
if (!await _languageRepository.LanguageExistById(request.LanguageId))
{
throw new ApplicationException($"Language {request.LanguageId} not found");
}
var step = StepEditionAggregate.CreateNew(
await _stepEditionRepository.NextIdAsync(),
request.Name,
request.Description,
request.HeaderCode,
request.MinFunctionsCount,
request.MaxFunctionsCount,
request.Score,
request.Difficulty,
new ProgrammingLanguageId(request.LanguageId));
var id = await _stepEditionRepository.SetAsync(step);
return(id.ToString());
}
private static List <Test> GetRemovedTests(StepEditionAggregate aggregate, Step step)
{
return(step.Tests
.Where(test => !test.IsDeleted && aggregate.Tests.All(t => t.Id.Value != test.Id))
.ToList());
}
