private IEnumerable <LearningObjective> IterateLearningObjectivesStatistics(SubmittedAnswersFilter filter)
{
var answers = submittedAnswersProvider.GetAnswers(filter);
var answersGrouppedByLearningObjective = answers.GroupBy(a => new LearningObjectiveGroupValues(a.LearningObjective, a.Domain, a.Subject));
foreach (var learningObjectivesGroup in answersGrouppedByLearningObjective)
{
var users = learningObjectivesGroup.GroupBy(lg => lg.User.UserId)
.Select(ug => new UserForLearningObjective
{
UserId = ug.First().User.UserId,
ImageId = ug.First().User.ImageId,
Name = ug.First().User.Name,
UserAnswers = ug.ToArray()
}).ToArray();
var learningObjective = new LearningObjective
{
Domain = learningObjectivesGroup.Key.Domain,
Name = learningObjectivesGroup.Key.Name,
Subject = learningObjectivesGroup.Key.Subject,
Users = users
};
yield return(learningObjective);
}
}
public void Should_ReturnEmpty_WhenNoUsers()
{
usersRepositorySetup.Setup(r => r.Query())
.Returns(new UserDb[0].AsQueryable());
var filter = new SubmittedAnswersFilter();
submittedAnswersProviderSetup.Setup(p => p.GetAnswers(filter))
.Returns(new SubmittedAnswer[0]);
usersProvider.GetUsers(filter)
.Should().BeEmpty();
}
public SubmittedAnswer[] GetAnswers(SubmittedAnswersFilter filter)
{
var answersQuery = ApplyFilter(answersRepository.Query(), filter);
var usersQuery = usersRepository.Query();
var answersWithUsers = answersQuery.Join(usersQuery, a => a.UserId, u => u.UserId, (a, u) => new
{
Answer = a,
User = u
})
.ToArray();
var result = answersWithUsers.Select(x => submittedAnswerBuilder.Build(x.Answer, x.User))
.ToArray();
return(result);
}
public void Should_ReturnUsers_WithoutAnswers()
{
var users = fixture.CreateMany <UserDb>(5).ToArray();
usersRepositorySetup.Setup(r => r.Query())
.Returns(users.AsQueryable());
var filter = new SubmittedAnswersFilter();
submittedAnswersProviderSetup.Setup(p => p.GetAnswers(filter))
.Returns(new SubmittedAnswer[0]);
usersProvider.GetUsers(filter)
.Select(u => u.UserId)
.ShouldBeEquivalentTo(users.Select(u => u.UserId));
}
public void Should_FilterByUser()
{
var users = fixture.CreateMany <UserDb>(4).ToArray();
usersRepositorySetup.Setup(r => r.Query())
.Returns(users.AsQueryable());
var filter = new SubmittedAnswersFilter
{
UserId = users[1].UserId
};
submittedAnswersProviderSetup.Setup(p => p.GetAnswers(filter))
.Returns(new SubmittedAnswer[0]);
var resultUsers = usersProvider.GetUsers(filter);
resultUsers.Length.Should().Be(1);
resultUsers[0].UserId.Should().Be(users[1].UserId);
}
public void Should_GroupByUser()
{
var users = fixture.CreateMany <UserForSubmittedAnswer>(2).ToArray();
var answersSetup = fixture.Build <SubmittedAnswer>()
.With(a => a.LearningObjective, "learning objective")
.With(a => a.Domain, "domain")
.With(a => a.Subject, "subject");
var subset1 = answersSetup.With(a => a.User, users[0])
.CreateMany()
.ToArray();
var subset2 = answersSetup.With(a => a.User, users[1])
.CreateMany()
.ToArray();
var dbUsers = users.Select(u => new UserDb {
UserId = u.UserId, Name = u.Name, ImageId = u.ImageId
});
usersRepositorySetup.Setup(r => r.Query())
.Returns(dbUsers.AsQueryable());
var filter = new SubmittedAnswersFilter();
submittedAnswersProviderSetup.Setup(p => p.GetAnswers(filter))
.Returns(subset1.Union(subset2).ToArray());
var resultUsers = usersProvider.GetUsers(filter);
resultUsers.Length.Should().Be(2);
var resultUser1 = resultUsers.First(u => u.UserId == users[0].UserId);
resultUser1.LearningObjectives.Length.Should().Be(1);
resultUser1.LearningObjectives[0].Answers.ShouldBeEquivalentTo(subset1);
var resultUser2 = resultUsers.First(u => u.UserId == users[1].UserId);
resultUser2.LearningObjectives.Length.Should().Be(1);
resultUser2.LearningObjectives[0].Answers.ShouldBeEquivalentTo(subset2);
}
private IEnumerable <User> IterateUsers(SubmittedAnswersFilter filter)
{
var answers = submittedAnswersProvider.GetAnswers(filter);
var usersQuery = usersRepository.Query();
if (filter.UserId != null)
{
usersQuery = usersQuery.Where(u => u.UserId == filter.UserId.Value);
}
var users = usersQuery // In real app there probably should be some filter by studying class
.ToArray();
var usersWithAnswers = users.GroupJoin(answers, u => u.UserId, a => a.User.UserId,
(u, a) => new
{
User = u,
Answers = a
}).ToArray();
foreach (var userWithAnswers in usersWithAnswers)
{
var learningObjectives = userWithAnswers.Answers
.GroupBy(a => new LearningObjectiveGroupValues(a.LearningObjective, a.Domain, a.Subject))
.Select(ag => new LearningObjectiveForUser
{
Name = ag.Key.Name,
Domain = ag.Key.Domain,
Subject = ag.Key.Subject,
Answers = ag.ToArray()
}).ToArray();
var user = new User
{
UserId = userWithAnswers.User.UserId,
Name = userWithAnswers.User.Name,
ImageId = userWithAnswers.User.ImageId,
LearningObjectives = learningObjectives
};
yield return(user);
}
}
public LearningObjective[] GetLearningObjectives(SubmittedAnswersFilter filter)
{
return(IterateLearningObjectivesStatistics(filter).ToArray());
}
public IQueryable <SubmittedAnswerDb> ApplyFilter(IQueryable <SubmittedAnswerDb> input, SubmittedAnswersFilter filter)
{
if (filter.To == null)
{
return(input);
}
return(input.Where(a => a.SubmitDateTime < filter.To.Value));
}
private IQueryable <SubmittedAnswerDb> ApplyFilter(IQueryable <SubmittedAnswerDb> inputQuery, SubmittedAnswersFilter filter)
{
return(filterHandlers.Aggregate(inputQuery, (current, filterHandler) => filterHandler.ApplyFilter(current, filter)));
}
public IQueryable <SubmittedAnswerDb> ApplyFilter(IQueryable <SubmittedAnswerDb> input, SubmittedAnswersFilter filter)
{
if (filter.UserId == null)
{
return(input);
}
return(input.Where(a => a.UserId == filter.UserId.Value));
}
public User[] GetUsers(SubmittedAnswersFilter filter)
{
return(IterateUsers(filter).ToArray());
}
