public async Task GetRecommendedLearningForSelfAssessment_calls_learning_hub_api_with_distinct_ids()
{
// Given
A.CallTo(() => selfAssessmentDataService.GetCompetencyIdsForSelfAssessment(SelfAssessmentId))
.Returns(new[] { 1, 2, 3, 4, 5 });
var competencyLearningResources = Builder <CompetencyLearningResource> .CreateListOfSize(5).All()
.With(clr => clr.LearningHubResourceReferenceId = LearningHubResourceReferenceId)
.And(clr => clr.LearningResourceReferenceId = LearningResourceReferenceId).Build();
A.CallTo(
() => competencyLearningResourcesDataService.GetCompetencyLearningResourcesByCompetencyId(A <int> ._)
).Returns(competencyLearningResources);
var clientResponse = new BulkResourceReferences
{
ResourceReferences = new List <ResourceReferenceWithResourceDetails>
{
new ResourceReferenceWithResourceDetails
{
ResourceId = 0,
RefId = LearningHubResourceReferenceId,
Title = ResourceName,
Description = ResourceDescription,
Catalogue = new Catalogue {
Name = ResourceCatalogue
},
ResourceType = ResourceType,
Rating = 0,
Link = ResourceLink,
},
},
};
A.CallTo(() => learningHubApiClient.GetBulkResourcesByReferenceIds(A <IEnumerable <int> > ._))
.Returns(clientResponse);
// When
await recommendedLearningService.GetRecommendedLearningForSelfAssessment(SelfAssessmentId, DelegateId);
// Then
A.CallTo(
() => learningHubApiClient.GetBulkResourcesByReferenceIds(
A <IEnumerable <int> > .That.Matches(i => i.Single() == LearningHubResourceReferenceId)
)
)
.MustHaveHappenedOnceExactly();
}
public async Task <IEnumerable <RecommendedResource> > GetRecommendedLearningForSelfAssessment(
int selfAssessmentId,
int delegateId
)
{
var competencyIds = selfAssessmentDataService.GetCompetencyIdsForSelfAssessment(selfAssessmentId);
var competencyLearningResources = new List <CompetencyLearningResource>();
foreach (var competencyId in competencyIds)
{
var learningHubResourceReferencesForCompetency =
competencyLearningResourcesDataService.GetCompetencyLearningResourcesByCompetencyId(
competencyId
);
competencyLearningResources.AddRange(learningHubResourceReferencesForCompetency);
}
var resourceReferences = competencyLearningResources.Select(
clr => (clr.LearningHubResourceReferenceId, clr.LearningResourceReferenceId)
).Distinct().ToDictionary(x => x.LearningHubResourceReferenceId, x => x.LearningResourceReferenceId);
var uniqueLearningHubReferenceIds = competencyLearningResources
.Select(clr => clr.LearningHubResourceReferenceId).Distinct();
var resources = await learningHubApiClient.GetBulkResourcesByReferenceIds(uniqueLearningHubReferenceIds);
var delegateLearningLogItems = learningLogItemsDataService.GetLearningLogItems(delegateId);
var recommendedResources = resources.ResourceReferences.Select(
rr =>
{
var learningLogItemsForResource = delegateLearningLogItems.Where(
ll => ll.ArchivedDate == null && ll.LearningHubResourceReferenceId == rr.RefId
).ToList();
var incompleteLearningLogItem =
learningLogItemsForResource.SingleOrDefault(ll => ll.CompletedDate == null);
return(new RecommendedResource(
resourceReferences[rr.RefId],
rr,
incompleteLearningLogItem,
learningLogItemsForResource.Any(ll => ll.CompletedDate != null),
CalculateRecommendedLearningScore(rr, competencyLearningResources, selfAssessmentId, delegateId)
));
}
);
return(recommendedResources);
}
GetRecommendedLearningForSelfAssessment_calls_learning_hub_resource_service_with_distinct_ids()
{
// Given
A.CallTo(() => selfAssessmentDataService.GetCompetencyIdsForSelfAssessment(SelfAssessmentId))
.Returns(new[] { 1, 2, 3, 4, 5 });
var competencyLearningResources = Builder <CompetencyLearningResource> .CreateListOfSize(5).All()
.With(clr => clr.LearningHubResourceReferenceId = LearningHubResourceReferenceId)
.And(clr => clr.LearningResourceReferenceId = LearningResourceReferenceId).Build();
A.CallTo(
() => competencyLearningResourcesDataService.GetActiveCompetencyLearningResourcesByCompetencyId(
A <int> ._
)
).Returns(competencyLearningResources);
GivenLearningHubApiReturnsResources(0);
// When
await recommendedLearningService.GetRecommendedLearningForSelfAssessment(SelfAssessmentId, DelegateId);
// Then
A.CallTo(
() => learningHubResourceService.GetResourceReferenceDetailsByReferenceIds(
A <List <int> > .That.Matches(i => i.Single() == LearningHubResourceReferenceId)
)
)
.MustHaveHappenedOnceExactly();
A.CallTo(
() => learningHubResourceService.GetBulkResourcesByReferenceIds(
A <List <int> > .That.Matches(i => i.Single() == LearningHubResourceReferenceId)
)
)
.MustHaveHappenedOnceExactly();
}
public async Task AddResourceToActionPlan(int learningResourceReferenceId, int delegateId, int selfAssessmentId)
{
var learningHubResourceReferenceId =
learningResourceReferenceDataService.GetLearningHubResourceReferenceById(learningResourceReferenceId);
var competenciesForResource =
competencyLearningResourcesDataService.GetCompetencyIdsByLearningResourceReferenceId(
learningResourceReferenceId
);
var selfAssessmentCompetencies =
selfAssessmentDataService.GetCompetencyIdsForSelfAssessment(selfAssessmentId);
var learningLogCompetenciesToAdd =
competenciesForResource.Where(id => selfAssessmentCompetencies.Contains(id));
var addedDate = clockService.UtcNow;
var resource = await learningHubApiClient.GetResourceByReferenceId(learningHubResourceReferenceId);
using var transaction = new TransactionScope();
var learningLogItemId = learningLogItemsDataService.InsertLearningLogItem(
delegateId,
addedDate,
resource.Title,
resource.Link,
learningResourceReferenceId
);
learningLogItemsDataService.InsertCandidateAssessmentLearningLogItem(selfAssessmentId, learningLogItemId);
foreach (var competencyId in learningLogCompetenciesToAdd)
{
learningLogItemsDataService.InsertLearningLogItemCompetencies(
learningLogItemId,
competencyId,
addedDate
);
}
transaction.Complete();
}
public void AddResourceToActionPlan_calls_expected_insert_data_service_methods()
{
// Given
const int learningResourceReferenceId = 1;
const int delegateId = 2;
const int selfAssessmentId = 3;
const int candidateAssessmentId = 4;
const string resourceName = "Activity";
const string resourceLink = "www.test.com";
const int learningLogId = 4;
const int learningHubResourceId = 6;
var addedDate = new DateTime(2021, 11, 1);
A.CallTo(() => clockService.UtcNow).Returns(addedDate);
A.CallTo(
() => learningResourceReferenceDataService.GetLearningHubResourceReferenceById(
learningResourceReferenceId
)
).Returns(learningHubResourceId);
var resource = new ResourceReferenceWithResourceDetails {
Title = resourceName, Link = resourceLink
};
A.CallTo(() => learningHubResourceService.GetResourceByReferenceId(learningHubResourceId))
.Returns((resource, true));
var resourceCompetencies = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
A.CallTo(
() => competencyLearningResourcesDataService.GetCompetencyIdsLinkedToResource(
learningResourceReferenceId
)
).Returns(resourceCompetencies);
var assessmentCompetencies = new[] { 2, 3, 5, 6, 8, 9, 10 };
A.CallTo(() => selfAssessmentDataService.GetCompetencyIdsForSelfAssessment(selfAssessmentId))
.Returns(assessmentCompetencies);
A.CallTo(() => selfAssessmentDataService.GetCandidateAssessments(delegateId, selfAssessmentId))
.Returns(
new[] { Builder <CandidateAssessment> .CreateNew().With(ca => ca.Id = candidateAssessmentId).Build() }
);
A.CallTo(
() => learningLogItemsDataService.InsertLearningLogItem(
A <int> ._,
A <DateTime> ._,
A <string> ._,
A <string> ._,
A <int> ._
)
).Returns(learningLogId);
var expectedMatchingCompetencies = new[] { 2, 3, 5, 6, 8 };
// When
actionPlanService.AddResourceToActionPlan(learningResourceReferenceId, delegateId, selfAssessmentId);
// Then
A.CallTo(
() => learningLogItemsDataService.InsertLearningLogItem(
delegateId,
addedDate,
resourceName,
resourceLink,
learningResourceReferenceId
)
).MustHaveHappenedOnceExactly();
A.CallTo(
() => learningLogItemsDataService.InsertCandidateAssessmentLearningLogItem(
candidateAssessmentId,
learningLogId
)
).MustHaveHappenedOnceExactly();
foreach (var competencyId in expectedMatchingCompetencies)
{
A.CallTo(
() => learningLogItemsDataService.InsertLearningLogItemCompetencies(
learningLogId,
competencyId,
addedDate
)
).MustHaveHappenedOnceExactly();
}
A.CallTo(
() => learningLogItemsDataService.InsertLearningLogItemCompetencies(learningLogId, A <int> ._, addedDate)
).MustHaveHappened(5, Times.Exactly);
}
GetRecommendedLearningForSelfAssessment(
int selfAssessmentId,
int delegateId
)
{
var hasMaxSignpostedResources = Int32.TryParse(
configDataService.GetConfigValue(ConfigDataService.MaxSignpostedResources),
out var maxSignpostedResources
);
var competencyIds = selfAssessmentDataService.GetCompetencyIdsForSelfAssessment(selfAssessmentId);
var competencyLearningResources = new List <CompetencyLearningResource>();
foreach (var competencyId in competencyIds)
{
var learningHubResourceReferencesForCompetency =
competencyLearningResourcesDataService.GetActiveCompetencyLearningResourcesByCompetencyId(
competencyId
);
competencyLearningResources.AddRange(learningHubResourceReferencesForCompetency);
}
var resourceReferences = competencyLearningResources.Select(
clr => (clr.LearningHubResourceReferenceId, clr.LearningResourceReferenceId)
).Distinct().ToDictionary(
x => x.LearningHubResourceReferenceId,
x => x.LearningResourceReferenceId
);
var uniqueLearningHubReferenceIds = competencyLearningResources.Select(
clr => clr.LearningHubResourceReferenceId
).Distinct().ToList();
var resources =
learningHubResourceService.GetResourceReferenceDetailsByReferenceIds(uniqueLearningHubReferenceIds);
var delegateLearningLogItems = learningLogItemsDataService.GetLearningLogItems(delegateId);
var recommendedResources = resources.Select(
rr => GetPopulatedRecommendedResource(
selfAssessmentId,
delegateId,
resourceReferences[rr.RefId],
delegateLearningLogItems,
rr,
competencyLearningResources
)
)
.WhereNotNull()
.OrderByDescending(resource => resource.RecommendationScore);
var bestRecommendedResources = hasMaxSignpostedResources
? recommendedResources.Take(maxSignpostedResources).ToList()
: recommendedResources.ToList();
var apiResources =
await learningHubResourceService.GetBulkResourcesByReferenceIds(
bestRecommendedResources.Select(resource => resource.LearningHubReferenceId).ToList()
);
var recommendedResourcesPresentInApi = bestRecommendedResources.Where(
resource => !apiResources.bulkResourceReferences.UnmatchedResourceReferenceIds.Contains(
resource.LearningHubReferenceId
)
).ToList();
return(recommendedResourcesPresentInApi, apiResources.apiIsAccessible);
}
