public async Task ThenItShouldRaiseEventForEstablishmentIfAlreadyExistsNotUpdatedButGroupIsUpdated(PointInTimeGroup stagingGroup, PointInTimeEstablishment stagingEstablishment)
{
// Arrange
var learningProvider = new LearningProvider {
Urn = stagingEstablishment.Urn
};
_mapperMock.Setup(m => m.MapAsync <LearningProvider>(It.IsAny <PointInTimeEstablishment>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(learningProvider);
_groupRepositoryMock.Setup(r => r.GetGroupFromStagingAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(stagingGroup);
_groupRepositoryMock.Setup(r => r.GetGroupAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(CloneWithChanges(stagingGroup, stagingGroup.GroupName + "-updated", false));
_establishmentRepositoryMock.Setup(r =>
r.GetEstablishmentFromStagingAsync(stagingEstablishment.Urn, It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(stagingEstablishment);
_establishmentRepositoryMock.Setup(r => r.GetEstablishmentAsync(stagingEstablishment.Urn, It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Clone(stagingEstablishment));
// Act
await _manager.ProcessGroupAsync(stagingGroup.Uid, new[] { stagingEstablishment.Urn }, stagingGroup.PointInTime, _cancellationToken);
// Assert
_eventPublisherMock.Verify(p => p.PublishLearningProviderUpdatedAsync(
learningProvider,
stagingEstablishment.PointInTime,
_cancellationToken),
Times.Once);
}
public void Summarise_CheckRounding(decimal value1, decimal value2, decimal result)
{
FundingStream fundingStream = GetFundingTypes()
.SelectMany(ft => ft.FundingStreams)
.Single(fs => fs.PeriodCode == "ESF1420" && fs.DeliverableLineCode == 1);
int ukprn = GetProviders().First();
var allocation = GetContractAllocation(ukprn);
var periods = new List <Period>()
{
new Period()
{
PeriodId = 1,
CalendarMonth = 8,
CalendarYear = 2018,
Value = value1,
},
new Period()
{
PeriodId = 1,
CalendarMonth = 8,
CalendarYear = 2018,
Value = value2,
},
};
List <PeriodisedData> periodisedDatas = new List <PeriodisedData>()
{
new PeriodisedData()
{
AttributeName = "StartEarnings",
DeliverableCode = "ST01",
Periods = periods,
},
};
List <LearningDelivery> learningDeliveries = new List <LearningDelivery>()
{
new LearningDelivery()
{
ConRefNumber = "All10000001-1",
PeriodisedData = periodisedDatas,
},
};
LearningProvider testProvider = new LearningProvider()
{
UKPRN = ukprn,
LearningDeliveries = learningDeliveries,
};
var task = new SummarisationDeliverableProcess();
var results = task.Summarise(fundingStream, testProvider, allocation, GetCollectionPeriods());
results.Count.Should().Be(12);
results.FirstOrDefault(w => w.ActualValue > 0).ActualValue.Should().Be(result);
}
private bool IsCorrectlyMappedEntity(LearningProvider learningProvider, string sourceSystemName, Entity actual)
{
var expectedId = sourceSystemName == SourceSystemNames.UkRegisterOfLearningProviders ? actual.Ukprn : actual.Urn;
return(actual.EntityType == EntityNameTranslator.LearningProviderSingular &&
actual.SourceSystemName == sourceSystemName &&
actual.SourceSystemId == expectedId?.ToString() &&
actual.Name == learningProvider.Name &&
actual.Type == learningProvider.Type &&
actual.SubType == learningProvider.SubType &&
actual.Status == learningProvider.Status &&
actual.OpenDate == learningProvider.OpenDate &&
actual.CloseDate == learningProvider.CloseDate &&
actual.Urn == learningProvider.Urn &&
actual.Ukprn == learningProvider.Ukprn &&
actual.Uprn == learningProvider.Uprn &&
actual.CompaniesHouseNumber == learningProvider.CompaniesHouseNumber &&
actual.CharitiesCommissionNumber == learningProvider.CharitiesCommissionNumber &&
actual.AcademyTrustCode == learningProvider.AcademyTrustCode &&
actual.DfeNumber == learningProvider.DfeNumber &&
actual.LocalAuthorityCode == learningProvider.LocalAuthorityCode &&
actual.ManagementGroupType == learningProvider.ManagementGroup?.Type &&
actual.ManagementGroupId == learningProvider.ManagementGroup?.Identifier &&
actual.ManagementGroupUkprn == learningProvider.ManagementGroup?.Ukprn &&
actual.ManagementGroupCompaniesHouseNumber == learningProvider.ManagementGroup?.CompaniesHouseNumber);
}
private LearningProviderSearchDocument MapLearningProviderToSearchDocument(LearningProvider learningProvider,
string source)
{
var searchDocument = new LearningProviderSearchDocument
{
SourceSystemName = source,
Name = learningProvider.Name,
Type = learningProvider.Type,
SubType = learningProvider.SubType,
Status = learningProvider.Status,
OpenDate = learningProvider.OpenDate,
CloseDate = learningProvider.CloseDate,
Urn = learningProvider.Urn,
Ukprn = learningProvider.Ukprn,
Uprn = learningProvider.Uprn,
CompaniesHouseNumber = learningProvider.CompaniesHouseNumber,
CharitiesCommissionNumber = learningProvider.CharitiesCommissionNumber,
AcademyTrustCode = learningProvider.AcademyTrustCode,
DfeNumber = learningProvider.DfeNumber,
LocalAuthorityCode = learningProvider.LocalAuthorityCode,
ManagementGroupType = learningProvider.ManagementGroup?.Type,
ManagementGroupId = learningProvider.ManagementGroup?.Identifier,
};
if (source == SourceSystemNames.UkRegisterOfLearningProviders)
{
searchDocument.SourceSystemId = learningProvider.Ukprn.ToString();
}
else
{
searchDocument.SourceSystemId = learningProvider.Urn.ToString();
}
return(searchDocument);
}
public ICollection <SummarisedActual> Summarise(FundingStream fundingStream, LearningProvider provider, FcsContractAllocation allocation, ICollection <CollectionPeriod> collectionPeriods)
{
var summarisedActuals = new List <SummarisedActual>();
foreach (var fundLine in fundingStream.DeliverableLines)
{
var periodisedData = provider
.LearningDeliveries
.Where(ld => ld.ConRefNumber != null && ld.ConRefNumber.Trim().Equals(allocation.ContractAllocationNumber, StringComparison.OrdinalIgnoreCase))
.SelectMany(x => x.PeriodisedData.Where(w => w.DeliverableCode == fundLine.DeliverableCode));
var periods = GetPeriodsForFundLine(periodisedData, fundLine);
summarisedActuals.AddRange(SummarisePeriods(periods, fundLine, collectionPeriods, allocation));
}
return(summarisedActuals
.GroupBy(grp => grp.Period)
.Select(g =>
new SummarisedActual
{
OrganisationId = allocation.DeliveryOrganisation,
DeliverableCode = fundingStream.DeliverableLineCode,
FundingStreamPeriodCode = fundingStream.PeriodCode,
Period = g.Key,
ActualValue = Math.Round(g.Sum(x => x.ActualValue), 2),
ActualVolume = g.Sum(x => x.ActualVolume),
ContractAllocationNumber = allocation.ContractAllocationNumber,
PeriodTypeCode = PeriodTypeCodeConstants.CalendarMonth
}).ToList());
}
public async Task ThenItShouldRaiseEventForEstablishmentIfAlreadyExistsAndUpdated(PointInTimeLocalAuthority stagingLocalAuthority, PointInTimeEstablishment stagingEstablishment)
{
// Arrange
var learningProvider = new LearningProvider {
Urn = stagingEstablishment.Urn
};
_mapperMock.Setup(m => m.MapAsync <LearningProvider>(It.IsAny <PointInTimeEstablishment>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(learningProvider);
_localAuthorityRepositoryMock.Setup(r => r.GetLocalAuthorityFromStagingAsync(stagingLocalAuthority.Code, stagingLocalAuthority.PointInTime, _cancellationToken))
.ReturnsAsync(stagingLocalAuthority);
_establishmentRepositoryMock.Setup(r =>
r.GetEstablishmentFromStagingAsync(stagingEstablishment.Urn, It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(stagingEstablishment);
_establishmentRepositoryMock.Setup(r => r.GetEstablishmentAsync(stagingEstablishment.Urn, It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(CloneWithChanges(stagingEstablishment, stagingEstablishment.EstablishmentName + "-updated", false));
// Act
await _manager.ProcessLocalAuthorityAsync(stagingLocalAuthority.Code, new[] { stagingEstablishment.Urn }, stagingLocalAuthority.PointInTime, _cancellationToken);
// Assert
_eventPublisherMock.Verify(p => p.PublishLearningProviderUpdatedAsync(
learningProvider,
stagingEstablishment.PointInTime,
_cancellationToken),
Times.Once);
}
private ResolveFieldContext <LearningProvider> BuildLearningProviderResolveFieldContext(
LearningProvider source = null, int year = 2020, string type = "SchoolSummer",
string[] fields = null, AggregationRequestModel[] aggregationRequests = null)
{
if (source == null)
{
source = new LearningProvider();
}
if (fields == null)
{
fields = new[] { "name" };
}
if (aggregationRequests != null && !fields.Any(f => f == "_aggregations"))
{
fields = fields.Concat(new[] { "_aggregations" }).ToArray();
}
var context = TestHelper.BuildResolveFieldContext(
source: source,
arguments: new Dictionary <string, object>
{
{ "year", year },
{ "type", type },
},
fields: fields);
if (aggregationRequests != null)
{
var aggregationsField = context.FieldAst.SelectionSet.Selections
.Select(x => (Field)x)
.Single(f => f.Name == "_aggregations");
aggregationsField.Arguments = new Arguments
{
new Argument(new NameNode("definitions"))
{
Value = new ListValue(aggregationRequests.Select(request =>
new ObjectValue(new[]
{
new ObjectField("name", new StringValue(request.Name)),
new ObjectField("conditions",
new ListValue(request.Conditions.Select(condition =>
new ObjectValue(new[]
{
new ObjectField("field", new StringValue(condition.Field)),
new ObjectField("operator", new StringValue(condition.Operator.ToString().ToUpper())),
new ObjectField("value", new StringValue(condition.Value)),
})))),
}))),
}
};
}
return(context);
}
public async Task ThenItShouldUploadBatchWithSingleDocument(LearningProvider learningProvider)
{
await _manager.SyncAsync(learningProvider, SourceSystemNames.GetInformationAboutSchools,
_cancellationToken);
_searchIndexMock.Verify(i => i.UploadBatchAsync(
It.Is <LearningProviderSearchDocument[]>(a => a.Length == 1),
_cancellationToken),
Times.Once);
}
public async Task SyncAsync(LearningProvider learningProvider, string source,
CancellationToken cancellationToken)
{
var searchDocument = MapLearningProviderToSearchDocument(learningProvider, source);
_logger.Info($"Mapped learning provider to search document: {JsonConvert.SerializeObject(searchDocument)}");
await _searchIndex.UploadBatchAsync(new[] { searchDocument }, cancellationToken);
_logger.Debug($"Successfully uploaded document to search index");
}
public async Task PublishLearningProviderUpdatedAsync(LearningProvider learningProvider, DateTime pointInTime, CancellationToken cancellationToken)
{
var @event = new PointInTimeMiddlewareEvent <LearningProvider>
{
Details = learningProvider,
PointInTime = pointInTime,
};
await SendEventToMiddleware("learning-provider-updated", @event, cancellationToken);
_logger.Debug($"Published learning provider updated: {JsonConvert.SerializeObject(learningProvider)}");
}
public async Task ThenItShouldReturnAcceptedResult(LearningProvider learningProvider, string source)
{
var request = new DefaultHttpRequest(new DefaultHttpContext())
{
Body = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(learningProvider))),
};
var actual = await _function.RunAsync(request, source, _cancellationToken);
Assert.IsNotNull(actual);
Assert.IsInstanceOf <AcceptedResult>(actual);
}
public async Task ThenItShouldMapSourceIdFromUkprnForUkrlp(LearningProvider learningProvider)
{
await _manager.SyncAsync(learningProvider, SourceSystemNames.UkRegisterOfLearningProviders,
_cancellationToken);
_searchIndexMock.Verify(i => i.UploadBatchAsync(
It.Is <LearningProviderSearchDocument[]>(a =>
a.Length == 1 &&
a[0].SourceSystemId == learningProvider.Ukprn.ToString()),
_cancellationToken),
Times.Once);
}
public async Task ThenItShouldReturnLearningProviderIfFound(int urn, LearningProvider provider)
{
_learningProviderManagerMock.Setup(x =>
x.GetLearningProviderAsync(It.IsAny <string>(), null, It.IsAny <bool>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(provider);
var actual = await _function.Run(new DefaultHttpRequest(new DefaultHttpContext()), urn.ToString(),
_cancellationToken);
Assert.IsNotNull(actual);
Assert.IsInstanceOf <FormattedJsonResult>(actual);
Assert.AreSame(provider, ((FormattedJsonResult)actual).Value);
}
static async Task <LearningProvider[]> MapProvidersToLearningProviders(Provider[] providers, CancellationToken cancellationToken)
{
var learningProviders = new LearningProvider[providers.Length];
for (var i = 0; i < providers.Length; i++)
{
_logger.Info($"Starting to map establishment {i} of {providers.Length}");
learningProviders[i] = await _mapper.MapAsync <LearningProvider>(providers[i], cancellationToken);
}
_logger.Info($"Mapped {learningProviders.Length} learning providers");
return(learningProviders);
}
public async Task ThenItShouldPostProviderToProviderCreatedEndpoint(LearningProvider learningProvider, DateTime pointInTime)
{
await _publisher.PublishLearningProviderCreatedAsync(learningProvider, pointInTime, _cancellationToken);
var expectedBody = JsonConvert.SerializeObject(new PointInTimeMiddlewareEvent <LearningProvider>
{
Details = learningProvider,
PointInTime = pointInTime,
});
_restClientMock.Verify(c => c.ExecuteTaskAsync(It.Is <RestRequest>(req =>
req.Method == Method.POST &&
req.Resource == "learning-provider-created" &&
req.Parameters.SingleOrDefault(p => p.Type == ParameterType.RequestBody) != null &&
(string)req.Parameters.Single(p => p.Type == ParameterType.RequestBody).Value == expectedBody), _cancellationToken), Times.Once);
}
public void SomethingSomething()
{
// Arrange
LearningProvider learningProvider = new LearningProvider()
{
Name = "SomeCorp Inc. Acadamies, Ltd",
Address = new Address()
{
AddressLine1 = "SomeCorp House",
AddressLine2 = "123 Example Way",
County = "Leicestershire",
Town = "Enderby",
},
DfeNumber = "ABC/DEF",
Ukprn = 123,
Uprn = "4567890",
Urn = 7262827,
OpenDate = new DateTime(2010, 8, 2),
};
string[] propertiesToInclude = new string[]
{
null,
nameof(LearningProvider.Address),
nameof(LearningProvider.Urn),
nameof(LearningProvider.OpenDate),
string.Empty,
"a field that does not exist",
nameof(LearningProvider.Name),
};
LearningProvider pruned = null;
// Act
pruned = learningProvider.PruneModel(propertiesToInclude);
// Assert
Assert.IsNotNull(pruned.Name);
Assert.IsNotNull(pruned.Address);
Assert.IsNull(pruned.DfeNumber);
Assert.IsNull(pruned.Ukprn);
Assert.IsNull(pruned.Uprn);
Assert.IsNotNull(pruned.Urn);
Assert.IsNotNull(pruned.OpenDate);
}
public ICollection <SummarisedActual> Summarise(
ICollection <FundingStream> fundingStreams,
LearningProvider provider,
ICollection <FcsContractAllocation> allocations,
ICollection <CollectionPeriod> collectionPeriods,
ISummarisationMessage summarisationMessage)
{
var summarisedActuals = new List <SummarisedActual>();
foreach (var fs in fundingStreams)
{
var fundingStreamSummarisedActuals = Summarise(fs, provider, allocations, collectionPeriods, summarisationMessage);
summarisedActuals.AddRange(fundingStreamSummarisedActuals);
}
return(summarisedActuals);
}
public async Task ThenItShouldSyncDeserializedLearningProvider(LearningProvider learningProvider, string source)
{
var request = new DefaultHttpRequest(new DefaultHttpContext())
{
Body = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(learningProvider))),
};
await _function.RunAsync(request, source, _cancellationToken);
_searchManagerMock.Verify(m => m.SyncAsync(
It.Is <LearningProvider>(lp =>
lp.Urn == learningProvider.Urn &&
lp.Ukprn == learningProvider.Ukprn &&
lp.Name == learningProvider.Name),
source,
_cancellationToken),
Times.Once());
}
public async Task <LearningProvider[]> GetLearningProvidersAsync(string[] ids, string[] fields, bool readFromLive, DateTime?pointInTime, CancellationToken cancellationToken)
{
var establishments = readFromLive
? await GetEstablishmentsAsync(ids, pointInTime, GetEstablishmentFromApiAsync, cancellationToken)
: await GetEstablishmentsAsync(ids, pointInTime, GetEstablishmentFromCacheAsync, cancellationToken);
var fieldsString = fields == null || fields.Length == 0 ? null : fields.Aggregate((x, y) => $"{x},{y}");
var providers = new LearningProvider[establishments.Length];
for (var i = 0; i < establishments.Length; i++)
{
if (establishments[i] == null)
{
continue;
}
providers[i] = await GetLearningProviderFromEstablishment(establishments[i], fieldsString, cancellationToken);
}
return(providers);
}
public async Task <LearningProvider[]> GetLearningProvidersAsync(string[] ids, string[] fields, bool readFromLive, DateTime?pointInTime, CancellationToken cancellationToken)
{
var ukprns = new long[ids.Length];
for (var i = 0; i < ids.Length; i++)
{
long ukprn;
if (!long.TryParse(ids[i], out ukprn))
{
throw new ArgumentException($"id must be a number (ukprn) but received {ids[i]} at index {i}", nameof(ids));
}
if (ids[i].Length != 8)
{
throw new ArgumentException($"UKPRN must be 8 digits but received {ids[i].Length} ({ids[i]}) at index {i}", nameof(ids));
}
ukprns[i] = ukprn;
}
var providers = readFromLive
? await _ukrlpApiClient.GetProvidersAsync(ukprns, cancellationToken)
: await _providerRepository.GetProvidersAsync(ukprns, pointInTime, cancellationToken);
var learningProviders = new LearningProvider[ukprns.Length];
for (var i = 0; i < ukprns.Length; i++)
{
var provider = providers.SingleOrDefault(p => p.UnitedKingdomProviderReferenceNumber == ukprns[i]);
if (provider == null)
{
continue;
}
learningProviders[i] = await GetLearningProviderFromUkrlpProviderAsync(provider, fields, cancellationToken);
}
return(learningProviders);
}
public async Task ThenItShouldMapSearchableFieldsFromLearningProvider(LearningProvider learningProvider)
{
await _manager.SyncAsync(learningProvider, SourceSystemNames.GetInformationAboutSchools,
_cancellationToken);
_searchIndexMock.Verify(i => i.UploadBatchAsync(
It.Is <LearningProviderSearchDocument[]>(a =>
a.Length == 1 &&
a[0].Name == learningProvider.Name &&
a[0].Type == learningProvider.Type &&
a[0].SubType == learningProvider.SubType &&
a[0].Status == learningProvider.Status &&
a[0].OpenDate == learningProvider.OpenDate &&
a[0].CloseDate == learningProvider.CloseDate &&
a[0].Urn == learningProvider.Urn &&
a[0].Ukprn == learningProvider.Ukprn &&
a[0].Uprn == learningProvider.Uprn &&
a[0].CompaniesHouseNumber == learningProvider.CompaniesHouseNumber &&
a[0].CharitiesCommissionNumber == learningProvider.CharitiesCommissionNumber &&
a[0].AcademyTrustCode == learningProvider.AcademyTrustCode &&
a[0].DfeNumber == learningProvider.DfeNumber),
_cancellationToken),
Times.Once);
}
public ICollection <SummarisedActual> Summarise(
FundingStream fundingStream,
LearningProvider provider,
ICollection <FcsContractAllocation> allocations,
ICollection <CollectionPeriod> collectionPeriods)
{
var summarisedActuals = new List <SummarisedActual>();
foreach (var fundLine in fundingStream.FundLines)
{
var periodisedData = provider
.LearningDeliveries
.Where(ld => ld.Fundline.Equals(fundLine.Fundline, StringComparison.OrdinalIgnoreCase))
.SelectMany(x => x.PeriodisedData);
var periods = GetPeriodsForFundLine(periodisedData, fundLine);
summarisedActuals.AddRange(SummarisePeriods(periods));
}
var fcsAllocations = allocations.ToDictionary(a => a.FundingStreamPeriodCode, StringComparer.OrdinalIgnoreCase);
return(summarisedActuals
.GroupBy(grp => grp.Period)
.Select(g =>
new SummarisedActual
{
OrganisationId = fcsAllocations[fundingStream.PeriodCode].DeliveryOrganisation,
DeliverableCode = fundingStream.DeliverableLineCode,
FundingStreamPeriodCode = fundingStream.PeriodCode,
Period = collectionPeriods.First(cp => cp.Period == g.Key).ActualsSchemaPeriod,
ActualValue = Math.Round(g.Sum(x => x.ActualValue), 2),
ContractAllocationNumber = fcsAllocations[fundingStream.PeriodCode].ContractAllocationNumber,
PeriodTypeCode = PeriodTypeCodeConstants.CalendarMonth
}).ToList());
}
public async Task ThenItShouldReturnEntitiesFromRepository(LearningProvider learningProvider)
{
_entityRepositoryMock.Setup(r =>
r.LoadLearningProvidersAsync(It.IsAny <LoadLearningProvidersRequest>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new EntityCollection <LearningProvider>
{
SquashedEntityResults = new[]
{
new SquashedEntityResult <LearningProvider>
{
SquashedEntity = learningProvider
},
},
});
var context = BuildResolveFieldContext();
var actual = await _resolver.ResolveAsync(context);
Assert.IsNotNull(actual);
Assert.AreEqual(learningProvider.Urn, actual.Urn);
Assert.AreEqual(learningProvider.Ukprn, actual.Ukprn);
Assert.AreEqual(learningProvider.Name, actual.Name);
}
public ICollection <SummarisedActual> Summarise(
FundingStream fundingStream,
LearningProvider provider,
ICollection <FcsContractAllocation> allocations,
ICollection <CollectionPeriod> collectionPeriods,
ISummarisationMessage summarisationMessage)
{
var summarisedActuals = new List <SummarisedActual>();
int currentCollectionPeriod = summarisationMessage.CollectionMonth;
int previousCollectionYear = 0;
int previousCollectionMonth = 0;
switch (summarisationMessage.CollectionMonth)
{
case 2:
previousCollectionMonth = 13;
previousCollectionYear = summarisationMessage.CollectionYear - 101;
break;
case 3:
previousCollectionMonth = 14;
previousCollectionYear = summarisationMessage.CollectionYear - 101;
break;
default:
previousCollectionMonth = 0;
previousCollectionYear = 0;
break;
}
if (fundingStream.PeriodCode.Equals(FundingStreamConstants.Levy1799, StringComparison.OrdinalIgnoreCase) ||
fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy2019, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w =>
(w.CollectionYear == summarisationMessage.CollectionYear && w.CollectionMonth == summarisationMessage.CollectionMonth)
||
(w.CollectionYear == previousCollectionYear && w.CollectionMonth == previousCollectionMonth)
).ToList();
}
else if (summarisationMessage.CollectionYear == 2021 && fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_APPS2021, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == summarisationMessage.CollectionYear && w.CollectionMonth <= 12).ToList();
}
else if (summarisationMessage.CollectionYear == 2021 && fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_APPS1920, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == previousCollectionYear && w.CollectionMonth <= 12).ToList();
}
else if (summarisationMessage.CollectionYear == 1920 && fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_APPS1920, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == summarisationMessage.CollectionYear && w.CollectionMonth <= 12).ToList();
}
else if (summarisationMessage.CollectionYear == 1920 && fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_APPS1819, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == previousCollectionYear && w.CollectionMonth <= 12).ToList();
}
else if (fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_ANLAP2018, StringComparison.OrdinalIgnoreCase) ||
fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_1618NLAP2018, StringComparison.OrdinalIgnoreCase))
{
// No Filter needed. Need every thing from Collection Periods configuration
}
else
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == summarisationMessage.CollectionYear || w.CollectionYear == previousCollectionYear).ToList();
}
foreach (var fundLine in fundingStream.FundLines)
{
IEnumerable <PeriodisedData> periodisedData;
if (fundLine.LineType.Equals(FundingStreamConstants.LineType_EAS, StringComparison.OrdinalIgnoreCase))
{
periodisedData = provider
.LearningDeliveries
.Where(ld => ld.Fundline.Equals(fundLine.Fundline, StringComparison.OrdinalIgnoreCase))
.SelectMany(x => x.PeriodisedData);
}
else
{
periodisedData = provider
.LearningDeliveries
.Where(ld => ld.Fundline.Equals(fundLine.Fundline, StringComparison.OrdinalIgnoreCase))
.SelectMany(x => x.PeriodisedData
.Where(pd => pd.ApprenticeshipContractType == fundingStream.ApprenticeshipContractType &&
fundingStream.FundingSources.Contains(pd.FundingSource) &&
fundingStream.TransactionTypes.Contains(pd.TransactionType)));
}
var periods = GetPeriodsForFundLine(periodisedData, fundLine);
summarisedActuals.AddRange(SummarisePeriods(periods, collectionPeriods));
}
var fcsAllocations = allocations.GroupBy(g => new { g.FundingStreamPeriodCode, g.DeliveryOrganisation })
.Select(x => new
{
FundingStreamPeriodCode = x.Key.FundingStreamPeriodCode,
DeliveryOrganisation = x.Key.DeliveryOrganisation,
ContractAllocationNumber = allocations.Where(y => x.Key.FundingStreamPeriodCode == y.FundingStreamPeriodCode)
.OrderByDescending(z => z.ContractStartDate)
.ThenByDescending(t => t.ContractEndDate)
.FirstOrDefault()?.ContractAllocationNumber,
}).ToDictionary(a => a.FundingStreamPeriodCode, StringComparer.OrdinalIgnoreCase);
return(summarisedActuals
.GroupBy(grp => grp.Period)
.Select(g =>
new SummarisedActual
{
OrganisationId = fcsAllocations[fundingStream.PeriodCode].DeliveryOrganisation,
DeliverableCode = fundingStream.DeliverableLineCode,
FundingStreamPeriodCode = fundingStream.PeriodCode,
Period = g.Key,
ActualValue = Math.Round(g.Sum(x => x.ActualValue), 2),
ContractAllocationNumber = fcsAllocations[fundingStream.PeriodCode].ContractAllocationNumber,
PeriodTypeCode = PeriodTypeCodeConstants.CalendarMonth
}).ToList());
}
public ICollection <SummarisedActual> Summarise(ICollection <FundingStream> fundingStreams, LearningProvider provider, ICollection <FcsContractAllocation> allocations, ICollection <CollectionPeriod> collectionPeriods, ISummarisationMessage summarisationMessage)
{
var esfAllocations = allocations.Where(w => w.FundingStreamPeriodCode.Equals(FSPcode, StringComparison.OrdinalIgnoreCase));
var summarisedActuals = new List <SummarisedActual>();
foreach (var allocation in esfAllocations)
{
var allocationSummarisedActuals = Summarise(fundingStreams, provider, allocation, collectionPeriods);
summarisedActuals.AddRange(allocationSummarisedActuals);
}
return(summarisedActuals);
}
public ICollection <SummarisedActual> Summarise(ICollection <FundingStream> fundingStreams, LearningProvider provider, FcsContractAllocation allocation, ICollection <CollectionPeriod> collectionPeriods)
{
var summarisedActuals = new List <SummarisedActual>();
foreach (var fundingStream in fundingStreams)
{
var fundingStreamSummarisedActuals = Summarise(fundingStream, provider, allocation, collectionPeriods);
summarisedActuals.AddRange(fundingStreamSummarisedActuals);
}
return(summarisedActuals);
}
public async Task ThenItShouldPublishUpdatedEventIfHasChangedSincePrevious(long ukprn, DateTime pointInTime, LearningProvider learningProvider)
{
_providerRepositoryMock.Setup(r => r.GetProviderAsync(It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new PointInTimeProvider
{
UnitedKingdomProviderReferenceNumber = ukprn,
ProviderName = "old name",
});
_providerRepositoryMock.Setup(r =>
r.GetProviderFromStagingAsync(It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new PointInTimeProvider
{
UnitedKingdomProviderReferenceNumber = ukprn,
ProviderName = ukprn.ToString(),
PointInTime = pointInTime,
});
_mapperMock.Setup(m => m.MapAsync <LearningProvider>(It.IsAny <Provider>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(learningProvider);
await _manager.ProcessBatchOfProviders(new[] { ukprn }, pointInTime, _cancellationToken);
_eventPublisherMock.Verify(
p => p.PublishLearningProviderUpdatedAsync(learningProvider, pointInTime, It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task ThenItShouldRequestCensusForYearTypeAndUrnOfEachProviderInGroup(int year, string type, ManagementGroup source,
LearningProvider learningProvider1, LearningProvider learningProvider2)
{
_registryProviderMock.Setup(reg => reg.GetLinksAsync(
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTime?>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[]
{
new EntityLinkReference
{
LinkType = "ManagementGroup",
SourceSystemName = SourceSystemNames.GetInformationAboutSchools,
SourceSystemId = learningProvider1.Urn.ToString()
},
new EntityLinkReference
{
LinkType = "ManagementGroup",
SourceSystemName = SourceSystemNames.GetInformationAboutSchools,
SourceSystemId = learningProvider2.Urn.ToString()
},
});
var context = BuildManagementGroupResolveFieldContext(source, year, type);
await _censusResolver.ResolveAsync(context);
var expectedId1 = $"{year}_{type}-{nameof(LearningProvider)}-{learningProvider1.Urn}";
var expectedId2 = $"{year}_{type}-{nameof(LearningProvider)}-{learningProvider2.Urn}";
_entityRepositoryMock.Verify(r => r.LoadCensusAsync(
It.Is <LoadCensusRequest>(req =>
req.EntityReferences.Length == 1 &&
req.EntityReferences[0].AdapterRecordReferences.Length == 2 &&
req.EntityReferences[0].AdapterRecordReferences[0].SourceSystemName == SourceSystemNames.IStore &&
req.EntityReferences[0].AdapterRecordReferences[0].SourceSystemId == expectedId1 &&
req.EntityReferences[0].AdapterRecordReferences[1].SourceSystemName == SourceSystemNames.IStore &&
req.EntityReferences[0].AdapterRecordReferences[1].SourceSystemId == expectedId2),
context.CancellationToken),
Times.Once());
}
internal override async Task <TDestination> MapAsync <TDestination>(object source,
CancellationToken cancellationToken)
{
var establishment = source as Establishment;
if (establishment == null)
{
throw new ArgumentException(
$"source must be an Establishment, but received {source.GetType().FullName}", nameof(source));
}
if (typeof(TDestination) != typeof(LearningProvider))
{
throw new ArgumentException(
$"TDestination must be LearningProvider, but received {typeof(TDestination).FullName}",
nameof(source));
}
// Note: These are listed in the same order that the properties
// are ordered in the spi-models lib:
//
// https://github.com/DFE-Digital/spi-models/blob/master/src/Dfe.Spi.Models/Dfe.Spi.Models/Entities/LearningProvider.cs
//
// Which, is in turn, ordered the same in the spreadsheet
// Matt came up with:
//
// https://docs.google.com/spreadsheets/d/1GGvBUJohPLrC_K1Y3irFbH2OPABLPmVdb7lM_Kx2Xao/
//
// If adding new properties, please keep things in order!
var learningProvider = new LearningProvider
{
AdministrativeWardCode = establishment.AdministrativeWard?.Code,
AdministrativeWardName = establishment.AdministrativeWard?.DisplayName,
// TODO: Translate!
AdmissionsPolicy = establishment.AdmissionsPolicy?.Code,
BoardersCode = TryParseCodeAsLong(establishment.Boarders),
BoardersName = establishment.Boarders?.DisplayName,
PruChildcareFacilitiesName = establishment.Ccf?.DisplayName,
CloseDate = establishment.CloseDate,
OfstedLastInspection = establishment.OfstedLastInsp,
DioceseCode = establishment.Diocese?.Code,
DioceseName = establishment.Diocese?.DisplayName,
DistrictAdministrativeCode = establishment.DistrictAdministrative?.Code,
DistrictAdministrativeName = establishment.DistrictAdministrative?.DisplayName,
Easting = establishment.Easting,
PruEbdProvisionCode = TryParseCodeAsLong(establishment.Ebd),
PruEbdProvisionName = establishment.Ebd?.DisplayName,
PruEducatedByOtherProvidersCode = TryParseCodeAsLong(establishment.EdByOther),
PruEducatedByOtherProvidersName = establishment.EdByOther?.DisplayName,
Name = establishment.EstablishmentName,
EstablishmentNumber = establishment.EstablishmentNumber,
// Translatable.
Status = establishment.EstablishmentStatus?.Code,
// Translatable.
Type = establishment.EstablishmentTypeGroup?.Code,
// Translatable.
SubType = establishment.TypeOfEstablishment?.Code,
FurtherEducationTypeName = establishment.FurtherEducationType?.DisplayName,
GenderOfPupilsCode = TryParseCodeAsLong(establishment.Gender),
GenderOfPupilsName = establishment.Gender?.DisplayName,
GovernmentOfficeRegionCode = establishment.Gor?.Code,
GovernmentOfficeRegionName = establishment.Gor?.DisplayName,
GovernmentStatisticalServiceLocalAuthorityCodeName = establishment.GsslaCode?.DisplayName,
InspectorateCode = TryParseCodeAsLong(establishment.Inspectorate),
InspectorateName = establishment.Inspectorate?.DisplayName,
LocalAuthorityCode = establishment.LA?.Code,
LocalAuthorityName = establishment.LA?.DisplayName,
LastChangedDate = establishment.LastChangedDate,
MiddleLayerSuperOutputAreaCode = establishment.Msoa?.Code,
MiddleLayerSuperOutputAreaName = establishment.Msoa?.DisplayName,
Northing = establishment.Northing,
NumberOfPupils = establishment.NumberOfPupils,
SixthFormStatusCode = TryParseCodeAsLong(establishment.OfficialSixthForm),
SixthFormStatusName = establishment.OfficialSixthForm?.DisplayName,
OfstedRatingName = establishment.OfstedRating?.DisplayName,
OpenDate = establishment.OpenDate,
ParliamentaryConstituencyCode = establishment.ParliamentaryConstituency?.Code,
ParliamentaryConstituencyName = establishment.ParliamentaryConstituency?.DisplayName,
PercentageOfPupilsReceivingFreeSchoolMeals = establishment.PercentageFsm,
PhaseOfEducationCode = TryParseCodeAsLong(establishment.PhaseOfEducation),
PhaseOfEducationName = establishment.PhaseOfEducation?.DisplayName,
Postcode = establishment.Postcode,
PreviousEstablishmentNumber = establishment.PreviousEstablishmentNumber,
ClosingReasonCode = TryParseCodeAsLong(establishment.ReasonEstablishmentClosed),
ClosingReasonName = establishment.ReasonEstablishmentClosed?.DisplayName,
OpeningReasonCode = TryParseCodeAsLong(establishment.ReasonEstablishmentOpened),
OpeningReasonName = establishment.ReasonEstablishmentOpened?.DisplayName,
ReligiousEthosCode = TryParseCodeAsLong(establishment.ReligiousEthos),
ReligiousEthosName = establishment.ReligiousEthos?.DisplayName,
ResourcedProvisionCapacity = establishment.ResourcedProvisionCapacity,
ResourcedProvisionNumberOnRoll = establishment.ResourcedProvisionOnRoll,
RegionalSchoolsCommissionerRegionCode = TryParseCodeAsLong(establishment.RscRegion),
RegionalSchoolsCommissionerRegionName = establishment.RscRegion?.DisplayName,
SchoolCapacity = establishment.SchoolCapacity,
Website = establishment.SchoolWebsite,
Section41ApprovedCode = TryParseCodeAsLong(establishment.Section41Approved),
Section41ApprovedName = establishment.Section41Approved?.DisplayName,
SpecialClassesCode = TryParseCodeAsLong(establishment.SpecialClasses),
SpecialClassesName = establishment.SpecialClasses?.DisplayName,
HighestAge = establishment.StatutoryHighAge,
LowestAge = establishment.StatutoryLowAge,
TeenageMotherProvisionCode = TryParseCodeAsLong(establishment.TeenMoth),
TeenageMotherProvisionName = establishment.TeenMoth?.DisplayName,
TeenageMotherPlaces = establishment.TeenMothPlaces,
TelephoneNumber = establishment.TelephoneNum,
AcademyTrustCode = establishment.Trusts?.Code,
AcademyTrustName = establishment.Trusts?.DisplayName,
Ukprn = establishment.Ukprn,
Uprn = establishment.Uprn,
UrbanRuralCode = establishment.UrbanRural?.Code,
UrbanRuralName = establishment.UrbanRural?.DisplayName,
Urn = establishment.Urn,
ManagementGroup = null, // Not populated here - just sitting here for ordering purposes.
CompaniesHouseNumber = establishment.CompaniesHouseNumber,
CharitiesCommissionNumber = establishment.CharitiesCommissionNumber,
// Aggregate of other property values - not pulled or mapped
// from anything in particular.
DfeNumber = CreateDfeNumber(establishment),
LowerLayerSuperOutputAreaCode = establishment.Lsoa?.Code,
LowerLayerSuperOutputAreaName = establishment.Lsoa?.DisplayName,
InspectionDate = establishment.DateOfLastInspectionVisit,
InspectorateReport = establishment.InspectorateReport,
LegalName = null, // Not populated here - just sitting here for ordering purposes.
ContactEmail = establishment.ContactEmail,
AddressLine1 = establishment.Street,
AddressLine2 = establishment.Locality,
AddressLine3 = establishment.Address3,
Town = establishment.Town,
County = establishment.County,
};
DateTime readDate = DateTime.UtcNow;
// Do the translationy bit...
learningProvider.AdmissionsPolicy = await TranslateCodeNamePairAsync(
EnumerationNames.AdmissionsPolicy,
establishment.AdmissionsPolicy,
cancellationToken);
learningProvider.Type = await TranslateCodeNamePairAsync(
EnumerationNames.ProviderType,
establishment.EstablishmentTypeGroup,
cancellationToken);
learningProvider.SubType = await TranslateCodeNamePairAsync(
EnumerationNames.ProviderSubType,
establishment.TypeOfEstablishment,
cancellationToken);
learningProvider.Status = await TranslateCodeNamePairAsync(
EnumerationNames.ProviderStatus,
establishment.EstablishmentStatus,
cancellationToken);
// lineage
learningProvider.SetLineageForRequestedFields();
// Set management group
learningProvider.ManagementGroup = await GetManagementGroup(establishment, cancellationToken);
if (learningProvider.ManagementGroup != null)
{
learningProvider.ManagementGroup._Lineage = null;
}
return(learningProvider as TDestination);
}
public async Task ThenItShouldRequestCensusForYearTypeAndUrn(int year, string type, LearningProvider source)
{
var context = BuildLearningProviderResolveFieldContext(source, year, type);
await _censusResolver.ResolveAsync(context);
var expectedId = $"{year}_{type}-{nameof(LearningProvider)}-{source.Urn}";
_entityRepositoryMock.Verify(r => r.LoadCensusAsync(
It.Is <LoadCensusRequest>(req =>
req.EntityReferences.Length == 1 &&
req.EntityReferences[0].AdapterRecordReferences.Length == 1 &&
req.EntityReferences[0].AdapterRecordReferences[0].SourceSystemName ==
SourceSystemNames.IStore &&
req.EntityReferences[0].AdapterRecordReferences[0].SourceSystemId == expectedId),
context.CancellationToken),
Times.Once());
}
