public async Task And_Has_Keyword_Then_Gets_Standards_From_SearchManager(
string keyword,
OrderBy orderBy,
StandardFilter filter,
List <Standard> standardsFromRepo,
StandardSearchResultsList searchResult,
[Frozen] Mock <IStandardRepository> mockStandardsRepository,
[Frozen] Mock <ISearchManager> mockSearchManager,
[Frozen] Mock <IStandardsSortOrderService> mockSortOrderService,
StandardsService service)
{
searchResult.Standards = new List <StandardSearchResult>
{
new StandardSearchResult {
StandardUId = standardsFromRepo[0].StandardUId
}
};
var standardsFoundInSearch = standardsFromRepo
.Where(standard => searchResult.Standards.Select(result => result.StandardUId).Contains(standard.StandardUId))
.ToList();
mockStandardsRepository
.Setup(repository => repository.GetStandards(new List <int>(), new List <int>(), filter))
.ReturnsAsync(standardsFromRepo);
mockSearchManager
.Setup(manager => manager.Query(keyword))
.Returns(searchResult);
mockSortOrderService
.Setup(orderService => orderService.OrderBy(standardsFoundInSearch, It.IsAny <OrderBy>(), It.IsAny <string>()))
.Returns(standardsFoundInSearch.OrderBy(standard => standard.SearchScore));
var standards = await service.GetStandardsList(keyword, new List <int>(), new List <int>(), orderBy, filter);
standards.Should().BeEquivalentTo(standardsFoundInSearch, StandardEquivalencyAssertionOptions.ExcludingFields);
}
public async Task And_No_Keyword_And_Filtering_By_Active_Then_Gets_Standards_From_Repository(
List <Standard> standardsFromRepo,
OrderBy orderBy,
StandardFilter filter,
[Frozen] Mock <IStandardRepository> mockStandardsRepository,
[Frozen] Mock <IStandardsSortOrderService> mockSortOrderService,
StandardsService service)
{
filter = StandardFilter.Active;
mockStandardsRepository
.Setup(repository => repository.GetStandards(new List <int>(), new List <int>(), filter))
.ReturnsAsync(standardsFromRepo);
mockSortOrderService
.Setup(orderService => orderService.OrderBy(standardsFromRepo, It.IsAny <OrderBy>(), It.IsAny <string>()))
.Returns(standardsFromRepo.OrderBy(standard => standard.SearchScore));
var result = (await service.GetStandardsList("", new List <int>(), new List <int>(), orderBy, filter)).ToList();
result.Should().BeEquivalentTo(standardsFromRepo, StandardEquivalencyAssertionOptions.ExcludingFields);
foreach (var standard in result)
{
standard.Route.Should().Be(standardsFromRepo.Single(c => c.LarsCode.Equals(standard.LarsCode)).Route.Name);
}
}
public async Task Then_Gets_A_Standard_From_The_Repository_By_IFateReferenceNumber(
string iFateReferenceNumber,
Standard standardFromRepo,
[Frozen] Mock <IStandardRepository> mockStandardsRepository,
StandardsService service)
{
mockStandardsRepository
.Setup(repository => repository.GetLatestActiveStandard(iFateReferenceNumber))
.ReturnsAsync(standardFromRepo);
var standard = await service.GetLatestActiveStandard(iFateReferenceNumber);
standard.Should().BeEquivalentTo(standardFromRepo, StandardEquivalencyAssertionOptions.ExcludingFields);
}
public async Task Then_Gets_Count_From_Repo(
int count,
StandardFilter filter,
[Frozen] Mock <IStandardRepository> mockRepository,
StandardsService service)
{
mockRepository
.Setup(repository => repository.Count(filter))
.ReturnsAsync(count);
var actual = await service.Count(filter);
actual.Should().Be(count);
}
public async Task And_Has_Levels_Then_Gets_Standards_From_Filters(
List <int> levelCodes,
OrderBy orderBy,
StandardFilter filter,
List <Standard> standardsFromRepo,
[Frozen] Mock <IStandardRepository> mockStandardsRepository,
[Frozen] Mock <IStandardsSortOrderService> mockSortOrderService,
StandardsService service)
{
mockStandardsRepository
.Setup(repository => repository.GetStandards(new List <int>(), levelCodes, filter))
.ReturnsAsync(standardsFromRepo);
mockSortOrderService
.Setup(orderService => orderService.OrderBy(standardsFromRepo, It.IsAny <OrderBy>(), It.IsAny <string>()))
.Returns(standardsFromRepo.OrderBy(standard => standard.SearchScore));
var getStandardsListResult = await service.GetStandardsList("", new List <int>(), levelCodes, orderBy, filter);
getStandardsListResult.Should().BeEquivalentTo(standardsFromRepo, StandardEquivalencyAssertionOptions.ExcludingFields);
}
public async Task Then_Gets_A_Standard_From_The_Repository(
string standardUId,
Standard standardFromRepo,
[Frozen] Mock <IStandardRepository> mockStandardsRepository,
StandardsService service)
{
mockStandardsRepository
.Setup(repository => repository.Get(standardUId))
.ReturnsAsync(standardFromRepo);
var expectedEqaProvider = (Domain.Courses.EqaProvider)standardFromRepo;
var expectedVersionDetail = (Domain.Courses.StandardVersionDetail)standardFromRepo;
var standard = await service.GetStandard(standardUId);
standard.Should().BeEquivalentTo(standardFromRepo, StandardEquivalencyAssertionOptions.ExcludingFields);
standard.Route.Should().Be(standardFromRepo.Route.Name);
standard.EqaProvider.Should().BeEquivalentTo(expectedEqaProvider);
standard.VersionDetail.Should().BeEquivalentTo(expectedVersionDetail);
}
public async Task Then_Standards_Are_Ordered_By_SortOrderService(
List <int> levelCodes,
OrderBy orderBy,
StandardFilter filter,
List <Standard> standardsFromRepo,
List <Standard> standardsFromSortService,
[Frozen] Mock <IStandardRepository> mockStandardsRepository,
[Frozen] Mock <IStandardsSortOrderService> mockSortOrderService,
StandardsService service)
{
mockStandardsRepository
.Setup(repository => repository.GetStandards(new List <int>(), levelCodes, filter))
.ReturnsAsync(standardsFromRepo);
mockSortOrderService
.Setup(orderService => orderService.OrderBy(standardsFromRepo, orderBy, ""))
.Returns(standardsFromSortService.OrderBy(standard => standard.SearchScore));
var getStandardsListResult = await service.GetStandardsList("", new List <int>(), levelCodes, orderBy, filter);
getStandardsListResult
.Should().BeEquivalentTo(standardsFromSortService.OrderBy(standard => standard.SearchScore), StandardEquivalencyAssertionOptions.ExcludingFieldsWithStrictOrdering);
}
private void Run()
{
var dbConnFact = new DbConnectionFactory(_config);
using (var conn = dbConnFact.Get())
{
Console.WriteLine($"Importing data:");
Console.WriteLine($" from: {NHSD.GPITF.BuyingCatalog.Settings.GIF_CRM_URL(_config)}");
Console.WriteLine($" into: {conn.ConnectionString}");
Console.WriteLine();
Console.WriteLine($"Retrieving data from CRM:");
#region NHSD data
Console.WriteLine($" Frameworks...");
var frameworksSvc = new FrameworksService(_repo);
var frameworks = frameworksSvc
.GetAll()
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" Capabilities...");
var capsSvc = new CapabilitiesService(_repo);
var caps = capsSvc
.GetAll()
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" Standards...");
var stdsSvc = new StandardsService(_repo);
var stds = stdsSvc
.GetAll()
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" TODO CapabilityFramework...");
Console.WriteLine($" TODO FrameworkStandard...");
Console.WriteLine($" CapabilityStandard...");
var capsStdsSvc = new CapabilitiesStandardService(_repo);
var capsStds = capsStdsSvc
.GetAll()
.Select(x => Converter.FromCrm(x))
.ToList();
#endregion
#region Supplier data
Console.WriteLine($" Organisations...");
var orgsSvc = new OrganisationsService(_repo);
var orgs = orgsSvc
.GetAll()
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" Contacts...");
var contactsSvc = new ContactsService(_repo);
var contacts = orgs
.SelectMany(org => contactsSvc.ByOrganisation(org.Id))
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" Solutions...");
var solnsSvc = new SolutionsService(_repo);
var solns = orgs
.SelectMany(org => solnsSvc.ByOrganisation(org.Id))
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" TechnicalContact...");
var techContSvc = new TechnicalContactService(_repo);
var techConts = solns
.SelectMany(soln => techContSvc.BySolution(soln.Id))
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" TODO FrameworkSolution...");
Console.WriteLine($" ClaimedCapability...");
var claimedCapsSvc = new CapabilitiesImplementedService(_repo);
var claimedCaps = solns
.SelectMany(soln => claimedCapsSvc.BySolution(soln.Id))
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" ClaimedStandard...");
var claimedStdsSvc = new StandardsApplicableService(_repo);
var claimedStds = solns
.SelectMany(soln => claimedStdsSvc.BySolution(soln.Id))
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" ClaimedCapabilityEvidence...");
var claimedCapsEvSvc = new CapabilitiesImplementedEvidenceService(_repo);
var claimedCapsEv = claimedCaps
.SelectMany(claim => claimedCapsEvSvc.ByClaim(claim.Id).SelectMany(x => x))
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" ClaimedStandardEvidence...");
var claimedStdsEvSvc = new StandardsApplicableEvidenceService(_repo);
var claimedStdsEv = claimedStds
.SelectMany(claim => claimedStdsEvSvc.ByClaim(claim.Id).SelectMany(x => x))
.Select(x => Converter.FromCrm(x))
.ToList();
Console.WriteLine($" ClaimedCapabilityReview...");
var claimedCapsRevSvc = new CapabilitiesImplementedReviewsService(_repo);
var claimedCapsRev = claimedCapsEv
.SelectMany(ev => claimedCapsRevSvc.ByEvidence(ev.Id).SelectMany(x => x))
.Select(x => Converter.CapabilitiesImplementedReviewsFromCrm(x))
.ToList();
Console.WriteLine($" ClaimedStandardReview...");
var claimedStdsRevSvc = new StandardsApplicableReviewsService(_repo);
var claimedStdsRev = claimedStdsEv
.SelectMany(ev => claimedStdsRevSvc.ByEvidence(ev.Id).SelectMany(x => x))
.Select(x => Converter.StandardsApplicableReviewsFromCrm(x))
.ToList();
#endregion
Console.WriteLine();
Console.WriteLine($"Importing data into datastore...");
using (var trans = conn.BeginTransaction())
{
// NHSD data
conn.Insert(frameworks, trans);
conn.Insert(caps, trans);
conn.Insert(stds, trans);
conn.Insert(capsStds, trans);
// Supplier data
conn.Insert(orgs, trans);
conn.Insert(contacts, trans);
conn.Insert(solns, trans);
conn.Insert(techConts, trans);
conn.Insert(claimedCaps, trans);
conn.Insert(claimedStds, trans);
conn.Insert(GetInsertionTree(claimedCapsEv), trans);
conn.Insert(GetInsertionTree(claimedStdsEv), trans);
conn.Insert(GetInsertionTree(claimedCapsRev), trans);
conn.Insert(GetInsertionTree(claimedStdsRev), trans);
trans.Commit();
}
Console.WriteLine("Finished!");
}
}
